windows: expose cfg for 64-bit time_t

Use `gnu_time_bits64` on Windows x86 GNU to expose a 64-bit `time_t`.
`time_t` is always 64-bits on Windows. The target environment matters
not. There's a feature test macro to make it 32-bits wide. In `libc` we
expose it as 32-bits in Windows x86 GNU. This is wrong. Folks need to
experiment with correct behavior. The 32-bit routines are linked in that
case.

Author: dybucc

build.rs

@@ -24,7 +24,8 @@ const ALLOWED_CFGS: &[&str] = &[
     "freebsd15",
     // Corresponds to `_FILE_OFFSET_BITS=64` in glibc
     "gnu_file_offset_bits64",
-    // Corresponds to `_TIME_BITS=64` in glibc
+    // Corresponds to `_TIME_BITS=64` in glibc. Also used in Windows to fix
+    // faulty `time_t` bindings.
     "gnu_time_bits64",
     "libc_deny_warnings",
     // Corresponds to `__USE_TIME_BITS64` in UAPI
@@ -144,7 +145,7 @@ fn main() {
     }
 
     if target_env == "gnu"
-        && target_os == "linux"
+        && matches!(target_os.as_str(), "linux" | "windows")
         && target_ptr_width == "32"
         && target_arch != "riscv32"
         && target_arch != "x86_64"
@@ -173,7 +174,7 @@ fn main() {
         let (timebits, filebits) = match (tb_env.as_deref(), fb_env.as_deref()) {
             (Ok(_), Ok(_)) => panic!(
                 "Do not set both libc_unstable_gnu_time_bits and \
-                libc_unstable_gnu_file_offset_bits"
+                 libc_unstable_gnu_file_offset_bits"
             ),
             (Err(_), Err(_)) => (defaultbits, defaultbits),
             (Ok(tb), Err(_)) if tb == "64" => (tb, tb),

libc-test/build.rs

@@ -12,6 +12,7 @@ use std::path::{
     PathBuf,
 };
 use std::{
+    assert_matches,
     env,
     io,
 };
@@ -784,6 +785,31 @@ fn test_windows(target: &str) {
     }
     cfg.define("_WIN32_WINNT", Some("0x8000"));
 
+    // Needed for the Windows `time_t` test.
+    println!("cargo::rustc-check-cfg=cfg(gnu_time_bits64)");
+
+    let redirect_time_t = if gnu && i686 {
+        if let Ok(v) = env::var("CARGO_CFG_LIBC_UNSTABLE_GNU_TIME_BITS") {
+            assert_matches!(
+                v.as_str(),
+                "32" | "64",
+                "Invalid value for `libc_unstable_gnu_time_bits`. Must be 32, 64 or unset."
+            );
+
+            if v == "64" {
+                cfg.cfg("gnu_time_bits64", None);
+                println!("cargo::rustc-cfg=gnu_time_bits64");
+                true
+            } else {
+                false
+            }
+        } else {
+            false
+        }
+    } else {
+        false
+    };
+
     headers!(
         cfg,
         "direct.h",
@@ -841,7 +867,7 @@ fn test_windows(target: &str) {
         "SSIZE_T" if !gnu => true,
         "ssize_t" if !gnu => true,
         // FIXME(windows): The size and alignment of this type are incorrect
-        "time_t" if gnu && i686 => true,
+        "time_t" if gnu && i686 && !redirect_time_t => true,
         _ => false,
     });
 

libc-test/tests/windows_time.rs

@@ -11,7 +11,11 @@
 /// functions that expect it as a parameter.
 #[test]
 fn test_bitwidth_store() {
-    if cfg!(all(target_arch = "x86", target_env = "gnu")) {
+    if cfg!(all(
+        target_arch = "x86",
+        target_env = "gnu",
+        not(gnu_time_bits64),
+    )) {
         assert_eq!(size_of::<libc::time_t>(), 4);
     } else {
         assert_eq!(size_of::<libc::time_t>(), 8);

src/windows/mod.rs

@@ -19,7 +19,13 @@ pub type clock_t = i32;
 pub type errno_t = c_int;
 
 cfg_if! {
-    if #[cfg(all(target_arch = "x86", target_env = "gnu"))] {
+    // FIXME(1.0): Windows GNU has 64-bit `time_t` by default. In x86 this is
+    // wrongly bound.
+    if #[cfg(all(
+        target_arch = "x86",
+        target_env = "gnu",
+        not(gnu_time_bits64)
+    ))] {
         pub type time_t = i32;
     } else {
         pub type time_t = i64;
@@ -395,7 +401,11 @@ extern "C" {
     // Under Windows x86 with GNU, `time_t` is still 32-bit wide on stable, so
     // these routines have to link with their 32-bit variants.
     cfg_if! {
-        if #[cfg(all(target_arch = "x86", target_env = "gnu"))] {
+        if #[cfg(all(
+            target_arch = "x86",
+            target_env = "gnu",
+            not(gnu_time_bits64),
+        ))] {
             #[link_name = "_ctime32"]
             pub fn ctime(sourceTime: *const time_t) -> *mut c_char;
             #[link_name = "_difftime32"]