Update libc to 0.2.126

Test: cd external/rust/crates && atest --host -c
Change-Id: Ic8fc77d9593a59f72653d91cc42fe99424723028

Author: colincross

.cargo_vcs_info.json

@@ -1,6 +1,6 @@
 {
   "git": {
-    "sha1": "abb9b4bb0528a218f23789456d5c1aa0715cace1"
+    "sha1": "5add164cd9beadf360dd6fdc738681e73475d14d"
   },
   "path_in_vcs": ""
 }

Android.bp

@@ -39,10 +39,11 @@ license {
 
 rust_library {
     name: "liblibc",
+    // has rustc warnings
     host_supported: true,
     crate_name: "libc",
     cargo_env_compat: true,
-    cargo_pkg_version: "0.2.119",
+    cargo_pkg_version: "0.2.126",
     srcs: ["src/lib.rs"],
     edition: "2015",
     features: [
@@ -56,10 +57,12 @@ rust_library {
         "libc_cfg_target_vendor",
         "libc_const_size_of",
         "libc_core_cvoid",
+        "libc_int128",
         "libc_non_exhaustive",
         "libc_packedN",
         "libc_priv_mod_use",
         "libc_ptr_addr_of",
+        "libc_underscore_const_names",
         "libc_union",
     ],
     apex_available: [

Cargo.toml

@@ -11,7 +11,7 @@
 
 [package]
 name = "libc"
-version = "0.2.119"
+version = "0.2.126"
 authors = ["The Rust Project Developers"]
 build = "build.rs"
 exclude = [

Cargo.toml.orig

@@ -7,13 +7,13 @@ third_party {
   }
   url {
     type: ARCHIVE
-    value: "https://static.crates.io/crates/libc/libc-0.2.119.crate"
+    value: "https://static.crates.io/crates/libc/libc-0.2.126.crate"
   }
-  version: "0.2.119"
+  version: "0.2.126"
   license_type: NOTICE
   last_upgrade_date {
     year: 2022
-    month: 3
-    day: 1
+    month: 5
+    day: 18
   }
 }

METADATA

@@ -60,6 +60,11 @@ fn main() {
         println!("cargo:rustc-cfg=libc_align");
     }
 
+    // Rust >= 1.26 supports i128 and u128:
+    if rustc_minor_ver >= 26 || rustc_dep_of_std {
+        println!("cargo:rustc-cfg=libc_int128");
+    }
+
     // Rust >= 1.30 supports `core::ffi::c_void`, so libc can just re-export it.
     // Otherwise, it defines an incompatible type to retaining
     // backwards-compatibility.
@@ -82,6 +87,11 @@ fn main() {
         println!("cargo:rustc-cfg=libc_ptr_addr_of");
     }
 
+    // Rust >= 1.37.0 allows underscores as anonymous constant names.
+    if rustc_minor_ver >= 37 || rustc_dep_of_std {
+        println!("cargo:rustc-cfg=libc_underscore_const_names");
+    }
+
     // #[thread_local] is currently unstable
     if rustc_dep_of_std {
         println!("cargo:rustc-cfg=libc_thread_local");

build.rs

@@ -18,3 +18,82 @@ pub type uint16_t = u16;
 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);
+            }
+        }
+    }
+}

src/fixed_width_ints.rs

@@ -25,8 +25,8 @@
 #![cfg_attr(not(feature = "rustc-dep-of-std"), no_std)]
 #![cfg_attr(feature = "rustc-dep-of-std", no_core)]
 #![cfg_attr(
-    any(feature = "rustc-dep-of-std", target_os = "redox"),
-    feature(static_nobundle, native_link_modifiers, native_link_modifiers_bundle)
+    feature = "rustc-dep-of-std",
+    feature(native_link_modifiers, native_link_modifiers_bundle)
 )]
 #![cfg_attr(libc_const_extern_fn, feature(const_extern_fn))]
 

src/lib.rs

@@ -62,7 +62,7 @@ macro_rules! cfg_if {
     };
 }
 
-#[allow(unused_macros)]
+#[allow(unused_macros, unused_macro_rules)]
 macro_rules! s {
     ($($(#[$attr:meta])* pub $t:ident $i:ident { $($field:tt)* })*) => ($(
         s!(it: $(#[$attr])* pub $t $i { $($field)* });

src/macros.rs

@@ -535,8 +535,8 @@ extern "C" {
     pub fn strtod_l(arg1: *const c_char, arg2: *mut *mut c_char, arg3: locale_t) -> f64;
     pub fn strtof_l(arg1: *const c_char, arg2: *mut *mut c_char, arg3: locale_t) -> f32;
     pub fn strtold_l(arg1: *const c_char, arg2: *mut *mut c_char, arg3: locale_t) -> f64;
-    pub fn _Exit(arg1: c_int);
-    pub fn abort();
+    pub fn _Exit(arg1: c_int) -> !;
+    pub fn abort() -> !;
     pub fn abs(arg1: c_int) -> c_int;
     pub fn atexit(arg1: ::Option<unsafe extern "C" fn()>) -> c_int;
     pub fn atoi(arg1: *const c_char) -> c_int;
@@ -553,7 +553,7 @@ extern "C" {
     ) -> *mut c_void;
     pub fn calloc(arg1: size_t, arg2: size_t) -> *mut c_void;
     pub fn div(arg1: c_int, arg2: c_int) -> div_t;
-    pub fn exit(arg1: c_int);
+    pub fn exit(arg1: c_int) -> !;
     pub fn free(arg1: *mut c_void);
     pub fn getenv(arg1: *const c_char) -> *mut c_char;
     pub fn labs(arg1: c_long) -> c_long;