Add cfg option gnu_time64_abi

The gnu_time64_abi option indicates that a 32-bit arch should use
64-bit time_t and 64-bit off_t and simliar file related types.

32-bit platforms are identified by CARGO_CFG_TARGET_POINTER_WIDTH, but
x86_64-unknown-linux-gnux32 is a 64-bit platform and should not use
gnu_time64_abi even if it has 32-bit pointers.

riscv32 is a 32-bit platform but has always used 64-bit types for
time and file operations.  It should not use the gnu_time64_abi

The default - all relevant platforms should use 64-bit time - can be
overridden by setting the RUST_LIBC_TIME_BITS environment variable to
32.  It can also be set to 64 to force gnu_time64_abi, or default
which is the same as leaving it unset.  The last two options are
mainly useful for CI flows.

Author: snogge

build.rs

@@ -14,6 +14,7 @@ const ALLOWED_CFGS: &'static [&'static str] = &[
     "freebsd13",
     "freebsd14",
     "freebsd15",
+    "gnu_time64_abi",
     "libc_const_extern_fn",
     "libc_const_extern_fn_unstable",
     "libc_deny_warnings",
@@ -67,6 +68,11 @@ fn main() {
         Some(_) | None => (),
     }
 
+    // Some ABIs need to redirect time related symbols to their time64 equivalents.
+    if is_gnu_time64_abi() {
+        set_cfg("gnu_time64_abi");
+    }
+
     // On CI: deny all warnings
     if libc_ci {
         set_cfg("libc_deny_warnings");
@@ -205,3 +211,64 @@ fn set_cfg(cfg: &str) {
     }
     println!("cargo:rustc-cfg={}", cfg);
 }
+
+fn is_gnu_time64_abi() -> bool {
+    match env::var("CARGO_CFG_TARGET_ENV") {
+        Ok(target_env) => {
+            if target_env != "gnu" {
+                return false;
+            }
+        }
+        Err(_) => panic!("CARGO_CFG_TARGET_ENV not set"),
+    }
+    match env::var("CARGO_CFG_TARGET_OS") {
+        Ok(target_os) => {
+            if target_os != "linux" {
+                return false;
+            }
+        }
+        Err(_) => panic!("CARGO_CFG_TARGET_OS not set"),
+    }
+    match env::var("CARGO_CFG_TARGET_POINTER_WIDTH") {
+        Ok(bits) => {
+            if bits == "64" {
+                return false;
+            }
+        }
+        Err(_) => panic!("CARGO_CFG_TARGET_POINTER_WIDTH not set"),
+    }
+    match env::var("CARGO_CFG_TARGET_ARCH") {
+        Ok(bits) => {
+            if bits == "riscv32" {
+                return false;
+            }
+        }
+        Err(_) => panic!("CARGO_CFG_TARGET_ARCH not set"),
+    }
+    match env::var("RUST_LIBC_TIME_BITS") {
+        Ok(time_bits) => {
+            if time_bits == "64" {
+                return true;
+            }
+            if time_bits == "32" {
+                return false;
+            }
+            if time_bits != "default" {
+                panic!("Invalid value for RUST_LIBC_TIME_BITS");
+            }
+        }
+        Err(_) => {}
+    }
+    // At this point, we _know_ it is *-*-linux-gnu* with 32 bit
+    // pointers. Some 64 bit arch still have 32 bit pointers though.
+    match env::var("TARGET") {
+        Ok(target) => {
+            // x86_64-unknown-linux-gnux32 and similar
+            if target.contains("x86_64") && target.contains("x32") {
+                return false;
+            }
+        }
+        Err(_) => panic!("TARGET not set"),
+    }
+    return true;
+}