feat: add support for 32 bit time_t in windows

This commit adds support symmetric to that offered in Linux for using
32-bit `time_t` in Windows. This PR also removes some of the `skip()`
functions in Windows, as it renames some symbols to properly reflect
whether they are 32-bit or 64-bit compliant, and adds deprecation
notices to functions that were are not supported by Microsoft anymore
(as per their security guidelines.)

There's a few functions that are altogether missing and yet do appear in
the Windows CRT docs, but that's work for another PR.

Author: dybucc

.github/workflows/ci.yaml

@@ -128,6 +128,11 @@ jobs:
           #  env: { ARCH_BITS: 32, ARCH: i686 }
           - target: i686-pc-windows-msvc
             os: windows-2025
+            env: { ARCH_BITS: 32, ARCH: i686 }
+          - target: i686-pc-windows-msvc
+            os: windows-2025
+            env: { ARCH_BITS: 32, ARCH: i686, RUST_LIBC_UNSTABLE_WINDOWS_TIME32: 1 }
+            artifact-tag: windows_time32
           - target: i686-unknown-linux-gnu
           - target: x86_64-pc-windows-gnu
             os: windows-2025

build.rs

@@ -1,12 +1,6 @@
 use std::env::VarError;
-use std::process::{
-    Command,
-    Output,
-};
-use std::{
-    env,
-    str,
-};
+use std::process::{Command, Output};
+use std::{env, str};
 
 // List of cfgs this build script is allowed to set. The list is needed to support check-cfg, as we
 // need to know all the possible cfgs that this script will set. If you need to set another cfg
@@ -31,6 +25,8 @@ const ALLOWED_CFGS: &[&str] = &[
     // Corresponds to `_REDIR_TIME64` in musl
     "musl32_time64",
     "vxworks_lt_25_09",
+    // Corresponds to `_USE_32BIT_TIME_T` in Windows CRT
+    "windows_use_time32",
 ];
 
 // Extra values to allow for check-cfg.
@@ -123,6 +119,11 @@ fn main() {
         }
     }
 
+    let windows_use_time32 = env::var("RUST_LIBC_UNSTABLE_WINDOWS_TIME32").is_ok();
+    println!("cargo:rerun-if-env-changed=RUST_LIBC_UNSTABLE_WINDOWS_TIME32");
+    if windows_use_time32 {
+        set_cfg("windows_use_time32");
+    }
     let linux_time_bits64 = env::var("RUST_LIBC_UNSTABLE_LINUX_TIME_BITS64").is_ok();
     println!("cargo:rerun-if-env-changed=RUST_LIBC_UNSTABLE_LINUX_TIME_BITS64");
     if linux_time_bits64 {

ci/install-rust.sh

@@ -38,7 +38,7 @@ if [ -n "${INSTALL_RUST_SRC:-}" ]; then
 fi
 
 if [ "$os" = "windows" ]; then
-    if [ "${ARCH_BITS:-}" = "i686" ]; then
+    if [ "${ARCH:-}" = "i686" ]; then
         echo "Install MinGW32"
         choco install mingw --x86 --force
     fi

ctest-test/src/t1.rs

@@ -1,16 +1,9 @@
 #![allow(dead_code)]
 
-use std::ffi::{
-    c_char,
-    c_double,
-    c_int,
-    c_long,
-    c_uint,
-    c_void,
-};
+use std::ffi::{c_char, c_double, c_int, c_long, c_uint, c_void};
 
 pub type T1Foo = i32;
-pub const T1S: *const c_char = b"foo\0".as_ptr().cast();
+pub const T1S: *const c_char = c"foo".as_ptr().cast();
 
 pub const T1N: i32 = 5;
 

ctest-test/src/t2.rs

@@ -1,9 +1,6 @@
 #![allow(non_camel_case_types)]
 
-use std::ffi::{
-    c_char,
-    c_int,
-};
+use std::ffi::{c_char, c_int};
 
 pub type T2Foo = u32;
 pub type T2Bar = u32;
@@ -33,7 +30,7 @@ pub union T2Union {
 pub const T2C: i32 = 5;
 
 i! {
-    pub const T2S: *const c_char = b"b\0".as_ptr().cast();
+    pub const T2S: *const c_char = c"b".as_ptr().cast();
 }
 
 extern "C" {

ctest/src/ffi_items.rs

@@ -2,22 +2,14 @@
 
 use std::ops::Deref;
 
-use syn::punctuated::Punctuated;
-use syn::visit::Visit;
-
-use crate::{
-    Abi,
-    BoxStr,
-    Const,
-    Field,
-    Fn,
-    Parameter,
-    Static,
-    Struct,
-    Type,
-    Union,
+use syn::{
+    Attribute, Expr, ExprLit, Fields, FnArg, ForeignItem, ForeignItemFn, ForeignItemStatic,
+    ItemConst, ItemForeignMod, ItemStruct, ItemType, ItemUnion, Lit, Meta, MetaNameValue, Pat,
+    ReturnType, punctuated::Punctuated, visit::Visit,
 };
 
+use crate::{Abi, BoxStr, Const, Field, Fn, Parameter, Static, Struct, Type, Union};
+
 /// Represents a collected set of top-level Rust items relevant to FFI generation or analysis.
 ///
 /// Includes foreign functions/statics, type aliases, structs, unions, and constants.
@@ -105,7 +97,7 @@ fn collect_fields(fields: &Punctuated<syn::Field, syn::Token![,]>) -> Vec<Field>
         .collect()
 }
 
-fn extract_single_link_name(attrs: &[syn::Attribute]) -> Option<BoxStr> {
+fn extract_single_link_name(attrs: &[Attribute]) -> Option<BoxStr> {
     let mut link_name_iter = attrs
         .iter()
         .filter(|attr| attr.path().is_ident("link_name"));
@@ -115,17 +107,17 @@ fn extract_single_link_name(attrs: &[syn::Attribute]) -> Option<BoxStr> {
         panic!("multiple `#[link_name = ...]` attributes found: {attr:?}");
     }
 
-    if let syn::Meta::NameValue(nv) = &link_name.meta
-        && let syn::Expr::Lit(expr_lit) = &nv.value
-        && let syn::Lit::Str(lit_str) = &expr_lit.lit
+    if let Meta::NameValue(MetaNameValue { value, .. }) = &link_name.meta
+        && let Expr::Lit(ExprLit { lit, .. }) = value
+        && let Lit::Str(lit_str) = lit
     {
         return Some(lit_str.value().into_boxed_str());
     }
 
     panic!("unrecognized `link_name` syntax: {link_name:?}");
 }
 
-fn visit_foreign_item_fn(table: &mut FfiItems, i: &syn::ForeignItemFn, abi: &Abi) {
+fn visit_foreign_item_fn(table: &mut FfiItems, i: &ForeignItemFn, abi: &Abi) {
     let public = is_visible(&i.vis);
     let abi = abi.clone();
     let ident = i.sig.ident.to_string().into_boxed_str();
@@ -134,23 +126,22 @@ fn visit_foreign_item_fn(table: &mut FfiItems, i: &syn::ForeignItemFn, abi: &Abi
         .inputs
         .iter()
         .map(|arg| match arg {
-            syn::FnArg::Typed(arg) => Parameter {
-                ident: match arg.pat.deref() {
-                    syn::Pat::Ident(i) => i.ident.to_string().into_boxed_str(),
-                    _ => {
-                        unimplemented!("Foreign functions are unlikely to have any other pattern.")
-                    }
+            FnArg::Typed(arg) => Parameter {
+                ident: if let Pat::Ident(i) = arg.pat.deref() {
+                    i.ident.to_string().into_boxed_str()
+                } else {
+                    unimplemented!("Foreign functions are unlikely to have any other pattern.");
                 },
                 ty: arg.ty.deref().clone(),
             },
-            syn::FnArg::Receiver(_) => {
+            FnArg::Receiver(_) => {
                 unreachable!("Foreign functions can't have self/receiver parameters.")
             }
         })
-        .collect::<Vec<_>>();
+        .collect();
     let return_type = match &i.sig.output {
-        syn::ReturnType::Default => None,
-        syn::ReturnType::Type(_, ty) => Some(ty.deref().clone()),
+        ReturnType::Default => None,
+        ReturnType::Type(_, ty) => Some(ty.deref().clone()),
     };
     let link_name = extract_single_link_name(&i.attrs);
 
@@ -164,7 +155,7 @@ fn visit_foreign_item_fn(table: &mut FfiItems, i: &syn::ForeignItemFn, abi: &Abi
     });
 }
 
-fn visit_foreign_item_static(table: &mut FfiItems, i: &syn::ForeignItemStatic, abi: &Abi) {
+fn visit_foreign_item_static(table: &mut FfiItems, i: &ForeignItemStatic, abi: &Abi) {
     let public = is_visible(&i.vis);
     let abi = abi.clone();
     let ident = i.ident.to_string().into_boxed_str();
@@ -181,21 +172,21 @@ fn visit_foreign_item_static(table: &mut FfiItems, i: &syn::ForeignItemStatic, a
 }
 
 impl<'ast> Visit<'ast> for FfiItems {
-    fn visit_item_type(&mut self, i: &'ast syn::ItemType) {
+    fn visit_item_type(&mut self, i: &'ast ItemType) {
         let public = is_visible(&i.vis);
         let ty = i.ty.deref().clone();
         let ident = i.ident.to_string().into_boxed_str();
 
         self.aliases.push(Type { public, ident, ty });
     }
 
-    fn visit_item_struct(&mut self, i: &'ast syn::ItemStruct) {
+    fn visit_item_struct(&mut self, i: &'ast ItemStruct) {
         let public = is_visible(&i.vis);
         let ident = i.ident.to_string().into_boxed_str();
         let fields = match &i.fields {
-            syn::Fields::Named(fields) => collect_fields(&fields.named),
-            syn::Fields::Unnamed(fields) => collect_fields(&fields.unnamed),
-            syn::Fields::Unit => Vec::new(),
+            Fields::Named(fields) => collect_fields(&fields.named),
+            Fields::Unnamed(_) => Vec::new(),
+            Fields::Unit => Vec::new(),
         };
 
         self.structs.push(Struct {
@@ -205,7 +196,7 @@ impl<'ast> Visit<'ast> for FfiItems {
         });
     }
 
-    fn visit_item_union(&mut self, i: &'ast syn::ItemUnion) {
+    fn visit_item_union(&mut self, i: &'ast ItemUnion) {
         let public = is_visible(&i.vis);
         let ident = i.ident.to_string().into_boxed_str();
         let fields = collect_fields(&i.fields.named);
@@ -217,15 +208,15 @@ impl<'ast> Visit<'ast> for FfiItems {
         });
     }
 
-    fn visit_item_const(&mut self, i: &'ast syn::ItemConst) {
+    fn visit_item_const(&mut self, i: &'ast ItemConst) {
         let public = is_visible(&i.vis);
         let ident = i.ident.to_string().into_boxed_str();
         let ty = i.ty.deref().clone();
 
         self.constants.push(Const { public, ident, ty });
     }
 
-    fn visit_item_foreign_mod(&mut self, i: &'ast syn::ItemForeignMod) {
+    fn visit_item_foreign_mod(&mut self, i: &'ast ItemForeignMod) {
         // Because we need to store the ABI we can't directly visit the foreign
         // functions/statics.
 
@@ -235,12 +226,12 @@ impl<'ast> Visit<'ast> for FfiItems {
             .name
             .clone()
             .map(|s| Abi::from(s.value().as_str()))
-            .unwrap_or_else(|| Abi::C);
+            .unwrap_or(Abi::C);
 
         for item in &i.items {
             match item {
-                syn::ForeignItem::Fn(function) => visit_foreign_item_fn(self, function, &abi),
-                syn::ForeignItem::Static(static_variable) => {
+                ForeignItem::Fn(function) => visit_foreign_item_fn(self, function, &abi),
+                ForeignItem::Static(static_variable) => {
                     visit_foreign_item_static(self, static_variable, &abi)
                 }
                 _ => (),

libc-test/build.rs

@@ -1,20 +1,11 @@
 #![deny(warnings)]
 #![allow(clippy::match_like_matches_macro)]
 
-use std::fs::File;
-use std::io::{
-    BufRead,
-    BufReader,
-    BufWriter,
-    Write,
-};
-use std::path::{
-    Path,
-    PathBuf,
-};
 use std::{
     env,
-    io,
+    fs::File,
+    io::{self, BufRead, BufReader, BufWriter, Write},
+    path::{Path, PathBuf},
 };
 
 fn do_cc() {
@@ -76,7 +67,7 @@ fn do_ctest() {
         t if t.contains("windows") => test_windows(t),
         t if t.contains("vxworks") => test_vxworks(t),
         t if t.contains("nto-qnx") => test_neutrino(t),
-        t if t.contains("aix") => return test_aix(t),
+        t if t.contains("aix") => test_aix(t),
         t => panic!("unknown target {t}"),
     }
 }
@@ -735,7 +726,6 @@ fn test_cygwin(target: &str) {
 fn test_windows(target: &str) {
     assert!(target.contains("windows"));
     let gnu = target.contains("gnu");
-    let i686 = target.contains("i686");
 
     let mut cfg = ctest_cfg();
 
@@ -744,6 +734,11 @@ fn test_windows(target: &str) {
     }
     cfg.define("_WIN32_WINNT", Some("0x8000"));
 
+    if env::var("RUST_LIBC_UNSTABLE_WINDOWS_TIME32").is_ok() {
+        cfg.define("_USE_32BIT_TIME_T", None);
+        cfg.cfg("windows_use_time32", None);
+    }
+
     headers!(
         cfg,
         "direct.h",
@@ -772,23 +767,18 @@ fn test_windows(target: &str) {
             // Just pass all these through, no need for a "struct" prefix
             "FILE" | "DIR" | "Dl_info" => ty.to_string().into(),
             t if t.ends_with("_t") => t.to_string().into(),
-            // Windows uppercase structs don't have `struct` in fr.into()ont:
+            // Windows uppercase structs don't have `struct` in front:
             t if ty.chars().next().unwrap().is_uppercase() => t.to_string().into(),
-            "stat" => "struct __stat64".to_string().into(),
-            "utimbuf" => "struct __utimbuf64".to_string().into(),
             _ => None,
         }
     });
-    cfg.rename_type(move |ty| {
-        match ty {
-            // FIXME(windows): these don't exist:
-            "time64_t" => "__time64_t".to_string().into(),
-            "ssize_t" => "SSIZE_T".to_string().into(),
 
-            "sighandler_t" if !gnu => "_crt_signal_t".to_string().into(),
-            "sighandler_t" if gnu => "__p_sig_fn_t".to_string().into(),
-            _ => None,
-        }
+    cfg.rename_type(move |ty| match ty {
+        "time64_t" => "__time64_t".to_string().into(),
+        "ssize_t" => "SSIZE_T".to_string().into(),
+        "sighandler_t" if !gnu => "_crt_signal_t".to_string().into(),
+        "sighandler_t" if gnu => "__p_sig_fn_t".to_string().into(),
+        _ => None,
     });
 
     cfg.rename_fn(move |func| {
@@ -800,19 +790,9 @@ fn test_windows(target: &str) {
     cfg.skip_alias(move |alias| match alias.ident() {
         "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,
         _ => false,
     });
 
-    cfg.skip_struct(move |struct_| {
-        match struct_.ident() {
-            // FIXME(windows): The size and alignment of this struct are incorrect
-            "timespec" if gnu && i686 => true,
-            _ => false,
-        }
-    });
-
     cfg.skip_const(move |constant| {
         match constant.ident() {
             // FIXME(windows): API error:
@@ -1380,7 +1360,6 @@ fn test_netbsd(target: &str) {
     });
 
     cfg.skip_fn(move |func| {
-        #[expect(clippy::wildcard_in_or_patterns)]
         match func.ident() {
             // FIXME(netbsd): Look into setting `_POSIX_C_SOURCE` to enable this
             "qsort_r" => true,
@@ -3085,11 +3064,8 @@ fn test_emscripten(target: &str) {
     });
 
     cfg.skip_alias(|ty| {
-        match ty.ident() {
-            // LFS64 types have been removed in Emscripten 3.1.44
-            // https://github.com/emscripten-core/emscripten/pull/19812
-            ty => ty.ends_with("64") || ty.ends_with("64_t"),
-        }
+        let ty = ty.ident();
+        ty.ends_with("64") || ty.ends_with("64_t")
     });
 
     cfg.skip_struct(move |struct_| {