| 1 |
//! This module contains type aliases for C's fixed-width integer types . |
| 2 |
//! |
| 3 |
//! These aliases are deprecated: use the Rust types instead. |
| 4 |
|
| 5 |
#[deprecated(since = "0.2.55", note = "Use i8 instead.")] |
| 6 |
pub type int8_t = i8; |
| 7 |
#[deprecated(since = "0.2.55", note = "Use i16 instead.")] |
| 8 |
pub type int16_t = i16; |
| 9 |
#[deprecated(since = "0.2.55", note = "Use i32 instead.")] |
| 10 |
pub type int32_t = i32; |
| 11 |
#[deprecated(since = "0.2.55", note = "Use i64 instead.")] |
| 12 |
pub type int64_t = i64; |
| 13 |
#[deprecated(since = "0.2.55", note = "Use u8 instead.")] |
| 14 |
pub type uint8_t = u8; |
| 15 |
#[deprecated(since = "0.2.55", note = "Use u16 instead.")] |
| 16 |
pub type uint16_t = u16; |
| 17 |
#[deprecated(since = "0.2.55", note = "Use u32 instead.")] |
| 18 |
pub type uint32_t = u32; |
| 19 |
#[deprecated(since = "0.2.55", note = "Use u64 instead.")] |
| 20 |
pub type uint64_t = u64; |
| 21 |
|
| 22 |
cfg_if! { |
| 23 |
if #[cfg(all(libc_int128, target_arch = "aarch64", not(target_os = "windows")))] { |
| 24 |
// This introduces partial support for FFI with __int128 and |
| 25 |
// equivalent types on platforms where Rust's definition is validated |
| 26 |
// to match the standard C ABI of that platform. |
| 27 |
// |
| 28 |
// Rust does not guarantee u128/i128 are sound for FFI, and its |
| 29 |
// definitions are in fact known to be incompatible. [0] |
| 30 |
// |
| 31 |
// However these problems aren't fundamental, and are just platform |
| 32 |
// inconsistencies. Specifically at the time of this writing: |
| 33 |
// |
| 34 |
// * For x64 SysV ABIs (everything but Windows), the types are underaligned. |
| 35 |
// * For all Windows ABIs, Microsoft doesn't actually officially define __int128, |
| 36 |
// and as a result different implementations don't actually agree on its ABI. |
| 37 |
// |
| 38 |
// But on the other major aarch64 platforms (android, linux, ios, macos) we have |
| 39 |
// validated that rustc has the right ABI for these types. This is important because |
| 40 |
// aarch64 uses these types in some fundamental OS types like user_fpsimd_struct, |
| 41 |
// which represents saved simd registers. |
| 42 |
// |
| 43 |
// Any API which uses these types will need to `#[ignore(improper_ctypes)]` |
| 44 |
// until the upstream rust issue is resolved, but this at least lets us make |
| 45 |
// progress on platforms where this type is important. |
| 46 |
// |
| 47 |
// The list of supported architectures and OSes is intentionally very restricted, |
| 48 |
// as careful work needs to be done to verify that a particular platform |
| 49 |
// has a conformant ABI. |
| 50 |
// |
| 51 |
// [0]: https://github.com/rust-lang/rust/issues/54341 |
| 52 |
|
| 53 |
/// C `__int128` (a GCC extension that's part of many ABIs) |
| 54 |
pub type __int128 = i128; |
| 55 |
/// C `unsigned __int128` (a GCC extension that's part of many ABIs) |
| 56 |
pub type __uint128 = u128; |
| 57 |
/// C __int128_t (alternate name for [__int128][]) |
| 58 |
pub type __int128_t = i128; |
| 59 |
/// C __uint128_t (alternate name for [__uint128][]) |
| 60 |
pub type __uint128_t = u128; |
| 61 |
|
| 62 |
cfg_if! { |
| 63 |
if #[cfg(libc_underscore_const_names)] { |
| 64 |
macro_rules! static_assert_eq { |
| 65 |
($a:expr, $b:expr) => { |
| 66 |
const _: [(); $a] = [(); $b]; |
| 67 |
}; |
| 68 |
} |
| 69 |
|
| 70 |
// NOTE: if you add more platforms to here, you may need to cfg |
| 71 |
// these consts. They should always match the platform's values |
| 72 |
// for `sizeof(__int128)` and `_Alignof(__int128)`. |
| 73 |
const _SIZE_128: usize = 16; |
| 74 |
const _ALIGN_128: usize = 16; |
| 75 |
|
| 76 |
// Since Rust doesn't officially guarantee that these types |
| 77 |
// have compatible ABIs, we const assert that these values have the |
| 78 |
// known size/align of the target platform's libc. If rustc ever |
| 79 |
// tries to regress things, it will cause a compilation error. |
| 80 |
// |
| 81 |
// This isn't a bullet-proof solution because e.g. it doesn't |
| 82 |
// catch the fact that llvm and gcc disagree on how x64 __int128 |
| 83 |
// is actually *passed* on the stack (clang underaligns it for |
| 84 |
// the same reason that rustc *never* properly aligns it). |
| 85 |
static_assert_eq!(core::mem::size_of::<__int128>(), _SIZE_128); |
| 86 |
static_assert_eq!(core::mem::align_of::<__int128>(), _ALIGN_128); |
| 87 |
|
| 88 |
static_assert_eq!(core::mem::size_of::<__uint128>(), _SIZE_128); |
| 89 |
static_assert_eq!(core::mem::align_of::<__uint128>(), _ALIGN_128); |
| 90 |
|
| 91 |
static_assert_eq!(core::mem::size_of::<__int128_t>(), _SIZE_128); |
| 92 |
static_assert_eq!(core::mem::align_of::<__int128_t>(), _ALIGN_128); |
| 93 |
|
| 94 |
static_assert_eq!(core::mem::size_of::<__uint128_t>(), _SIZE_128); |
| 95 |
static_assert_eq!(core::mem::align_of::<__uint128_t>(), _ALIGN_128); |
| 96 |
} |
| 97 |
} |
| 98 |
} |
| 99 |
} |