[libc][NFC] Switch use of errno in src/time and test/src/time to libc_errno.

[rtenneti]

Summary

Switch use of errno in src/time and test/src/time to libc_errno.

[sivachandra]

While this patch is a step in the right direction, I think we also need to remove setting of errno from helper functions. See this RFC for the justification: https://discourse.llvm.org/t/rfc-improving-the-hermeticity-of-tests-with-respect-to-errno/68684

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
     libc.include.time
     libc.src.errno.errno
 )
 
 add_entrypoint_object(
   asctime
   SRCS
     asctime.cpp

 add_entrypoint_object(
   gettimeofday
   SRCS
     gettimeofday.cpp
   HDRS
     gettimeofday.h
   DEPENDS
     .clock_gettime
-    libc.include.errno
     libc.include.time
     libc.include.sys_syscall
     libc.src.__support.OSUtil.osutil
     libc.src.errno.errno
 )
 
 add_entrypoint_object(
   gmtime

 add_entrypoint_object(
   mktime
   SRCS
     mktime.cpp
   HDRS
     mktime.h
   DEPENDS
     .time_utils
-    libc.include.errno
     libc.include.time
     libc.src.errno.errno
 )
 
 add_entrypoint_object(
   nanosleep
   SRCS
     nanosleep.cpp
   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

libc/src/time/clock_gettime.cpp

 //===---------- Linux implementation of the POSIX clock_gettime 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_gettime.h"
 
 #include "src/__support/OSUtil/syscall.h" // For internal syscall function.
 #include "src/__support/common.h"
+#include "src/errno/libc_errno.h"
 
-#include <errno.h>
 #include <sys/syscall.h> // For syscall numbers.
 #include <time.h>
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, clock_gettime,
                    (clockid_t clockid, struct timespec *tp)) {
   long ret_val =
       __llvm_libc::syscall_impl(SYS_clock_gettime, static_cast<long>(clockid),
                                 reinterpret_cast<long>(tp));
   // A negative return value indicates an error with the magnitude of the
   // value being the error code.
   if (ret_val < 0) {
-    errno = -ret_val;
+    libc_errno = -ret_val;
     return -1;
   }
 
   return 0;
 }
 
 } // namespace __llvm_libc

libc/src/time/gettimeofday.cpp

 //===-- Implementation of gettimeofday 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/gettimeofday.h"
 
 #include "src/__support/OSUtil/syscall.h" // For internal syscall function.
 #include "src/__support/common.h"
+#include "src/errno/libc_errno.h"
 
-#include <errno.h>
 #include <sys/syscall.h> // For syscall numbers.
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, gettimeofday,
                    (struct timeval * tv, [[maybe_unused]] void *unused)) {
   if (tv == nullptr)
     return 0;
   struct timespec tp;
   long ret_val = __llvm_libc::syscall_impl(SYS_clock_gettime,
                                            static_cast<long>(CLOCK_REALTIME),
                                            reinterpret_cast<long>(&tp));
   // A negative return value indicates an error with the magnitude of the
   // value being the error code.
   if (ret_val < 0) {
-    errno = -ret_val;
+    libc_errno = -ret_val;
     return -1;
   }
   tv->tv_sec = tp.tv_sec;
   tv->tv_usec = tp.tv_nsec / 1000;
   return 0;
 }
 
 } // namespace __llvm_libc

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 "src/errno/libc_errno.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;
+    libc_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 =

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 "src/errno/libc_errno.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;
+    libc_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/nanosleep.cpp

 //===-- Implementation of nanosleep 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/nanosleep.h"
+
 #include "include/sys/syscall.h"          // For syscall numbers.
 #include "src/__support/OSUtil/syscall.h" // For syscall functions.
 #include "src/__support/common.h"
-
-#include <errno.h>
+#include "src/errno/libc_errno.h"
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, nanosleep,
                    (const struct timespec *req, struct timespec *rem)) {
   int ret = __llvm_libc::syscall_impl(SYS_nanosleep, req, rem);
   if (ret < 0) {
     errno = -ret;
     return -1;
   }
   return ret;
 }
 
 } // namespace __llvm_libc

libc/src/time/time_utils.h

 //===-- Collection of utils for mktime and friends --------------*- 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_UTILS_H
 #define LLVM_LIBC_SRC_TIME_TIME_UTILS_H
 
 #include <stddef.h> // For size_t.
 
-#include "include/errno.h"
-
 #include "src/__support/common.h"
-#include "src/errno/llvmlibc_errno.h"
+#include "src/errno/libc_errno.h"
 #include "src/time/mktime.h"
 
 #include <stdint.h>
 
 namespace __llvm_libc {
 namespace time_utils {
 
 enum Month : int {

 };
 
 // Update the "tm" structure's year, month, etc. members from seconds.
 // "total_seconds" is the number of seconds since January 1st, 1970.
 extern int64_t update_from_seconds(int64_t total_seconds, struct tm *tm);
 
 // POSIX.1-2017 requires this.
 LIBC_INLINE time_t out_of_range() {
-  llvmlibc_errno = EOVERFLOW;
+  libc_errno = EOVERFLOW;
   return static_cast<time_t>(-1);
 }
 
-LIBC_INLINE void invalid_value() { llvmlibc_errno = EINVAL; }
+LIBC_INLINE void invalid_value() { libc_errno = EINVAL; }
 
 LIBC_INLINE char *asctime(const struct tm *timeptr, char *buffer,
                           size_t bufferLength) {
   if (timeptr == nullptr || buffer == nullptr) {
     invalid_value();
     return nullptr;
   }
   if (timeptr->tm_wday < 0 ||

libc/test/src/time/CMakeLists.txt

add_libc_unittest(
   SRCS
     gettimeofday_test.cpp
   HDRS
     TmHelper.h
     TmMatcher.h
   CXX_STANDARD
     20
   DEPENDS
-    libc.include.errno
     libc.include.time
     libc.src.time.gettimeofday
     libc.src.time.nanosleep
+    libc.src.errno.errno
 )
 
 add_libc_unittest(
   gmtime
   SUITE
     libc_time_unittests
   SRCS
     gmtime_test.cpp
add_libc_unittest(
   SRCS
     nanosleep_test.cpp
   HDRS
     TmHelper.h
     TmMatcher.h
   CXX_STANDARD
     20
   DEPENDS
-    libc.include.errno
     libc.include.time
     libc.src.time.nanosleep
+    libc.src.errno.errno
 )
 
 add_libc_unittest(
   time_test
   SUITE
     libc_time_unittests
   SRCS
     time_test.cpp
   DEPENDS
-    libc.include.errno
     libc.include.time
     libc.src.time.time
+    libc.src.errno.errno
 )
 
 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.src.errno.errno
 )

libc/test/src/time/asctime_r_test.cpp

 //===-- Unittests for asctime_r
 //--------------------------------------------===//
 //
 // 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/errno/libc_errno.h"
 #include "src/time/asctime_r.h"
 #include "src/time/time_utils.h"
 #include "test/UnitTest/Test.h"
 #include "test/src/time/TmHelper.h"
 
 using __llvm_libc::time_utils::TimeConstants;
 
 static inline char *call_asctime_r(struct tm *tm_data, int year, int month,
                                    int mday, int hour, int min, int sec,
                                    int wday, int yday, char *buffer) {
   __llvm_libc::tmhelper::testing::initialize_tm_data(
       tm_data, year, month, mday, hour, min, sec, wday, yday);
   return __llvm_libc::asctime_r(tm_data, buffer);
 }
 
 // asctime and asctime_r share the same code and thus didn't repeat all the
 // tests from asctime. Added couple of validation tests.
 TEST(LlvmLibcAsctimeR, Nullptr) {
   char *result;
   result = __llvm_libc::asctime_r(nullptr, nullptr);
-  ASSERT_EQ(EINVAL, llvmlibc_errno);
+  ASSERT_EQ(EINVAL, libc_errno);
   ASSERT_STREQ(nullptr, result);
 
   char buffer[TimeConstants::ASCTIME_BUFFER_SIZE];
   result = __llvm_libc::asctime_r(nullptr, buffer);
-  ASSERT_EQ(EINVAL, llvmlibc_errno);
+  ASSERT_EQ(EINVAL, libc_errno);
   ASSERT_STREQ(nullptr, result);
 
   struct tm tm_data;
   result = __llvm_libc::asctime_r(&tm_data, nullptr);
-  ASSERT_EQ(EINVAL, llvmlibc_errno);
+  ASSERT_EQ(EINVAL, libc_errno);
   ASSERT_STREQ(nullptr, result);
 }
 
 TEST(LlvmLibcAsctimeR, ValidDate) {
   char buffer[TimeConstants::ASCTIME_BUFFER_SIZE];
   struct tm tm_data;
   char *result;
   // 1970-01-01 00:00:00. Test with a valid buffer size.

libc/test/src/time/asctime_test.cpp

 //===-- Unittests for asctime ---------------------------------------------===//
 //
 // 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/errno/libc_errno.h"
 #include "src/time/asctime.h"
 #include "test/UnitTest/Test.h"
 #include "test/src/time/TmHelper.h"
 
 static inline char *call_asctime(struct tm *tm_data, int year, int month,
                                  int mday, int hour, int min, int sec, int wday,
                                  int yday) {
   __llvm_libc::tmhelper::testing::initialize_tm_data(
       tm_data, year, month, mday, hour, min, sec, wday, yday);
   return __llvm_libc::asctime(tm_data);
 }
 
 TEST(LlvmLibcAsctime, Nullptr) {
   char *result;
   result = __llvm_libc::asctime(nullptr);
-  ASSERT_EQ(EINVAL, llvmlibc_errno);
+  ASSERT_EQ(EINVAL, libc_errno);
   ASSERT_STREQ(nullptr, result);
 }
 
 // Weekdays are in the range 0 to 6. Test passing invalid value in wday.
 TEST(LlvmLibcAsctime, InvalidWday) {
   struct tm tm_data;
 
   // Test with wday = -1.
   call_asctime(&tm_data,
                1970, // year
                1,    // month
                1,    // day
                0,    // hr
                0,    // min
                0,    // sec
                -1,   // wday
                0);   // yday
-  ASSERT_EQ(EINVAL, llvmlibc_errno);
+  ASSERT_EQ(EINVAL, libc_errno);
 
   // Test with wday = 7.
   call_asctime(&tm_data,
                1970, // year
                1,    // month
                1,    // day
                0,    // hr
                0,    // min
                0,    // sec
                7,    // wday
                0);   // yday
-  ASSERT_EQ(EINVAL, llvmlibc_errno);
+  ASSERT_EQ(EINVAL, libc_errno);
 }
 
 // Months are from January to December. Test passing invalid value in month.
 TEST(LlvmLibcAsctime, InvalidMonth) {
   struct tm tm_data;
 
   // Test with month = 0.
   call_asctime(&tm_data,
                1970, // year
                0,    // month
                1,    // day
                0,    // hr
                0,    // min
                0,    // sec
                4,    // wday
                0);   // yday
-  ASSERT_EQ(EINVAL, llvmlibc_errno);
+  ASSERT_EQ(EINVAL, libc_errno);
 
   // Test with month = 13.
   call_asctime(&tm_data,
                1970, // year
                13,   // month
                1,    // day
                0,    // hr
                0,    // min
                0,    // sec
                4,    // wday
                0);   // yday
-  ASSERT_EQ(EINVAL, llvmlibc_errno);
+  ASSERT_EQ(EINVAL, libc_errno);
 }
 
 TEST(LlvmLibcAsctime, ValidWeekdays) {
   struct tm tm_data;
   char *result;
   // 1970-01-01 00:00:00.
   result = call_asctime(&tm_data,
                         1970, // year
result = call_asctime(&tm_data,
                         2147483647, // year
                         1,          // month
                         1,          // day
                         12,         // hr
                         50,         // min
                         50,         // sec
                         2,          // wday
                         50);        // yday
-  ASSERT_EQ(EOVERFLOW, llvmlibc_errno);
+  ASSERT_EQ(EOVERFLOW, libc_errno);
   ASSERT_STREQ(nullptr, result);
 }

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 "test/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/difftime_test.cpp

 //===-- Unittests for difftime --------------------------------------------===//
 //
 // 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/__support/FPUtil/FPBits.h"
 #include "src/time/difftime.h"
 #include "src/time/time_utils.h"
 #include "test/ErrnoSetterMatcher.h"
 #include "test/UnitTest/Test.h"
 
-#include <errno.h>
-
 using __llvm_libc::testing::ErrnoSetterMatcher::Succeeds;
 using __llvm_libc::time_utils::TimeConstants;
 
 TEST(LlvmLibcDifftime, SmokeTest) {
   time_t t1_seconds = TimeConstants::SECONDS_PER_HOUR;
   time_t t2_seconds = 0;
 
   __llvm_libc::fputil::FPBits<long double> expected_fp =

libc/test/src/time/gettimeofday_test.cpp

 //===-- Unittests for gettimeofday ----------------------------------------===//
 //
 // 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 <errno.h>
 #include <time.h>
 
 #include "src/time/gettimeofday.h"
 #include "src/time/nanosleep.h"
 #include "test/ErrnoSetterMatcher.h"
 #include "test/UnitTest/Test.h"
 
 namespace cpp = __llvm_libc::cpp;

libc/test/src/time/gmtime_test.cpp

 //===-- Unittests for gmtime ----------------------------------------------===//
 //
 // 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/errno/libc_errno.h"
 #include "src/time/gmtime.h"
 #include "src/time/time_utils.h"
 #include "test/ErrnoSetterMatcher.h"
 #include "test/UnitTest/Test.h"
 #include "test/src/time/TmMatcher.h"
 
-#include <errno.h>
 #include <limits.h>
 
 using __llvm_libc::testing::ErrnoSetterMatcher::Fails;
 using __llvm_libc::testing::ErrnoSetterMatcher::Succeeds;
 using __llvm_libc::time_utils::TimeConstants;
 
 TEST(LlvmLibcGmTime, OutOfRange) {
   time_t seconds =
       1 + INT_MAX * static_cast<int64_t>(
                         TimeConstants::NUMBER_OF_SECONDS_IN_LEAP_YEAR);
   struct tm *tm_data = __llvm_libc::gmtime(&seconds);
   EXPECT_TRUE(tm_data == nullptr);
-  EXPECT_EQ(llvmlibc_errno, EOVERFLOW);
+  EXPECT_EQ(libc_errno, EOVERFLOW);
 
-  llvmlibc_errno = 0;
+  libc_errno = 0;
   seconds = INT_MIN * static_cast<int64_t>(
                           TimeConstants::NUMBER_OF_SECONDS_IN_LEAP_YEAR) -
             1;
   tm_data = __llvm_libc::gmtime(&seconds);
   EXPECT_TRUE(tm_data == nullptr);
-  EXPECT_EQ(llvmlibc_errno, EOVERFLOW);
+  EXPECT_EQ(libc_errno, EOVERFLOW);
 }
 
 TEST(LlvmLibcGmTime, InvalidSeconds) {
   time_t seconds = 0;
   struct tm *tm_data = nullptr;
   // -1 second from 1970-01-01 00:00:00 returns 1969-12-31 23:59:59.
   seconds = -1;
   tm_data = __llvm_libc::gmtime(&seconds);

libc/test/src/time/mktime_test.cpp

 //===-- Unittests for mktime ----------------------------------------------===//
 //
 // 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/mktime.h"
 #include "src/time/time_utils.h"
 #include "test/ErrnoSetterMatcher.h"
 #include "test/UnitTest/Test.h"
 #include "test/src/time/TmHelper.h"
 #include "test/src/time/TmMatcher.h"
 
-#include <errno.h>
 #include <limits.h>
 
 using __llvm_libc::testing::ErrnoSetterMatcher::Fails;
 using __llvm_libc::testing::ErrnoSetterMatcher::Succeeds;
 using __llvm_libc::time_utils::Month;
 
 static inline constexpr int tm_year(int year) {
   return year - TimeConstants::TIME_YEAR_BASE;

libc/test/src/time/nanosleep_test.cpp

 //===-- Unittests for nanosleep
 //---------------------------------------------===//
 //
 // 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 <errno.h>
 #include <time.h>
 
+#include "src/errno/libc_errno.h"
 #include "src/time/nanosleep.h"
 #include "test/ErrnoSetterMatcher.h"
 #include "test/UnitTest/Test.h"
 
 namespace cpp = __llvm_libc::cpp;
 
 TEST(LlvmLibcNanosleep, SmokeTest) {
   // TODO: When we have the code to read clocks, test that time has passed.
   using __llvm_libc::testing::ErrnoSetterMatcher::Succeeds;
-  errno = 0;
+  libc_errno = 0;
 
   struct timespec tim = {1, 500};
   struct timespec tim2 = {0, 0};
   int ret = __llvm_libc::nanosleep(&tim, &tim2);
-  ASSERT_EQ(errno, 0);
+  ASSERT_EQ(libc_errno, 0);
   ASSERT_EQ(ret, 0);
 }

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 "test/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);
 }