WIP attempt to implement user_fpsimd_struct.

Potentially fixes #2524, see the comments in the patch for details.

Author: Gankra

libc-test/semver/android-aarch64.txt

@@ -12,3 +12,4 @@ SYS_syscalls
 SYS_fcntl
 __system_property_wait
 user_regs_struct
+user_fpsimd_struct

src/fixed_width_ints.rs

@@ -18,3 +18,75 @@ pub type uint16_t = u16;
 pub type uint32_t = u32;
 #[deprecated(since = "0.2.55", note = "Use u64 instead.")]
 pub type uint64_t = u64;
+
+
+/// This module introduces partial support for FFI with __int128 and
+/// equivalent types on platforms where Rust's definition is validated
+/// to match the standard C ABI of that platform.
+///
+/// Rust does not guarantee u128/i128 are sound for FFI, and its
+/// definitions are in fact known to be incompatible. [0]
+///
+/// However these problems aren't fundamental, and are just platform
+/// inconsistencies. Specifically at the time of this writing:
+///
+/// * For x64 SysV ABIs (everything but Windows), the types are underaligned.
+/// * For all Windows ABIs, Microsoft doesn't actually officially define __int128,
+///   and as a result different implementations don't actually agree on its ABI.
+///
+/// But on the major aarch64 platforms (android, macos, ios) we have validated
+/// that rustc has the right ABI for these types. This is important because
+/// aarch64 uses these types in some fundamental OS types like user_fpsimd_struct,
+/// which represents saved simd registers.
+///
+/// Any API which uses these types will need to `#[ignore(improper_ctypes)]`
+/// until the upstream rust issue is resolved, but this at least lets us make
+/// progress on platforms where this type is important.
+///
+/// The supported architectures and OSes is intentionally very restricted,
+/// as careful work needs to be done to verify that a particular platform
+/// has a conformant ABI.
+///
+/// [0]: https://github.com/rust-lang/rust/issues/54341
+mod supported_128 {
+    cfg_if! {
+        if #[cfg(all(target_arch = "aarch64",
+            any(target_os = "android", target_os="macos", target_os = "ios")))] {
+
+            /// C `__int128` (a GCC extension that's part of many ABIs)
+            pub type __int128 = i128;
+            /// C `unsigned __int128` (a GCC extension that's part of many ABIs)
+            pub type __uint128 = u128;
+            /// C __int128_t (alternate name for [__int128][])
+            pub type __int128_t = i128;
+            /// C __uint128_t (alternate name for [__uint128][])
+            pub type __uint128_t = u128;
+
+            // NOTE: if you add more platforms to here, you made need to cfg
+            // these consts. They should always match the platform's values
+            // for `sizeof(__int128)` and `_Alignof(__int128)`.
+            const SIZE_128: usize = 16;
+            const ALIGN_128: usize = 16;
+
+            /// Since Rust doesn't officially guarantee that these types
+            /// have compatible ABIs, we const assert that these values have the
+            /// known size/align of the target platform's libc. If rustc ever
+            /// tries to regress things, it will cause a compilation error.
+            const _ASSERT_128_COMPAT: () = {
+                assert!(std::mem::size_of::<__int128>() == SIZE_128);
+                assert!(std::mem::align_of::<__int128>() == ALIGN_128);
+
+                assert!(std::mem::size_of::<__uint128>() == SIZE_128);
+                assert!(std::mem::align_of::<__uint128>() == ALIGN_128);
+
+                assert!(std::mem::size_of::<__int128_t>() == SIZE_128);
+                assert!(std::mem::align_of::<__int128_t>() == ALIGN_128);
+
+                assert!(std::mem::size_of::<__uint128_t>() == SIZE_128);
+                assert!(std::mem::align_of::<__uint128_t>() == ALIGN_128);
+            };
+        }
+    }
+}
+
+pub use self::supported_128::*;

src/unix/bsd/apple/b64/aarch64/align.rs

@@ -39,9 +39,8 @@ s! {
         pub __pad: u32,
     }
 
-    #[repr(align(16))]
     pub struct __darwin_arm_neon_state64 {
-        pub __v: [[u64; 2]; 32],
+        pub __v: [__uint128_t; 32],
         pub __fpsr: u32,
         pub __fpcr: u32,
     }

src/unix/linux_like/android/b64/aarch64/mod.rs

@@ -55,6 +55,12 @@ s! {
         pub pc: u64,
         pub pstate: u64,
     }
+
+    pub struct user_fpsimd_struct {
+        pub vregs: [__uint128_t; 32],
+        pub fpsr: u32,
+        pub fpcr: u32,
+    }
 }
 
 pub const O_DIRECT: ::c_int = 0x10000;