//===-- 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 namespace __llvm_libc { 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) { // 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( TimeConstants::NumberOfSecondsInLeapYear) || total_seconds > INT_MAX * static_cast( 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) { 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(); return static_cast(seconds); } } // namespace __llvm_libc