[libc] Make time_t 64 bits long on all platforms but arm32

[mikhail.ramalho]

Summary

This patch changes the size of time_t to be an int64_t. This still
follows the POSIX standard which only requires time_t to be an integer.

Making time_t a 64-bit integer also fixes two cases in 32 bits platforms
that use SYS_clock_nanosleep_time64 and SYS_clock_gettime64, as the name
of these calls implies, they require a 64-bit time_t. For instance, in rv32,
the 32-bit version of these syscalls is not available.

We also follow glibc here, where time_t is still a 32-bit integer in
arm32.

[mikhail.ramalho]

ping

[mikhail.ramalho]

• define time64_t as INT64_TYPE
• rebased

[mikhail.ramalho]

• define INT64_TYPE time_t
• Rebased

[sivachandra]

libc/src/time/linux/clockGetTimeImpl.h

17 ↗

(On Diff #556284)

cstdint is a C++ header which we cannot include in the runtime code. Use stdint.h.

[mikhail.ramalho]

• Fix header include

[mikhail.ramalho]

ping

libc/config/linux/api.td

let Types = [
     "__atexithandler_t",
   ];
 }
 
 def TimeAPI : PublicAPI<"time.h"> {
   let Types = [
     "clock_t",
     "time_t",
+    "time64_t",
     "struct tm",
     "struct timespec",
+    "struct timespec64",
     "struct timeval",
     "clockid_t",
   ];
 }
 
 def SchedAPI : PublicAPI<"sched.h"> {
   let Types = [
     "pid_t",
     "size_t",
     "cpu_set_t",
     "struct sched_param",
     // Needed according to posix standard
     "time_t",
     "struct timespec",
+    "time64_t",
+    "struct timespec64",
   ];
 }
 
 def SysMManAPI : PublicAPI<"sys/mman.h"> {
   let Types = ["off_t", "size_t"];
 }
 
 def SignalAPI : PublicAPI<"signal.h"> {

 }
 
 def SysRandomAPI : PublicAPI<"sys/random.h"> {
   let Types = ["size_t", "ssize_t"];
 }
 
 def SysSelectAPI : PublicAPI<"sys/select.h"> {
   let Types = ["fd_set", "sigset_t", "suseconds_t", "time_t", "struct timespec",
-               "struct timeval"];
+               "time64_t", "struct timespec64", "struct timeval"];
 }
 
 def SysSocketAPI : PublicAPI<"sys/socket.h"> {
   let Types = ["struct sockaddr", "sa_family_t"];
 }
 
 def SysResourceAPI : PublicAPI<"sys/resource.h"> {
   let Types = ["rlim_t", "struct rlimit", "rlim64_t", "struct rlimit64"];
 }
 
 def SysStatAPI : PublicAPI<"sys/stat.h"> {
   let Types = ["mode_t", "dev_t", "ino_t", "nlink_t", "uid_t", "gid_t", "off_t",
-               "struct timespec", "struct timeval", "blksize_t", "blkcnt_t",
-               "struct stat"];
+               "struct timespec", "struct timespec64", "struct timeval", "blksize_t",
+               "blkcnt_t", "struct stat"];
 }
 
 def SysWaitAPI : PublicAPI<"sys/wait.h"> {
   let Types = ["pid_t", "struct rusage", "siginfo_t"];
 }
 
 def SysSendfileAPI : PublicAPI<"sys/sendfile.h"> {
   let Types = ["off_t", "size_t", "ssize_t"];
 }
 
 def SysTypesAPI : PublicAPI<"sys/types.h"> {
   let Types = ["blkcnt_t", "blksize_t", "clockid_t", "dev_t", "gid_t", "ino_t",
                "mode_t", "nlink_t", "off_t", "pid_t", "pthread_attr_t", "pthread_key_t",
                "pthread_mutex_t", "pthread_mutexattr_t", "pthread_once_t", "pthread_t",
-               "size_t", "ssize_t", "suseconds_t", "time_t", "uid_t"];
+               "size_t", "ssize_t", "suseconds_t", "time_t", "time64_t", "uid_t"];
 }
 
 def SysUtsNameAPI : PublicAPI<"sys/utsname.h"> {
   let Types = ["struct utsname"];
 }
 
 def SpawnAPI : PublicAPI<"spawn.h"> {
   let Types = ["mode_t", "pid_t", "posix_spawnattr_t", "posix_spawn_file_actions_t"];

libc/include/CMakeLists.txt

add_gen_header(
   time
   DEF_FILE time.h.def
   GEN_HDR time.h
   DEPENDS
     .llvm_libc_common_h
     .llvm-libc-macros.time_macros
     .llvm-libc-types.clock_t
     .llvm-libc-types.time_t
+    .llvm-libc-types.time64_t
     .llvm-libc-types.struct_tm
     .llvm-libc-types.struct_timespec
+    .llvm-libc-types.struct_timespec64
     .llvm-libc-types.struct_timeval
     .llvm-libc-types.clockid_t
 )
 
 add_gen_header(
   threads
   DEF_FILE threads.h.def
   GEN_HDR threads.h
DEPENDS
     .llvm-libc-macros.sched_macros
     .llvm-libc-types.cpu_set_t
     .llvm-libc-types.pid_t
     .llvm-libc-types.size_t
     .llvm-libc-types.struct_sched_param
     # Needed according to posix standard
     .llvm-libc-types.time_t
     .llvm-libc-types.struct_timespec
+    .llvm-libc-types.time64_t
+    .llvm-libc-types.struct_timespec64
 )
 
 add_gen_header(
   spawn
   DEF_FILE spawn.h.def
   GEN_HDR spawn.h
   DEPENDS
     .llvm_libc_common_h
DEPENDS
     .llvm-libc-types.mode_t
     .llvm-libc-types.dev_t
     .llvm-libc-types.ino_t
     .llvm-libc-types.nlink_t
     .llvm-libc-types.uid_t
     .llvm-libc-types.gid_t
     .llvm-libc-types.off_t
     .llvm-libc-types.struct_timespec
+    .llvm-libc-types.struct_timespec64
     .llvm-libc-types.struct_timeval
     .llvm-libc-types.blksize_t
     .llvm-libc-types.blkcnt_t
     .llvm-libc-types.struct_stat
 )
 
 add_gen_header(
   sys_select
   DEF_FILE sys/select.h.def
   GEN_HDR sys/select.h
   DEPENDS
     .llvm_libc_common_h
     .llvm-libc-macros.sys_select_macros
     .llvm-libc-types.fd_set
     .llvm-libc-types.sigset_t
     .llvm-libc-types.suseconds_t
     .llvm-libc-types.time_t
     .llvm-libc-types.struct_timespec
+    .llvm-libc-types.time64_t
+    .llvm-libc-types.struct_timespec64
     .llvm-libc-types.struct_timeval
 )
 
 add_gen_header(
   sys_sendfile
   DEF_FILE sys/sendfile.h.def
   GEN_HDR sys/sendfile.h
   DEPENDS
DEPENDS
     .llvm-libc-types.pthread_mutex_t
     .llvm-libc-types.pthread_mutexattr_t
     .llvm-libc-types.pthread_once_t
     .llvm-libc-types.pthread_t
     .llvm-libc-types.size_t
     .llvm-libc-types.ssize_t
     .llvm-libc-types.suseconds_t
     .llvm-libc-types.time_t
+    .llvm-libc-types.time64_t
     .llvm-libc-types.uid_t
 )
 
 add_gen_header(
   sys_utsname
   DEF_FILE sys/utsname.h.def
   GEN_HDR sys/utsname.h
   DEPENDS

libc/include/llvm-libc-types/CMakeLists.txt

 add_header(pthread_key_t HDR pthread_key_t.h)
 add_header(pthread_mutex_t HDR pthread_mutex_t.h DEPENDS .__futex_word .__mutex_type)
 add_header(pthread_t HDR pthread_t.h DEPENDS .__thread_type)
 add_header(pthread_mutexattr_t HDR pthread_mutexattr_t.h)
 add_header(pthread_once_t HDR pthread_once_t.h DEPENDS .__futex_word)
 add_header(rlim_t HDR rlim_t.h)
 add_header(rlim64_t HDR rlim64_t.h)
 add_header(time_t HDR time_t.h)
+add_header(time64_t HDR time64_t.h)
 add_header(stack_t HDR stack_t.h)
 add_header(suseconds_t HDR suseconds_t.h)
 add_header(struct_timeval HDR struct_timeval.h DEPENDS .suseconds_t .time_t)
 add_header(struct_rlimit HDR struct_rlimit.h DEPENDS .rlim_t)
 add_header(struct_rlimit64 HDR struct_rlimit64.h DEPENDS .rlim64_t)
 add_header(struct_rusage HDR struct_rusage.h DEPENDS .struct_timeval)
 add_header(struct_dirent HDR struct_dirent.h DEPENDS .ino_t .off_t)
 add_header(struct_sched_param HDR struct_sched_param.h)
 add_header(union_sigval HDR union_sigval.h)
 add_header(siginfo_t HDR siginfo_t.h DEPENDS .union_sigval .pid_t .uid_t)
 add_header(sig_atomic_t HDR sig_atomic_t.h)
 add_header(sigset_t HDR sigset_t.h DEPENDS libc.include.llvm-libc-macros.signal_macros)
 add_header(struct_sigaction HDR struct_sigaction.h DEPENDS .sigset_t .siginfo_t)
 add_header(struct_timespec HDR struct_timespec.h DEPENDS .time_t)
+add_header(struct_timespec64 HDR struct_timespec64.h DEPENDS .time64_t)
 add_header(
   struct_stat
   HDR struct_stat.h
   DEPENDS
     .dev_t .ino_t .mode_t .nlink_t .uid_t .gid_t .off_t .struct_timespec
-    .blksize_t .blkcnt_t
+    .struct_timespec64 .blksize_t .blkcnt_t
 )
 add_header(struct_tm HDR struct_tm.h)
 add_header(struct_utsname HDR struct_utsname.h)
 add_header(thrd_start_t HDR thrd_start_t.h)
 add_header(thrd_t HDR thrd_t.h DEPENDS .__thread_type)
 add_header(tss_t HDR tss_t.h)
 add_header(tss_dtor_t HDR tss_dtor_t.h)
 add_header(__atexithandler_t HDR __atexithandler_t.h)

libc/include/llvm-libc-types/struct_sched_param.h

 //===-- Definition of type struct sched_param -----------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef __LLVM_LIBC_TYPES_STRUCT_SCHED_PARAM_H__
 #define __LLVM_LIBC_TYPES_STRUCT_SCHED_PARAM_H__
 
 #include <llvm-libc-types/pid_t.h>
 #include <llvm-libc-types/struct_timespec.h>
+#include <llvm-libc-types/struct_timespec64.h>
+#include <llvm-libc-types/time64_t.h>
 #include <llvm-libc-types/time_t.h>
 
 struct sched_param {
   // Process or thread execution scheduling priority.
   int sched_priority;
 };
 
 #endif // __LLVM_LIBC_TYPES_STRUCT_SCHED_PARAM_H__

libc/include/llvm-libc-types/struct_stat.h

 #include <llvm-libc-types/blksize_t.h>
 #include <llvm-libc-types/dev_t.h>
 #include <llvm-libc-types/gid_t.h>
 #include <llvm-libc-types/ino_t.h>
 #include <llvm-libc-types/mode_t.h>
 #include <llvm-libc-types/nlink_t.h>
 #include <llvm-libc-types/off_t.h>
 #include <llvm-libc-types/struct_timespec.h>
+#include <llvm-libc-types/struct_timespec64.h>
 #include <llvm-libc-types/uid_t.h>
 
 struct stat {
   dev_t st_dev;
   ino_t st_ino;
   mode_t st_mode;
   nlink_t st_nlink;
   uid_t st_uid;

libc/include/llvm-libc-types/struct_timespec64.h

+//===-- Definition of struct timespec64 -----------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef __LLVM_LIBC_TYPES_TIMESPEC64_H__
+#define __LLVM_LIBC_TYPES_TIMESPEC64_H__
+
+#include <llvm-libc-types/time64_t.h>
+
+struct timespec64 {
+  time64_t tv_sec; /* Seconds.  */
+  /* TODO: BIG_ENDIAN may require padding. */
+  long tv_nsec; /* Nanoseconds.  */
+};
+
+#endif // __LLVM_LIBC_TYPES_TIMESPEC64_H__

libc/include/llvm-libc-types/time64_t.h

+//===-- Definition of the type time64_t -----------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef __LLVM_LIBC_TYPES_TIME64_T_H__
+#define __LLVM_LIBC_TYPES_TIME64_T_H__
+
+typedef __UINT64_TYPE__ time64_t;
+
+#endif // __LLVM_LIBC_TYPES_TIME64_T_H__

libc/spec/posix.td

 def DIRPtr : PtrType<DIR>;
 def DIRRestrictedPtr : RestrictedPtrType<DIR>;
 def StructDirent : NamedType<"struct dirent">;
 def StructDirentPtr : PtrType<StructDirent>;
 def StructDirentPtrPtr : PtrType<StructDirentPtr>;
 def ConstStructDirentPtrPtr : ConstType<StructDirentPtrPtr>;
 
 def StructTimeSpec : NamedType<"struct timespec">;
+def StructTimeSpec64 : NamedType<"struct timespec64">;
 def StructTimeSpecPtr : PtrType<StructTimeSpec>;
 
 def StructSchedParam : NamedType<"struct sched_param">;
 def StructSchedParamPtr : PtrType<StructSchedParam>;
 def ConstStructSchedParamPtr : ConstType<StructSchedParamPtr>;
 
 def ExecArgvT : NamedType<"__exec_argv_t">;
 def ExecEnvpT : NamedType<"__exec_envp_t">;
[
           [ArgSpec<ConstCharPtr>]
         >,
     ]
   >;
 
   HeaderSpec Sched = HeaderSpec<
       "sched.h",
       [], // Macros
-      [PidT, TimeTType, StructTimeSpec, StructSchedParam], // Types
+      [PidT, TimeTType, Time64TType, StructTimeSpec, StructTimeSpec64, StructSchedParam], // Types
       [], // Enumerations
       [
         FunctionSpec<
             "sched_yield",
             RetValSpec<IntType>,
             [ArgSpec<VoidType>]
         >,
         FunctionSpec<
HeaderSpec SysStat = HeaderSpec<
     [], // Macros
     [
         ModeTType,
         DevT,
         InoT,
         UidT,
         GidT,
         StructTimeSpec,
+        StructTimeSpec64,
         StructTimevalType,
         BlkSizeT,
         BlkCntT,
         OffTType,
         NLinkT,
         StatType,
     ], // Types
     [], // Enumerations
HeaderSpec Dirent = HeaderSpec<
               [ArgSpec<DIRPtr>]
           >,
       ]
   >;
 
   HeaderSpec Time = HeaderSpec<
       "time.h",
       [], // Macros
-      [ClockIdT, StructTimeSpec, StructTimevalType], // Types
+      [ClockIdT, StructTimeSpec, StructTimeSpec64, StructTimevalType], // Types
       [], // Enumerations
       [
           FunctionSpec<
               "clock_gettime",
               RetValSpec<IntType>,
               [ArgSpec<ClockIdT>, ArgSpec<StructTimeSpecPtr>]
           >,
           FunctionSpec<
[
         [ArgSpec<IntType>, ArgSpec<IntType>, ArgSpec<StructTermiosPtr>]
       >,
     ]
   >;
 
   HeaderSpec SysSelect = HeaderSpec<
     "sys/select.h",
     [], // Macros
-    [FdSet, SigSetType, StructTimevalType, StructTimeSpec, SuSecondsT, TimeTType],
+    [FdSet, SigSetType, StructTimevalType, StructTimeSpec, StructTimeSpec64, SuSecondsT, TimeTType, Time64TType],
     [], // Enumerations
     [
       FunctionSpec<
         "select",
         RetValSpec<IntType>,
         [
             ArgSpec<IntType>, ArgSpec<RestrictedFdSetPtr>, ArgSpec<RestrictedFdSetPtr>,
             ArgSpec<RestrictedFdSetPtr>, ArgSpec<RestrictedStructTimevalPtr>
HeaderSpec SysSocket = HeaderSpec<
       ]  // Functions
   >;
 
   HeaderSpec SysTypes = HeaderSpec<
     "sys/types.h",
     [], // Macros
     [BlkCntT, BlkSizeT, ClockIdT, DevT, GidT, InoT, ModeTType, NLinkT, OffTType, PidT,
      PThreadAttrTType, PThreadKeyT, PThreadMutexTType, PThreadMutexAttrTType, PThreadOnceT, PThreadTType,
-     SizeTType, SSizeTType, SuSecondsT, TimeTType, UidT],
+     SizeTType, SSizeTType, SuSecondsT, TimeTType, Time64TType, UidT],
     [], // Enumerations
     []  // Functions
   >;
 
   let Headers = [
     ArpaInet,
     CType,
     Dirent,

libc/spec/spec.td

 def IntPtr : PtrType<IntType>;
 def RestrictedIntPtr : RestrictedPtrType<IntType>;
 def FloatPtr : PtrType<FloatType>;
 def DoublePtr : PtrType<DoubleType>;
 
 def SigHandlerT : NamedType<"__sighandler_t">;
 
 def TimeTType : NamedType<"time_t">;
+def Time64TType : NamedType<"time64_t">;
 
 def BSearchCompareT : NamedType<"__bsearchcompare_t">;
 def QSortCompareT : NamedType<"__qsortcompare_t">;
 
 def AtexitHandlerT : NamedType<"__atexithandler_t">;
 
 def FILE : NamedType<"FILE">;
 def FILEPtr : PtrType<FILE>;

libc/spec/stdc.td

 
   HeaderSpec Time = HeaderSpec<
       "time.h",
       [], // Macros
       [ // Types
          ClockT,
          StructTmType,
          TimeTType,
+         Time64TType,
       ],
       [], // Enumerations
       [
           FunctionSpec<
               "asctime",
               RetValSpec<CharPtr>,
               [ArgSpec<StructTmPtr>]
           >,

libc/src/time/nanosleep.cpp

 namespace __llvm_libc {
 
 // TODO(michaelrj): Move this into time/linux with the other syscalls.
 LLVM_LIBC_FUNCTION(int, nanosleep,
                    (const struct timespec *req, struct timespec *rem)) {
 #if SYS_nanosleep
   int ret = __llvm_libc::syscall_impl<int>(SYS_nanosleep, req, rem);
 #elif defined(SYS_clock_nanosleep_time64)
-  int ret =
-      __llvm_libc::syscall_impl<int>(SYS_clock_nanosleep_time64, req, rem);
+  // SYS_clock_nanosleep_time64 takes a timespec64 struct, which is a struct
+  // timespec with 64-bit members. In 32-bit systems struct timespec has 32-bit
+  // members, so we need to fill a timespec64 struct with the 32-bit values
+  // from struct timespec.
+  struct timespec64 req64;
+  req64.tv_sec = req->tv_sec;
+  req64.tv_nsec = req->tv_nsec;
+
+  struct timespec64 rem64;
+  rem64.tv_sec = rem->tv_sec;
+  rem64.tv_nsec = rem->tv_nsec;
+
+  int ret = __llvm_libc::syscall_impl<int>(SYS_clock_nanosleep_time64,
+                                           CLOCK_REALTIME, 0, &req64, &rem64);
+
+  rem->tv_sec = static_cast<time_t>(rem64.tv_sec);
+  rem->tv_nsec = static_cast<long>(rem64.tv_nsec);
 #else
 #error "SYS_nanosleep and SYS_clock_nanosleep_time64 syscalls not available."
 #endif
 
   if (ret < 0) {
     libc_errno = -ret;
     return -1;
   }
   return ret;
 }
 
 } // namespace __llvm_libc