[libc] Add Linux implementations of time and clock functions.

[michaelrj]

LGTM

libc/config/linux/api.td

let Types = [
     "size_t",
     "__bsearchcompare_t",
     "__qsortcompare_t",
     "__atexithandler_t",
   ];
 }
 
 def TimeAPI : PublicAPI<"time.h"> {
-  let Types = ["time_t", "struct tm", "struct timespec", "clockid_t",];
+  let Types = ["clock_t", "time_t", "struct tm", "struct timespec", "clockid_t",];
 }
 
 def ErrnoAPI : PublicAPI<"errno.h"> {
   let Macros = [
     ErrnoMacro,
     // We largely depend on linux/errno.h to give us the
     // various error macro definitions. However, some libc
     // implementations have chosen to provide definitions

libc/config/linux/x86_64/entrypoints.txt

list(APPEND TARGET_LIBC_ENTRYPOINTS
     libc.src.threads.tss_create
     libc.src.threads.tss_delete
     libc.src.threads.tss_get
     libc.src.threads.tss_set
 
     # time.h entrypoints
     libc.src.time.asctime
     libc.src.time.asctime_r
+    libc.src.time.clock_gettime
+    libc.src.time.clock
     libc.src.time.difftime
     libc.src.time.gmtime
     libc.src.time.gmtime_r
     libc.src.time.mktime
     libc.src.time.nanosleep
-    libc.src.time.clock_gettime
+    libc.src.time.time
 
     # unistd.h entrypoints
     libc.src.unistd.environ
     libc.src.unistd.execv
     libc.src.unistd.fork
     libc.src.unistd.__llvm_libc_syscall
 
     # sys/select.h entrypoints
     libc.src.sys.select.select
   )
 endif()
 
 set(TARGET_LLVMLIBC_ENTRYPOINTS
   ${TARGET_LIBC_ENTRYPOINTS}
   ${TARGET_LIBM_ENTRYPOINTS}
 )

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.time_t
+    .llvm-libc-types.clock_t
     .llvm-libc-types.clockid_t
     .llvm-libc-types.struct_tm
     .llvm-libc-types.struct_timespec
 )
 
 add_gen_header(
   threads
   DEF_FILE threads.h.def

libc/include/llvm-libc-macros/linux/time-macros.h

 #define CLOCK_THREAD_CPUTIME_ID 3
 #define CLOCK_MONOTONIC_RAW 4
 #define CLOCK_REALTIME_COARSE 5
 #define CLOCK_MONOTONIC_COARSE 6
 #define CLOCK_BOOTTIME 7
 #define CLOCK_REALTIME_ALARM 8
 #define CLOCK_BOOTTIME_ALARM 9
 
+#define CLOCKS_PER_SEC 1000000
+
 #endif //__LLVM_LIBC_MACROS_LINUX_TIME_MACROS_H

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

 add_header(__pthread_start_t HDR __pthread_start_t.h)
 add_header(__pthread_tss_dtor_t HDR __pthread_tss_dtor_t.h)
 add_header(__qsortcompare_t HDR __qsortcompare_t.h)
 add_header(__sighandler_t HDR __sighandler_t.h)
 add_header(__thread_type HDR __thread_type.h)
 add_header(blkcnt_t HDR blkcnt_t.h)
 add_header(blksize_t HDR blksize_t.h)
 add_header(cc_t HDR cc_t.h)
+add_header(clock_t HDR clock_t.h)
 add_header(clockid_t HDR clockid_t.h)
 add_header(cnd_t HDR cnd_t.h)
 add_header(cookie_io_functions_t HDR cookie_io_functions_t.h DEPENDS .off64_t)
 add_header(cpu_set_t HDR cpu_set_t.h)
 add_header(double_t HDR double_t.h)
 add_header(DIR HDR DIR.h)
 add_header(dev_t HDR dev_t.h)
 add_header(div_t HDR div_t.h)

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

+//===-- Definition of clock_t type ----------------------------------------===//
+//
+// 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_CLOCK_T_H__
+#define __LLVM_LIBC_TYPES_CLOCK_T_H__
+
+typedef long clock_t;
+
+#endif // __LLVM_LIBC_TYPES_CLOCK_T_H__

libc/spec/stdc.td

 def StdC : StandardSpec<"stdc"> {
 
   NamedType StructTmType = NamedType<"struct tm">;
   PtrType StructTmPtr = PtrType<StructTmType>;
   PtrType TimeTTypePtr = PtrType<TimeTType>;
+  NamedType ClockT = NamedType<"clock_t">;
 
   NamedType DivTType = NamedType<"div_t">;
   NamedType LDivTType = NamedType<"ldiv_t">;
   NamedType LLDivTType = NamedType<"lldiv_t">;
 
   NamedType TssTType = NamedType<"tss_t">;
   PtrType TssTPtr = PtrType<TssTType>;
   NamedType TssDtorTType = NamedType<"tss_dtor_t">;
HeaderSpec Threads = HeaderSpec<
           >,
       ]
   >;
 
   HeaderSpec Time = HeaderSpec<
       "time.h",
       [], // Macros
       [ // Types
+         ClockT,
          StructTmType,
          TimeTType,
       ],
       [], // Enumerations
       [
           FunctionSpec<
               "asctime",
               RetValSpec<CharPtr>,
               [ArgSpec<StructTmPtr>]
           >,
           FunctionSpec<
               "asctime_r",
               RetValSpec<CharPtr>,
               [
                   ArgSpec<StructTmPtr>,
                   ArgSpec<CharPtr>,
               ]
           >,
           FunctionSpec<
+              "clock",
+              RetValSpec<ClockT>,
+              [ArgSpec<VoidType>]
+          >,
+          FunctionSpec<
               "difftime",
               RetValSpec<DoubleType>,
               [
                   ArgSpec<TimeTType>,
                   ArgSpec<TimeTType>,
               ]
           >,
           FunctionSpec<
HeaderSpec Time = HeaderSpec<
                   ArgSpec<StructTmPtr>,
               ]
           >,
           FunctionSpec<
               "mktime",
               RetValSpec<TimeTType>,
               [ArgSpec<StructTmPtr>]
           >,
+          FunctionSpec<
+              "time",
+              RetValSpec<TimeTType>,
+              [ArgSpec<TimeTTypePtr>]
+          >,
       ]
   >;
 
   let Headers = [
     Assert,
     CType,
     Errno,
     Fenv,

libc/src/time/CMakeLists.txt

+if(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/${LIBC_TARGET_OS})
+  add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/${LIBC_TARGET_OS})
+endif()
+
 add_object_library(
   time_utils
   SRCS
     time_utils.cpp
   HDRS
     time_utils.h
   DEPENDS
     libc.include.errno
HDRS
     nanosleep.h
   DEPENDS
     libc.include.errno
     libc.include.time
     libc.include.sys_syscall
     libc.src.__support.OSUtil.osutil
     libc.src.errno.errno
 )
+
+add_entrypoint_object(
+  time
+  ALIAS
+  DEPENDS
+    .${LIBC_TARGET_OS}.time
+)
+
+add_entrypoint_object(
+  clock
+  ALIAS
+  DEPENDS
+    .${LIBC_TARGET_OS}.clock
+)

libc/src/time/clock.h

+//===-- Implementation header of clock --------------------------*- C++ -*-===//
+//
+// 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_SRC_TIME_CLOCK_H
+#define LLVM_LIBC_SRC_TIME_CLOCK_H
+
+#include <time.h>
+
+namespace __llvm_libc {
+
+clock_t clock();
+
+} // namespace __llvm_libc
+
+#endif // LLVM_LIBC_SRC_TIME_CLOCK_H

libc/src/time/linux/CMakeLists.txt

+add_entrypoint_object(
+  time
+  SRCS
+    time.cpp
+  HDRS
+    ../time_func.h
+  DEPENDS
+    libc.include.time
+    libc.include.sys_syscall
+    libc.src.__support.OSUtil.osutil
+    libc.src.errno.errno
+)
+
+add_entrypoint_object(
+  clock
+  SRCS
+    clock.cpp
+  HDRS
+    ../clock.h
+  DEPENDS
+    libc.include.time
+    libc.include.sys_syscall
+    libc.src.__support.CPP.limits
+    libc.src.__support.OSUtil.osutil
+    libc.src.errno.errno
+)

libc/src/time/linux/clock.cpp

+//===-- Linux implementation of the clock function ------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#include "src/time/clock.h"
+
+#include "src/__support/CPP/limits.h"
+#include "src/__support/OSUtil/syscall.h" // For internal syscall function.
+#include "src/__support/common.h"
+
+#include <errno.h>
+#include <sys/syscall.h> // For syscall numbers.
+#include <time.h>
+
+namespace __llvm_libc {
+
+LLVM_LIBC_FUNCTION(clock_t, clock, ()) {
+  struct timespec ts;
+  long ret_val = __llvm_libc::syscall_impl(
+      SYS_clock_gettime, CLOCK_PROCESS_CPUTIME_ID, reinterpret_cast<long>(&ts));
+  if (ret_val < 0) {
+    errno = -ret_val;
+    return clock_t(-1);
+  }
+
+  // The above syscall gets the CPU time in seconds plus nanoseconds. We should
+  // make sure that corresponding clocks can actually be represented by clock-t.
+  // The standard requires that we return clock_t(-1) if we cannot represent
+  // clocks as a clock_t value.
+  constexpr clock_t CLOCK_SECS_MAX =
+      cpp::numeric_limits<clock_t>::max() / CLOCKS_PER_SEC;
+  if (ts.tv_sec > CLOCK_SECS_MAX)
+    return clock_t(-1);
+  if (ts.tv_nsec / 1000000000 > CLOCK_SECS_MAX - ts.tv_sec)
+    return clock_t(-1);
+
+  // For the integer computation converting tv_nsec to clocks to work
+  // correctly, we want CLOCKS_PER_SEC to be less than 1000000000.
+  static_assert(1000000000 > CLOCKS_PER_SEC,
+                "Expected CLOCKS_PER_SEC to be less than 1000000000.");
+  return clock_t(ts.tv_sec * CLOCKS_PER_SEC +
+                 ts.tv_nsec / (1000000000 / CLOCKS_PER_SEC));
+}
+
+} // namespace __llvm_libc

libc/src/time/linux/time.cpp

+//===-- Linux implementation of the time function -------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#include "src/time/time_func.h"
+
+#include "src/__support/OSUtil/syscall.h" // For internal syscall function.
+#include "src/__support/common.h"
+
+#include <errno.h>
+#include <sys/syscall.h> // For syscall numbers.
+#include <time.h>
+
+namespace __llvm_libc {
+
+LLVM_LIBC_FUNCTION(time_t, time, (time_t * tp)) {
+  // TODO: Use the Linux VDSO to fetch the time and avoid the syscall.
+  struct timespec ts;
+  long ret_val = __llvm_libc::syscall_impl(SYS_clock_gettime, CLOCK_REALTIME,
+                                           reinterpret_cast<long>(&ts));
+  if (ret_val < 0) {
+    errno = -ret_val;
+    return -1;
+  }
+
+  if (tp != nullptr)
+    *tp = time_t(ts.tv_sec);
+  return time_t(ts.tv_sec);
+}
+
+} // namespace __llvm_libc

libc/src/time/time_func.h

+//===-- Implementation header of time ---------------------------*- C++ -*-===//
+//
+// 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_SRC_TIME_TIME_FUNC_H
+#define LLVM_LIBC_SRC_TIME_TIME_FUNC_H
+
+#include <time.h>
+
+// Note this header file is named time_func.h to avoid conflicts with the
+// public header file time.h.
+namespace __llvm_libc {
+
+time_t time(time_t *tp);
+
+} // namespace __llvm_libc
+
+#endif // LLVM_LIBC_SRC_TIME_TIME_FUNC_H

libc/test/src/time/CMakeLists.txt

HDRS
     TmMatcher.h
   CXX_STANDARD
     20
   DEPENDS
     libc.include.errno
     libc.include.time
     libc.src.time.nanosleep
 )
+
+add_libc_unittest(
+  time_test
+  SUITE
+    libc_time_unittests
+  SRCS
+    time_test.cpp
+  DEPENDS
+    libc.include.errno
+    libc.include.time
+    libc.src.time.time
+)
+
+add_libc_unittest(
+  clock_test
+  SUITE
+    libc_time_unittests
+  SRCS
+    clock_test.cpp
+  DEPENDS
+    libc.include.errno
+    libc.include.time
+    libc.src.time.clock
+)

libc/test/src/time/clock_test.cpp

+//===-- Unittests for clock -----------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#include "src/time/clock.h"
+#include "utils/UnitTest/Test.h"
+
+#include <errno.h>
+#include <limits.h>
+#include <time.h>
+
+TEST(LlvmLibcClockTest, SmokeTest) {
+  clock_t c1 = __llvm_libc::clock();
+  ASSERT_GT(c1, clock_t(0));
+
+  clock_t c2 = __llvm_libc::clock();
+  ASSERT_GE(c2, c1);
+}

libc/test/src/time/time_test.cpp

+//===-- Unittests for time ------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#include "src/time/time_func.h"
+#include "utils/UnitTest/Test.h"
+
+#include <errno.h>
+#include <limits.h>
+#include <time.h>
+
+TEST(LlvmLibcTimeTest, SmokeTest) {
+  time_t t1;
+  time_t t2 = __llvm_libc::time(&t1);
+  ASSERT_EQ(t1, t2);
+  ASSERT_GT(t1, time_t(0));
+
+  time_t t3 = __llvm_libc::time(nullptr);
+  ASSERT_GE(t3, t1);
+}