This introduces gmtime to LLVM libc, based on C99/C2X/Single Unix Spec.

[rtenneti]

Summary

This change doesn't handle TIMEZONE, tm_isdst and leap seconds.

Moved shared code between mktime and gmtime into time_utils.cpp.

[rtenneti]

Added missing OutOfRange test. Fixed few nits while reviewing.

[sivachandra]

Couple of questions inline. Feel free to submit after answering/addressing them.

libc/src/time/CMakeLists.txt

9

Why do we need standalone_cpp?

libc/src/time/gmtime.cpp

19

Does any standard require thread safety? If yes, will making the below declaration thread-local solve the problem?

libc/test/src/time/gmtime_test.cpp

24

Why do we need the GmTimeTests prefix? Doesn't the suite name LlvmLibcGmTime already convey that it is a gmtime test?

libc/test/src/time/mktime_test.cpp

53

Ditto.

[jeffbailey]

libc/src/time/gmtime.cpp

19

C20 introduces gmtime_r (and the family of _r time functions).

In 7.27.3:

" Execution of any of the functions that return a pointer to one of these static
objects may overwrite the information returned from any previous call to one of these functions that
uses the same object. "

But what's not clear to me is for the non-reentrant versions, is doing a thread-local OK? I'm not seeing anything in the standard discussing static buffers and the use of thread-locals to store them (it only's mentioned in the definition of errno)

[sivachandra]

libc/src/time/gmtime.cpp

19

Whether thread-local is OK or not depends on the supported uses cases. For example, if a change in value in one thread is to be visible from another thread, then making it a thread-local is not a good idea. If it is unclear from the standards, I would say just leave it as you have it here.

[rtenneti]

Fixed Siva's code review comments.

[rtenneti]

Thanks Siva for the comments. PTAL.

libc/src/time/gmtime.cpp

19

I will implement gmtime_r in the next CL. Removed the TODO (it should have been a TODO in the description to implement gmtime_r).

libc/config/linux/api.td

 
 def TimeAPI : PublicAPI<"time.h"> {
   let TypeDeclarations = [
     StructTm,
     TimeT,
   ];
 
   let Functions = [
+    "gmtime",
     "mktime",
   ];
 }
 
 def ErrnoAPI : PublicAPI<"errno.h"> {
   let Macros = [
     ErrnoMacro,
     // We largely depend on linux/errno.h to give us the

libc/config/linux/x86_64/entrypoints.txt

list(APPEND TARGET_LIBC_ENTRYPOINTS
     libc.src.threads.call_once
     libc.src.threads.mtx_init
     libc.src.threads.mtx_lock
     libc.src.threads.mtx_unlock
     libc.src.threads.thrd_create
     libc.src.threads.thrd_join
 
     # time.h entrypoints
+    libc.src.time.gmtime
     libc.src.time.mktime
 
     # unistd.h entrypoints
     libc.src.unistd.write
   )
 endif()
 
 set(TARGET_LLVMLIBC_ENTRYPOINTS
   ${TARGET_LIBC_ENTRYPOINTS}
   ${TARGET_LIBM_ENTRYPOINTS}
 )

libc/spec/stdc.td

 def StdC : StandardSpec<"stdc"> {
 
   NamedType FILE = NamedType<"FILE">;
   PtrType FILEPtr = PtrType<FILE>;
   RestrictedPtrType FILERestrictedPtr = RestrictedPtrType<FILE>;
   NamedType StructTmType = NamedType<"struct tm">;
   PtrType StructTmPtr = PtrType<StructTmType>;
+  PtrType TimeTTypePtr = PtrType<TimeTType>;
 
   HeaderSpec Assert = HeaderSpec<
       "assert.h",
       [
           Macro<"static_assert">,
           Macro<"assert">,
       ],
       [], // Types
HeaderSpec Time = HeaderSpec<
       [], // Macros
       [ // Types
        StructTmType,
        TimeTType,
       ],
       [], // Enumerations
       [
           FunctionSpec<
+              "gmtime",
+              RetValSpec<StructTmPtr>,
+              [ArgSpec<TimeTTypePtr>]
+          >,
+          FunctionSpec<
               "mktime",
               RetValSpec<TimeTType>,
               [ArgSpec<StructTmPtr>]
           >,
       ]
   >;
 
   let Headers = [

libc/src/time/CMakeLists.txt

+add_object_library(
+  time_utils
+  SRCS
+    time_utils.cpp
+  HDRS
+    time_utils.h
+)
+
+add_entrypoint_object(
+  gmtime
+  SRCS
+    gmtime.cpp
+  HDRS
+    gmtime.h
+  DEPENDS
+    .time_utils
+    libc.include.errno
+    libc.include.time
+    libc.src.errno.__errno_location
+)
+
 add_entrypoint_object(
   mktime
   SRCS
     mktime.cpp
   HDRS
     mktime.h
-    time_utils.h
   DEPENDS
+    .time_utils
     libc.include.errno
     libc.include.time
     libc.src.errno.__errno_location
 )

libc/src/time/gmtime.h

+//===-- Implementation header of gmtime -------------------------*- 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_GMTIME_H
+#define LLVM_LIBC_SRC_TIME_GMTIME_H
+
+#include <time.h>
+
+namespace __llvm_libc {
+
+struct tm *gmtime(const time_t *timer);
+
+} // namespace __llvm_libc
+
+#endif // LLVM_LIBC_SRC_TIME_GMTIME_H
+
+#include "include/time.h"

libc/src/time/gmtime.cpp

+//===-- Implementation of gmtime 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/gmtime.h"
+#include "src/__support/common.h"
+#include "src/time/time_utils.h"
+
+#include <limits.h>
+
+namespace __llvm_libc {
+
+LLVM_LIBC_FUNCTION(struct tm *, gmtime, (const time_t *timer)) {
+  static struct tm tm_out;
+  time_t seconds = *timer;
+  // Update the tm structure's year, month, day, etc. from seconds.
+  if (time_utils::UpdateFromSeconds(seconds, &tm_out) < 0) {
+    time_utils::OutOfRange();
+    return nullptr;
+  }
+
+  return &tm_out;
+}
+
+} // namespace __llvm_libc

libc/src/time/mktime.cpp

static constexpr int64_t getNumOfLeapYearsBefore(int64_t year) {
   return (year / 4) - (year / 100) + (year / 400);
 }
 
 // Returns True if year is a leap year.
 static constexpr bool isLeapYear(const int64_t year) {
   return (((year) % 4) == 0 && (((year) % 100) != 0 || ((year) % 400) == 0));
 }
 
-static int64_t computeRemainingYears(int64_t daysPerYears,
-                                     int64_t quotientYears,
-                                     int64_t *remainingDays) {
-  int64_t years = *remainingDays / daysPerYears;
-  if (years == quotientYears)
-    years--;
-  *remainingDays -= years * daysPerYears;
-  return years;
-}
-
-// Update the "tm" structure's year, month, etc. members from seconds.
-// "total_seconds" is the number of seconds since January 1st, 1970.
-//
-// First, divide "total_seconds" by the number of seconds in a day to get the
-// number of days since Jan 1 1970. The remainder will be used to calculate the
-// number of Hours, Minutes and Seconds.
-//
-// Then, adjust that number of days by a constant to be the number of days
-// since Mar 1 2000. Year 2000 is a multiple of 400, the leap year cycle. This
-// makes it easier to count how many leap years have passed using division.
-//
-// While calculating numbers of years in the days, the following algorithm
-// subdivides the days into the number of 400 years, the number of 100 years and
-// the number of 4 years. These numbers of cycle years are used in calculating
-// leap day. This is similar to the algorithm used in  getNumOfLeapYearsBefore()
-// and isLeapYear(). Then compute the total number of years in days from these
-// subdivided units.
-//
-// Compute the number of months from the remaining days. Finally, adjust years
-// to be 1900 and months to be from January.
-static int64_t updateFromSeconds(int64_t total_seconds, struct tm *tm) {
-  // Days in month starting from March in the year 2000.
-  static const char daysInMonth[] = {31 /* Mar */, 30, 31, 30, 31, 31,
-                                     30,           31, 30, 31, 31, 29};
-
-  if (sizeof(time_t) == 4) {
-    if (total_seconds < 0x80000000)
-      return time_utils::OutOfRange();
-    if (total_seconds > 0x7FFFFFFF)
-      return time_utils::OutOfRange();
-  } else {
-    if (total_seconds <
-            INT_MIN * static_cast<int64_t>(
-                          TimeConstants::NumberOfSecondsInLeapYear) ||
-        total_seconds > INT_MAX * static_cast<int64_t>(
-                                      TimeConstants::NumberOfSecondsInLeapYear))
-      return time_utils::OutOfRange();
-  }
-
-  int64_t seconds = total_seconds - TimeConstants::SecondsUntil2000MarchFirst;
-  int64_t days = seconds / TimeConstants::SecondsPerDay;
-  int64_t remainingSeconds = seconds % TimeConstants::SecondsPerDay;
-  if (remainingSeconds < 0) {
-    remainingSeconds += TimeConstants::SecondsPerDay;
-    days--;
-  }
-
-  int64_t wday = (TimeConstants::WeekDayOf2000MarchFirst + days) %
-                 TimeConstants::DaysPerWeek;
-  if (wday < 0)
-    wday += TimeConstants::DaysPerWeek;
-
-  // Compute the number of 400 year cycles.
-  int64_t numOfFourHundredYearCycles = days / TimeConstants::DaysPer400Years;
-  int64_t remainingDays = days % TimeConstants::DaysPer400Years;
-  if (remainingDays < 0) {
-    remainingDays += TimeConstants::DaysPer400Years;
-    numOfFourHundredYearCycles--;
-  }
-
-  // The reminder number of years after computing number of
-  // "four hundred year cycles" will be 4 hundred year cycles or less in 400
-  // years.
-  int64_t numOfHundredYearCycles =
-      computeRemainingYears(TimeConstants::DaysPer100Years, 4, &remainingDays);
-
-  // The reminder number of years after computing number of
-  // "hundred year cycles" will be 25 four year cycles or less in 100 years.
-  int64_t numOfFourYearCycles =
-      computeRemainingYears(TimeConstants::DaysPer4Years, 25, &remainingDays);
-
-  // The reminder number of years after computing number of "four year cycles"
-  // will be 4 one year cycles or less in 4 years.
-  int64_t remainingYears = computeRemainingYears(
-      TimeConstants::DaysPerNonLeapYear, 4, &remainingDays);
-
-  // Calculate number of years from year 2000.
-  int64_t years = remainingYears + 4 * numOfFourYearCycles +
-                  100 * numOfHundredYearCycles +
-                  400LL * numOfFourHundredYearCycles;
-
-  int leapDay =
-      !remainingYears && (numOfFourYearCycles || !numOfHundredYearCycles);
-
-  int64_t yday = remainingDays + 31 + 28 + leapDay;
-  if (yday >= TimeConstants::DaysPerNonLeapYear + leapDay)
-    yday -= TimeConstants::DaysPerNonLeapYear + leapDay;
-
-  int64_t months = 0;
-  while (daysInMonth[months] <= remainingDays) {
-    remainingDays -= daysInMonth[months];
-    months++;
-  }
-
-  if (months >= TimeConstants::MonthsPerYear - 2) {
-    months -= TimeConstants::MonthsPerYear;
-    years++;
-  }
-
-  if (years > INT_MAX || years < INT_MIN)
-    return time_utils::OutOfRange();
-
-  // All the data (years, month and remaining days) was calculated from
-  // March, 2000. Thus adjust the data to be from January, 1900.
-  tm->tm_year = years + 2000 - TimeConstants::TimeYearBase;
-  tm->tm_mon = months + 2;
-  tm->tm_mday = remainingDays + 1;
-  tm->tm_wday = wday;
-  tm->tm_yday = yday;
-
-  tm->tm_hour = remainingSeconds / TimeConstants::SecondsPerHour;
-  tm->tm_min = remainingSeconds / TimeConstants::SecondsPerMin %
-               TimeConstants::SecondsPerMin;
-  tm->tm_sec = remainingSeconds % TimeConstants::SecondsPerMin;
-
-  return 0;
-}
-
 LLVM_LIBC_FUNCTION(time_t, mktime, (struct tm * tm_out)) {
   // Unlike most C Library functions, mktime doesn't just die on bad input.
   // TODO(rtenneti); Handle leap seconds.
   int64_t tmYearFromBase = tm_out->tm_year + TimeConstants::TimeYearBase;
 
   // 32-bit end-of-the-world is 03:14:07 UTC on 19 January 2038.
   if (sizeof(time_t) == 4 &&
       tmYearFromBase >= TimeConstants::EndOf32BitEpochYear) {
LLVM_LIBC_FUNCTION(time_t, mktime, (struct tm * tm_out)) {
 
   // TODO(rtenneti): Need to handle timezone and update of tm_isdst.
   int64_t seconds = tm_out->tm_sec +
                     tm_out->tm_min * TimeConstants::SecondsPerMin +
                     tm_out->tm_hour * TimeConstants::SecondsPerHour +
                     totalDays * TimeConstants::SecondsPerDay;
 
   // Update the tm structure's year, month, day, etc. from seconds.
-  if (updateFromSeconds(seconds, tm_out) < 0)
+  if (time_utils::UpdateFromSeconds(seconds, tm_out) < 0)
     return time_utils::OutOfRange();
 
   return static_cast<time_t>(seconds);
 }
 
 } // namespace __llvm_libc

libc/src/time/time_utils.h

 };
 
 // POSIX.1-2017 requires this.
 static inline time_t OutOfRange() {
   llvmlibc_errno = EOVERFLOW;
   return static_cast<time_t>(-1);
 }
 
+// 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 UpdateFromSeconds(int64_t total_seconds, struct tm *tm);
+
 } // namespace time_utils
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_TIME_TIME_UTILS_H

libc/src/time/time_utils.cpp

 //===-- Implementation of mktime 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/mktime.h"
-#include "src/__support/common.h"
 #include "src/time/time_utils.h"
+#include "src/__support/common.h"
 
 #include <limits.h>
 
 namespace __llvm_libc {
+namespace time_utils {
 
 using __llvm_libc::time_utils::TimeConstants;
 
-static constexpr int NonLeapYearDaysInMonth[] = {31, 28, 31, 30, 31, 30,
-                                                 31, 31, 30, 31, 30, 31};
-
-// Returns number of years from (1, year).
-static constexpr int64_t getNumOfLeapYearsBefore(int64_t year) {
-  return (year / 4) - (year / 100) + (year / 400);
-}
-
-// Returns True if year is a leap year.
-static constexpr bool isLeapYear(const int64_t year) {
-  return (((year) % 4) == 0 && (((year) % 100) != 0 || ((year) % 400) == 0));
-}
-
 static int64_t computeRemainingYears(int64_t daysPerYears,
                                      int64_t quotientYears,
                                      int64_t *remainingDays) {
   int64_t years = *remainingDays / daysPerYears;
   if (years == quotientYears)
     years--;
   *remainingDays -= years * daysPerYears;
   return years;
 }
 
-// Update the "tm" structure's year, month, etc. members from seconds.
-// "total_seconds" is the number of seconds since January 1st, 1970.
-//
 // First, divide "total_seconds" by the number of seconds in a day to get the
 // number of days since Jan 1 1970. The remainder will be used to calculate the
 // number of Hours, Minutes and Seconds.
 //
 // Then, adjust that number of days by a constant to be the number of days
 // since Mar 1 2000. Year 2000 is a multiple of 400, the leap year cycle. This
 // makes it easier to count how many leap years have passed using division.
 //
 // While calculating numbers of years in the days, the following algorithm
 // subdivides the days into the number of 400 years, the number of 100 years and
 // the number of 4 years. These numbers of cycle years are used in calculating
 // leap day. This is similar to the algorithm used in  getNumOfLeapYearsBefore()
 // and isLeapYear(). Then compute the total number of years in days from these
 // subdivided units.
 //
 // Compute the number of months from the remaining days. Finally, adjust years
 // to be 1900 and months to be from January.
-static int64_t updateFromSeconds(int64_t total_seconds, struct tm *tm) {
+int64_t UpdateFromSeconds(int64_t total_seconds, struct tm *tm) {
   // Days in month starting from March in the year 2000.
   static const char daysInMonth[] = {31 /* Mar */, 30, 31, 30, 31, 31,
                                      30,           31, 30, 31, 31, 29};
 
   if (sizeof(time_t) == 4) {
     if (total_seconds < 0x80000000)
       return time_utils::OutOfRange();
     if (total_seconds > 0x7FFFFFFF)
int64_t UpdateFromSeconds(int64_t total_seconds, struct tm *tm) {
   tm->tm_mday = remainingDays + 1;
   tm->tm_wday = wday;
   tm->tm_yday = yday;
 
   tm->tm_hour = remainingSeconds / TimeConstants::SecondsPerHour;
   tm->tm_min = remainingSeconds / TimeConstants::SecondsPerMin %
                TimeConstants::SecondsPerMin;
   tm->tm_sec = remainingSeconds % TimeConstants::SecondsPerMin;
-
-  return 0;
-}
-
-LLVM_LIBC_FUNCTION(time_t, mktime, (struct tm * tm_out)) {
-  // Unlike most C Library functions, mktime doesn't just die on bad input.
-  // TODO(rtenneti); Handle leap seconds.
-  int64_t tmYearFromBase = tm_out->tm_year + TimeConstants::TimeYearBase;
-
-  // 32-bit end-of-the-world is 03:14:07 UTC on 19 January 2038.
-  if (sizeof(time_t) == 4 &&
-      tmYearFromBase >= TimeConstants::EndOf32BitEpochYear) {
-    if (tmYearFromBase > TimeConstants::EndOf32BitEpochYear)
-      return time_utils::OutOfRange();
-    if (tm_out->tm_mon > 0)
-      return time_utils::OutOfRange();
-    if (tm_out->tm_mday > 19)
-      return time_utils::OutOfRange();
-    if (tm_out->tm_hour > 3)
-      return time_utils::OutOfRange();
-    if (tm_out->tm_min > 14)
-      return time_utils::OutOfRange();
-    if (tm_out->tm_sec > 7)
-      return time_utils::OutOfRange();
-  }
-
-  // Years are ints.  A 32-bit year will fit into a 64-bit time_t.
-  // A 64-bit year will not.
-  static_assert(sizeof(int) == 4,
-                "ILP64 is unimplemented.  This implementation requires "
-                "32-bit integers.");
-
-  // Calculate number of months and years from tm_mon.
-  int64_t month = tm_out->tm_mon;
-  if (month < 0 || month >= TimeConstants::MonthsPerYear - 1) {
-    int64_t years = month / 12;
-    month %= 12;
-    if (month < 0) {
-      years--;
-      month += 12;
-    }
-    tmYearFromBase += years;
-  }
-  bool tmYearIsLeap = isLeapYear(tmYearFromBase);
-
-  // Calculate total number of days based on the month and the day (tm_mday).
-  int64_t totalDays = tm_out->tm_mday - 1;
-  for (int64_t i = 0; i < month; ++i)
-    totalDays += NonLeapYearDaysInMonth[i];
-  // Add one day if it is a leap year and the month is after February.
-  if (tmYearIsLeap && month > 1)
-    totalDays++;
-
-  // Calculate total numbers of days based on the year.
-  totalDays += (tmYearFromBase - TimeConstants::EpochYear) *
-               TimeConstants::DaysPerNonLeapYear;
-  if (tmYearFromBase >= TimeConstants::EpochYear) {
-    totalDays += getNumOfLeapYearsBefore(tmYearFromBase - 1) -
-                 getNumOfLeapYearsBefore(TimeConstants::EpochYear);
-  } else if (tmYearFromBase >= 1) {
-    totalDays -= getNumOfLeapYearsBefore(TimeConstants::EpochYear) -
-                 getNumOfLeapYearsBefore(tmYearFromBase - 1);
-  } else {
-    // Calculate number of leap years until 0th year.
-    totalDays -= getNumOfLeapYearsBefore(TimeConstants::EpochYear) -
-                 getNumOfLeapYearsBefore(0);
-    if (tmYearFromBase <= 0) {
-      totalDays -= 1; // Subtract 1 for 0th year.
-      // Calculate number of leap years until -1 year
-      if (tmYearFromBase < 0) {
-        totalDays -= getNumOfLeapYearsBefore(-tmYearFromBase) -
-                     getNumOfLeapYearsBefore(1);
-      }
-    }
-  }
-
   // TODO(rtenneti): Need to handle timezone and update of tm_isdst.
-  int64_t seconds = tm_out->tm_sec +
-                    tm_out->tm_min * TimeConstants::SecondsPerMin +
-                    tm_out->tm_hour * TimeConstants::SecondsPerHour +
-                    totalDays * TimeConstants::SecondsPerDay;
-
-  // Update the tm structure's year, month, day, etc. from seconds.
-  if (updateFromSeconds(seconds, tm_out) < 0)
-    return time_utils::OutOfRange();
+  tm->tm_isdst = 0;
 
-  return static_cast<time_t>(seconds);
+  return 0;
 }
 
+} // namespace time_utils
 } // namespace __llvm_libc

libc/test/src/time/CMakeLists.txt

 add_libc_testsuite(libc_time_unittests)
 
 add_libc_unittest(
   mktime
   SUITE
     libc_time_unittests
   SRCS
+    gmtime_test.cpp
     mktime_test.cpp
   HDRS
     TmMatcher.h
   DEPENDS
+    libc.src.time.gmtime
     libc.src.time.mktime
 )

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/time/gmtime.h"
+#include "src/time/time_utils.h"
+#include "test/ErrnoSetterMatcher.h"
+#include "test/src/time/TmMatcher.h"
+#include "utils/UnitTest/Test.h"
+
+#include <errno.h>
+#include <limits.h>
+#include <string.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::NumberOfSecondsInLeapYear);
+  struct tm *tm_data = __llvm_libc::gmtime(&seconds);
+  EXPECT_TRUE(tm_data == nullptr);
+  EXPECT_EQ(llvmlibc_errno, EOVERFLOW);
+
+  llvmlibc_errno = 0;
+  seconds =
+      INT_MIN * static_cast<int64_t>(TimeConstants::NumberOfSecondsInLeapYear) -
+      1;
+  tm_data = __llvm_libc::gmtime(&seconds);
+  EXPECT_TRUE(tm_data == nullptr);
+  EXPECT_EQ(llvmlibc_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);
+  EXPECT_TM_EQ((tm{59,     // sec
+                   59,     // min
+                   23,     // hr
+                   31,     // day
+                   12 - 1, // tm_mon starts with 0 for Jan
+                   1969 - TimeConstants::TimeYearBase, // year
+                   3,                                  // wday
+                   364,                                // yday
+                   0}),
+               *tm_data);
+  // 60 seconds from 1970-01-01 00:00:00 returns 1970-01-01 00:01:00.
+  seconds = 60;
+  tm_data = __llvm_libc::gmtime(&seconds);
+  EXPECT_TM_EQ((tm{0, // sec
+                   1, // min
+                   0, // hr
+                   1, // day
+                   0, // tm_mon starts with 0 for Jan
+                   1970 - TimeConstants::TimeYearBase, // year
+                   4,                                  // wday
+                   0,                                  // yday
+                   0}),
+               *tm_data);
+}
+
+TEST(LlvmLibcGmTime, InvalidMinutes) {
+  time_t seconds = 0;
+  struct tm *tm_data = nullptr;
+  // -1 minute from 1970-01-01 00:00:00 returns 1969-12-31 23:59:00.
+  seconds = -TimeConstants::SecondsPerMin;
+  tm_data = __llvm_libc::gmtime(&seconds);
+  EXPECT_TM_EQ((tm{0,  // sec
+                   59, // min
+                   23, // hr
+                   31, // day
+                   11, // tm_mon starts with 0 for Jan
+                   1969 - TimeConstants::TimeYearBase, // year
+                   3,                                  // wday
+                   0,                                  // yday
+                   0}),
+               *tm_data);
+  // 60 minutes from 1970-01-01 00:00:00 returns 1970-01-01 01:00:00.
+  seconds = 60 * TimeConstants::SecondsPerMin;
+  tm_data = __llvm_libc::gmtime(&seconds);
+  EXPECT_TM_EQ((tm{0, // sec
+                   0, // min
+                   1, // hr
+                   1, // day
+                   0, // tm_mon starts with 0 for Jan
+                   1970 - TimeConstants::TimeYearBase, // year
+                   4,                                  // wday
+                   0,                                  // yday
+                   0}),
+               *tm_data);
+}
+
+TEST(LlvmLibcGmTime, InvalidHours) {
+  time_t seconds = 0;
+  struct tm *tm_data = nullptr;
+  // -1 hour from 1970-01-01 00:00:00 returns 1969-12-31 23:00:00.
+  seconds = -TimeConstants::SecondsPerHour;
+  tm_data = __llvm_libc::gmtime(&seconds);
+  EXPECT_TM_EQ((tm{0,  // sec
+                   0,  // min
+                   23, // hr
+                   31, // day
+                   11, // tm_mon starts with 0 for Jan
+                   1969 - TimeConstants::TimeYearBase, // year
+                   3,                                  // wday
+                   0,                                  // yday
+                   0}),
+               *tm_data);
+  // 24 hours from 1970-01-01 00:00:00 returns 1970-01-02 00:00:00.
+  seconds = 24 * TimeConstants::SecondsPerHour;
+  tm_data = __llvm_libc::gmtime(&seconds);
+  EXPECT_TM_EQ((tm{0, // sec
+                   0, // min
+                   0, // hr
+                   2, // day
+                   0, // tm_mon starts with 0 for Jan
+                   1970 - TimeConstants::TimeYearBase, // year
+                   5,                                  // wday
+                   0,                                  // yday
+                   0}),
+               *tm_data);
+}
+
+TEST(LlvmLibcGmTime, InvalidYear) {
+  // -1 year from 1970-01-01 00:00:00 returns 1969-01-01 00:00:00.
+  time_t seconds =
+      -TimeConstants::DaysPerNonLeapYear * TimeConstants::SecondsPerDay;
+  struct tm *tm_data = __llvm_libc::gmtime(&seconds);
+  EXPECT_TM_EQ((tm{0, // sec
+                   0, // min
+                   0, // hr
+                   1, // day
+                   0, // tm_mon starts with 0 for Jan
+                   1969 - TimeConstants::TimeYearBase, // year
+                   3,                                  // wday
+                   0,                                  // yday
+                   0}),
+               *tm_data);
+}
+
+TEST(LlvmLibcGmTime, InvalidMonths) {
+  time_t seconds = 0;
+  struct tm *tm_data = nullptr;
+  // -1 month from 1970-01-01 00:00:00 returns 1969-12-01 00:00:00.
+  seconds = -31 * TimeConstants::SecondsPerDay;
+  tm_data = __llvm_libc::gmtime(&seconds);
+  EXPECT_TM_EQ((tm{0,      // sec
+                   0,      // min
+                   0,      // hr
+                   1,      // day
+                   12 - 1, // tm_mon starts with 0 for Jan
+                   1969 - TimeConstants::TimeYearBase, // year
+                   1,                                  // wday
+                   0,                                  // yday
+                   0}),
+               *tm_data);
+  // 1970-13-01 00:00:00 returns 1971-01-01 00:00:00.
+  seconds = TimeConstants::DaysPerNonLeapYear * TimeConstants::SecondsPerDay;
+  tm_data = __llvm_libc::gmtime(&seconds);
+  EXPECT_TM_EQ((tm{0, // sec
+                   0, // min
+                   0, // hr
+                   1, // day
+                   0, // tm_mon starts with 0 for Jan
+                   1971 - TimeConstants::TimeYearBase, // year
+                   5,                                  // wday
+                   0,                                  // yday
+                   0}),
+               *tm_data);
+}
+
+TEST(LlvmLibcGmTime, InvalidDays) {
+  time_t seconds = 0;
+  struct tm *tm_data = nullptr;
+  // -1 day from 1970-01-01 00:00:00 returns 1969-12-31 00:00:00.
+  seconds = -1 * TimeConstants::SecondsPerDay;
+  tm_data = __llvm_libc::gmtime(&seconds);
+  EXPECT_TM_EQ((tm{0,  // sec
+                   0,  // min
+                   0,  // hr
+                   31, // day
+                   11, // tm_mon starts with 0 for Jan
+                   1969 - TimeConstants::TimeYearBase, // year
+                   3,                                  // wday
+                   0,                                  // yday
+                   0}),
+               *tm_data);
+
+  // 1970-01-32 00:00:00 returns 1970-02-01 00:00:00.
+  seconds = 31 * TimeConstants::SecondsPerDay;
+  tm_data = __llvm_libc::gmtime(&seconds);
+  EXPECT_TM_EQ((tm{0, // sec
+                   0, // min
+                   0, // hr
+                   1, // day
+                   0, // tm_mon starts with 0 for Jan
+                   1970 - TimeConstants::TimeYearBase, // year
+                   0,                                  // wday
+                   0,                                  // yday
+                   0}),
+               *tm_data);
+
+  // 1970-02-29 00:00:00 returns 1970-03-01 00:00:00.
+  seconds = 59 * TimeConstants::SecondsPerDay;
+  tm_data = __llvm_libc::gmtime(&seconds);
+  EXPECT_TM_EQ((tm{0, // sec
+                   0, // min
+                   0, // hr
+                   1, // day
+                   2, // tm_mon starts with 0 for Jan
+                   1970 - TimeConstants::TimeYearBase, // year
+                   0,                                  // wday
+                   0,                                  // yday
+                   0}),
+               *tm_data);
+
+  // 1972-02-30 00:00:00 returns 1972-03-01 00:00:00.
+  seconds = ((2 * TimeConstants::DaysPerNonLeapYear) + 60) *
+            TimeConstants::SecondsPerDay;
+  tm_data = __llvm_libc::gmtime(&seconds);
+  EXPECT_TM_EQ((tm{0, // sec
+                   0, // min
+                   0, // hr
+                   1, // day
+                   2, // tm_mon starts with 0 for Jan
+                   1972 - TimeConstants::TimeYearBase, // year
+                   3,                                  // wday
+                   0,                                  // yday
+                   0}),
+               *tm_data);
+}
+
+TEST(LlvmLibcGmTime, EndOf32BitEpochYear) {
+  // Test for maximum value of a signed 32-bit integer.
+  // Test implementation can encode time for Tue 19 January 2038 03:14:07 UTC.
+  time_t seconds = 0x7FFFFFFF;
+  struct tm *tm_data = __llvm_libc::gmtime(&seconds);
+  EXPECT_TM_EQ((tm{7,  // sec
+                   14, // min
+                   3,  // hr
+                   19, // day
+                   0,  // tm_mon starts with 0 for Jan
+                   2038 - TimeConstants::TimeYearBase, // year
+                   2,                                  // wday
+                   7,                                  // yday
+                   0}),
+               *tm_data);
+}
+
+TEST(LlvmLibcGmTime, Max64BitYear) {
+  if (sizeof(time_t) == 4)
+    return;
+  // Mon Jan 1 12:50:50 2170 (200 years from 1970),
+  time_t seconds = 6311479850;
+  struct tm *tm_data = __llvm_libc::gmtime(&seconds);
+  EXPECT_TM_EQ((tm{50, // sec
+                   50, // min
+                   12, // hr
+                   1,  // day
+                   0,  // tm_mon starts with 0 for Jan
+                   2170 - TimeConstants::TimeYearBase, // year
+                   1,                                  // wday
+                   50,                                 // yday
+                   0}),
+               *tm_data);
+
+  // Test for Tue Jan 1 12:50:50 in 2,147,483,647th year.
+  seconds = 67767976202043050;
+  tm_data = __llvm_libc::gmtime(&seconds);
+  EXPECT_TM_EQ((tm{50, // sec
+                   50, // min
+                   12, // hr
+                   1,  // day
+                   0,  // tm_mon starts with 0 for Jan
+                   2147483647 - TimeConstants::TimeYearBase, // year
+                   2,                                        // wday
+                   50,                                       // yday
+                   0}),
+               *tm_data);
+}

libc/test/src/time/mktime_test.cpp

 
 TEST(LlvmLibcMkTime, FailureSetsErrno) {
   struct tm tm_data;
   initialize_tm_data(&tm_data, INT_MAX, INT_MAX, INT_MAX, INT_MAX, INT_MAX, -1,
                      0, 0);
   EXPECT_THAT(__llvm_libc::mktime(&tm_data), Fails(EOVERFLOW));
 }
 
-TEST(LlvmLibcMkTime, MkTimesInvalidSeconds) {
+TEST(LlvmLibcMkTime, InvalidSeconds) {
   struct tm tm_data;
   // -1 second from 1970-01-01 00:00:00 returns 1969-12-31 23:59:59.
   EXPECT_THAT(call_mktime(&tm_data,
                           1970, // year
                           1,    // month
                           1,    // day
                           0,    // hr
                           0,    // min
EXPECT_TM_EQ((tm{0, // sec
                    0, // tm_mon starts with 0 for Jan
                    1970 - TimeConstants::TimeYearBase, // year
                    4,                                  // wday
                    0,                                  // yday
                    0}),
                tm_data);
 }
 
-TEST(LlvmLibcMkTime, MktimeTestsInvalidMinutes) {
+TEST(LlvmLibcMkTime, InvalidMinutes) {
   struct tm tm_data;
   // -1 minute from 1970-01-01 00:00:00 returns 1969-12-31 23:59:00.
   EXPECT_THAT(call_mktime(&tm_data,
                           1970, // year
                           1,    // month
                           1,    // day
                           0,    // hr
                           -1,   // min
EXPECT_TM_EQ((tm{0, // sec
                    0, // tm_mon starts with 0 for Jan
                    1970 - TimeConstants::TimeYearBase, // year
                    4,                                  // wday
                    0,                                  // yday
                    0}),
                tm_data);
 }
 
-TEST(LlvmLibcMkTime, MktimeTestsInvalidHours) {
+TEST(LlvmLibcMkTime, InvalidHours) {
   struct tm tm_data;
   // -1 hour from 1970-01-01 00:00:00 returns 1969-12-31 23:00:00.
   EXPECT_THAT(call_mktime(&tm_data,
                           1970, // year
                           1,    // month
                           1,    // day
                           -1,   // hr
                           0,    // min
EXPECT_TM_EQ((tm{0, // sec
                    0, // tm_mon starts with 0 for Jan
                    1970 - TimeConstants::TimeYearBase, // year
                    5,                                  // wday
                    0,                                  // yday
                    0}),
                tm_data);
 }
 
-TEST(LlvmLibcMkTime, MktimeTestsInvalidYear) {
+TEST(LlvmLibcMkTime, InvalidYear) {
   struct tm tm_data;
   // -1 year from 1970-01-01 00:00:00 returns 1969-01-01 00:00:00.
   EXPECT_THAT(call_mktime(&tm_data,
                           1969, // year
                           1,    // month
                           1,    // day
                           0,    // hr
                           0,    // min
EXPECT_TM_EQ((tm{0, // sec
                    0, // tm_mon starts with 0 for Jan
                    1969 - TimeConstants::TimeYearBase, // year
                    3,                                  // wday
                    0,                                  // yday
                    0}),
                tm_data);
 }
 
-TEST(LlvmLibcMkTime, MktimeTestsInvalidEndOf32BitEpochYear) {
+TEST(LlvmLibcMkTime, InvalidEndOf32BitEpochYear) {
   if (sizeof(size_t) != 4)
     return;
   struct tm tm_data;
   // 2038-01-19 03:14:08 tests overflow of the second in 2038.
   EXPECT_THAT(call_mktime(&tm_data, 2038, 1, 19, 3, 14, 8, 0, 0),
               Succeeds(TimeConstants::OutOfRangeReturnValue));
   // 2038-01-19 03:15:07 tests overflow of the minute in 2038.
   EXPECT_THAT(call_mktime(&tm_data, 2038, 1, 19, 3, 15, 7, 0, 0),
               Succeeds(TimeConstants::OutOfRangeReturnValue));
   // 2038-01-19 04:14:07 tests overflow of the hour in 2038.
   EXPECT_THAT(call_mktime(&tm_data, 2038, 1, 19, 4, 14, 7, 0, 0),
               Succeeds(TimeConstants::OutOfRangeReturnValue));
   // 2038-01-20 03:14:07 tests overflow of the day in 2038.
   EXPECT_THAT(call_mktime(&tm_data, 2038, 1, 20, 3, 14, 7, 0, 0),
               Succeeds(TimeConstants::OutOfRangeReturnValue));
   // 2038-02-19 03:14:07 tests overflow of the month in 2038.
   EXPECT_THAT(call_mktime(&tm_data, 2038, 2, 19, 3, 14, 7, 0, 0),
               Succeeds(TimeConstants::OutOfRangeReturnValue));
   // 2039-01-19 03:14:07 tests overflow of the year.
   EXPECT_THAT(call_mktime(&tm_data, 2039, 1, 19, 3, 14, 7, 0, 0),
               Succeeds(TimeConstants::OutOfRangeReturnValue));
 }
 
-TEST(LlvmLibcMkTime, MktimeTestsInvalidMonths) {
+TEST(LlvmLibcMkTime, InvalidMonths) {
   struct tm tm_data;
   // -1 month from 1970-01-01 00:00:00 returns 1969-12-01 00:00:00.
   EXPECT_THAT(call_mktime(&tm_data,
                           1970, // year
                           0,    // month
                           1,    // day
                           0,    // hr
                           0,    // min
EXPECT_TM_EQ((tm{0, // sec
                    0, // tm_mon starts with 0 for Jan
                    1971 - TimeConstants::TimeYearBase, // year
                    5,                                  // wday
                    0,                                  // yday
                    0}),
                tm_data);
 }
 
-TEST(LlvmLibcMkTime, MktimeTestsInvalidDays) {
+TEST(LlvmLibcMkTime, InvalidDays) {
   struct tm tm_data;
   // -1 day from 1970-01-01 00:00:00 returns 1969-12-31 00:00:00.
   EXPECT_THAT(call_mktime(&tm_data,
                           1970, // year
                           1,    // month
                           0,    // day
                           0,    // hr
                           0,    // min
EXPECT_TM_EQ((tm{0, // sec
                    2, // tm_mon starts with 0 for Jan
                    1972 - TimeConstants::TimeYearBase, // year
                    3,                                  // wday
                    0,                                  // yday
                    0}),
                tm_data);
 }
 
-TEST(LlvmLibcMkTime, MktimeTestsEndOf32BitEpochYear) {
+TEST(LlvmLibcMkTime, EndOf32BitEpochYear) {
   struct tm tm_data;
   // Test for maximum value of a signed 32-bit integer.
   // Test implementation can encode time for Tue 19 January 2038 03:14:07 UTC.
   EXPECT_THAT(call_mktime(&tm_data,
                           2038, // year
                           1,    // month
                           19,   // day
                           3,    // hr
EXPECT_TM_EQ((tm{7,  // sec
                    0,  // tm_mon starts with 0 for Jan
                    2038 - TimeConstants::TimeYearBase, // year
                    2,                                  // wday
                    7,                                  // yday
                    0}),
                tm_data);
 }
 
-TEST(LlvmLibcMkTime, MktimeTests64BitYear) {
+TEST(LlvmLibcMkTime, Max64BitYear) {
   if (sizeof(time_t) == 4)
     return;
   // Mon Jan 1 12:50:50 2170 (200 years from 1970),
   struct tm tm_data;
   EXPECT_THAT(call_mktime(&tm_data,
                           2170, // year
                           1,    // month
                           1,    // day