    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99

    //! This module contains type aliases for C's fixed-width integer types .
    //!
    //! These aliases are deprecated: use the Rust types instead.

    #[deprecated(since = "0.2.55", note = "Use i8 instead.")]
    pub type int8_t = i8;
    #[deprecated(since = "0.2.55", note = "Use i16 instead.")]
    pub type int16_t = i16;
    #[deprecated(since = "0.2.55", note = "Use i32 instead.")]
    pub type int32_t = i32;
    #[deprecated(since = "0.2.55", note = "Use i64 instead.")]
    pub type int64_t = i64;
    #[deprecated(since = "0.2.55", note = "Use u8 instead.")]
    pub type uint8_t = u8;
    #[deprecated(since = "0.2.55", note = "Use u16 instead.")]
    pub type uint16_t = u16;
    #[deprecated(since = "0.2.55", note = "Use u32 instead.")]
    pub type uint32_t = u32;
    #[deprecated(since = "0.2.55", note = "Use u64 instead.")]
    pub type uint64_t = u64;

    cfg_if! {
        if #[cfg(all(libc_int128, target_arch = "aarch64", not(target_os = "windows")))] {
            // This 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 other major aarch64 platforms (android, linux, ios, macos) 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 list of 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

            /// 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;

            cfg_if! {
                if #[cfg(libc_underscore_const_names)] {
                    macro_rules! static_assert_eq {
                        ($a:expr, $b:expr) => {
                            const _: [(); $a] = [(); $b];
                        };
                    }

                    // NOTE: if you add more platforms to here, you may 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.
                    //
                    // This isn't a bullet-proof solution because e.g. it doesn't
                    // catch the fact that llvm and gcc disagree on how x64 __int128
                    // is actually *passed* on the stack (clang underaligns it for
                    // the same reason that rustc *never* properly aligns it).
                    static_assert_eq!(core::mem::size_of::<__int128>(), _SIZE_128);
                    static_assert_eq!(core::mem::align_of::<__int128>(), _ALIGN_128);

                    static_assert_eq!(core::mem::size_of::<__uint128>(), _SIZE_128);
                    static_assert_eq!(core::mem::align_of::<__uint128>(), _ALIGN_128);

                    static_assert_eq!(core::mem::size_of::<__int128_t>(), _SIZE_128);
                    static_assert_eq!(core::mem::align_of::<__int128_t>(), _ALIGN_128);

                    static_assert_eq!(core::mem::size_of::<__uint128_t>(), _SIZE_128);
                    static_assert_eq!(core::mem::align_of::<__uint128_t>(), _ALIGN_128);
                }
            }
        }
    }