fix: fix differing bitwidth routines in win x86 gnu

Until [rust-lang#5032], whenever `libc` was running under Windows x86 with GNU,
the default bit-width of `time_t` values was 32-bits. This doesn't quite
align with the defaults in MSVC and `mingw`, but that's been addressed in
that PR.

This PR is a quick patch for stable, as the changes in [rust-lang#5032] are not
backwards-compatible. It separates the routines that under Windows use
`time_t` values and changes their link-time symbols to the 32-bit
variants exposed in both MSVC and `mingw`, for the affected target
platform/environment.

[rust-lang#5032]: rust-lang#5032

Author: dybucc

.github/workflows/windows.yml

@@ -0,0 +1,32 @@
+name: Windows test
+
+on: workflow_dispatch
+
+defaults:
+  run:
+    shell: bash
+
+jobs:
+  test:
+    name: Test
+    runs-on: windows-2025
+    strategy:
+      matrix:
+        include:
+          - target: x86_64-pc-windows-msvc
+          - target: i686-pc-windows-gnu
+    env:
+      TARGET: ${{ matrix.target }}
+    steps:
+      - uses: actions/checkout@v6
+      - name: Set up Rust toolchain
+        run: |
+          if [ "$TARGET" = "i686-pc-windows-gnu" ]; then
+            rustup target add i686-pc-windows-gnu
+          fi
+          rustup default nightly-$TARGET
+          rustc -Vv
+      - name: Test
+        run: |
+          cd ./libc-test
+          cargo t --target ${{ matrix.target }}

libc-test/tests/windows_time.rs

@@ -0,0 +1,29 @@
+//! Ensures Windows `time`-related routines align with `libc`'s interface. By
+//! default, both MSVC and GNU (under `mingw`) expose 64-bit symbols. `libc`
+//! also does that, but there's been slight inconsistencies in the past.
+
+#![cfg(windows)]
+
+/// Ensures a 64-bit write is performed on values that should always be 64 bits.
+/// This may fail if
+/// (1) the routine links with its 32-bit variant. This only happens if
+///     `_USE_32BIT_TIME_T` is defined. In theory, this should not be
+///     possible when working with Rust's `libc`.
+/// (2) Or `time_t` is 32-bits, and a 64-bit write overwrites both array items.
+///     This should neither be possible unless the above macro is defined.
+///     Support for non-64-bit values in `libc` should thus be non-existent.
+#[test]
+fn test_64_bit_store() {
+    #[cfg(all(target_arch = "x86", target_env = "gnu"))]
+    assert_eq!(size_of::<libc::time_t>(), 4);
+    #[cfg(not(all(target_arch = "x86", target_env = "gnu")))]
+    assert_eq!(size_of::<libc::time_t>(), 8);
+
+    let mut time_values: [libc::time_t; 2] = [123, 456];
+    let ptr = time_values.as_mut_ptr();
+
+    unsafe { libc::time(ptr) };
+
+    assert!(time_values[0] != 123);
+    assert_eq!(time_values[1], 456);
+}

src/windows/mod.rs

@@ -390,10 +390,6 @@ extern "C" {
     pub fn raise(signum: c_int) -> c_int;
 
     pub fn clock() -> clock_t;
-    pub fn ctime(sourceTime: *const time_t) -> *mut c_char;
-    pub fn difftime(timeEnd: time_t, timeStart: time_t) -> c_double;
-    #[link_name = "_gmtime64_s"]
-    pub fn gmtime_s(destTime: *mut tm, srcTime: *const time_t) -> c_int;
     #[link_name = "_get_daylight"]
     pub fn get_daylight(hours: *mut c_int) -> errno_t;
     #[link_name = "_get_dstbias"]
@@ -407,10 +403,6 @@ extern "C" {
         size_in_bytes: size_t,
         index: c_int,
     ) -> errno_t;
-    #[link_name = "_localtime64_s"]
-    pub fn localtime_s(tmDest: *mut tm, sourceTime: *const time_t) -> crate::errno_t;
-    #[link_name = "_time64"]
-    pub fn time(destTime: *mut time_t) -> time_t;
     #[link_name = "_tzset"]
     pub fn tzset();
     #[link_name = "_chmod"]
@@ -549,6 +541,33 @@ extern "C" {
     ) -> crate::errno_t;
 }
 
+// By default, the following link to 64-bit variants where the expected `time_t`
+// is also 64-bits.
+#[cfg(not(all(target_arch = "x86", target_env = "gnu")))]
+extern "C" {
+    pub fn ctime(sourceTime: *const time_t) -> *mut c_char;
+    pub fn difftime(timeEnd: time_t, timeStart: time_t) -> c_double;
+    pub fn gmtime_s(destTime: *mut tm, srcTime: *const time_t) -> c_int;
+    pub fn localtime_s(tmDest: *mut tm, sourceTime: *const time_t) -> crate::errno_t;
+    pub fn time(destTime: *mut time_t) -> time_t;
+}
+
+// Under Windows x86 with GNU, `time_t` is still 32-bit wide on stable, so the
+// above routines have to link with their 32-bit variants.
+#[cfg(all(target_arch = "x86", target_env = "gnu"))]
+extern "C" {
+    #[link_name = "_ctime32"]
+    pub fn ctime(sourceTime: *const time_t) -> *mut c_char;
+    #[link_name = "_difftime32"]
+    pub fn difftime(timeEnd: time_t, timeStart: time_t) -> c_double;
+    #[link_name = "_gmtime32_s"]
+    pub fn gmtime_s(destTime: *mut tm, srcTime: *const time_t) -> c_int;
+    #[link_name = "_localtime32_s"]
+    pub fn localtime_s(tmDest: *mut tm, sourceTime: *const time_t) -> crate::errno_t;
+    #[link_name = "_time32"]
+    pub fn time(destTime: *mut time_t) -> time_t;
+}
+
 extern "system" {
     pub fn listen(s: SOCKET, backlog: c_int) -> c_int;
     pub fn accept(s: SOCKET, addr: *mut crate::sockaddr, addrlen: *mut c_int) -> SOCKET;