<chrono>: make system_clock::now() and file_clock aware of Windows leap second handling

stl/CMakeLists.txt

@@ -232,6 +232,7 @@ set(HEADERS
     ${CMAKE_CURRENT_LIST_DIR}/inc/xstddef
     ${CMAKE_CURRENT_LIST_DIR}/inc/xstring
     ${CMAKE_CURRENT_LIST_DIR}/inc/xthreads.h
+    ${CMAKE_CURRENT_LIST_DIR}/inc/xtime0.h
     ${CMAKE_CURRENT_LIST_DIR}/inc/xtimec.h
     ${CMAKE_CURRENT_LIST_DIR}/inc/xtr1common
     ${CMAKE_CURRENT_LIST_DIR}/inc/xtree
@@ -256,6 +257,7 @@ set(IMPLIB_SOURCES
     ${CMAKE_CURRENT_LIST_DIR}/src/syserror_import_lib.cpp
     ${CMAKE_CURRENT_LIST_DIR}/src/vector_algorithms.cpp
     ${CMAKE_CURRENT_LIST_DIR}/src/xonce2.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/xtime0.cpp
 )
 
 # The following files are linked in msvcp140[d][_clr].dll.

stl/inc/chrono

@@ -12,6 +12,7 @@
 #include <limits>
 #include <ratio>
 #include <utility>
+#include <xtime0.h>
 #include <xtimec.h>
 
 #if _HAS_CXX20
@@ -663,6 +664,29 @@ namespace chrono {
     }
 
     // CLOCKS
+
+    // _Civil_from_days and _Days_from_civil perform conversions between the dates in the (proleptic) Gregorian
+    // calendar and the continuous count of days since 1970-01-01.
+
+    // See comments above year_month_day::_Civil_from_days for an explanation of the algorithm.
+
+    // courtesy of Howard Hinnant
+    // https://howardhinnant.github.io/date_algorithms.html#days_from_civil
+    _NODISCARD constexpr int _Days_from_civil(
+        const int _Year, const unsigned int _Month, const unsigned int _Day) noexcept {
+        static_assert(numeric_limits<unsigned int>::digits >= 18,
+            "This algorithm has not been ported to a 16 bit unsigned integer");
+        static_assert(
+            numeric_limits<int>::digits >= 26, "This algorithm has not been ported to a 16 bit signed integer");
+        const int _Yp          = static_cast<int>(_Year) - (_Month <= 2);
+        const int _Century     = (_Yp >= 0 ? _Yp : _Yp - 99) / 100;
+        const unsigned int _Mp = _Month + (_Month > 2 ? static_cast<unsigned int>(-3) : 9); // [0, 11]
+        // Formula 1
+        const int _Day_of_year = static_cast<int>(((979 * _Mp + 19) >> 5) + _Day) - 1;
+        // Formula 2
+        return ((1461 * _Yp) >> 2) - _Century + (_Century >> 2) + _Day_of_year - 719468;
+    }
+
     struct system_clock { // wraps GetSystemTimePreciseAsFileTime/GetSystemTimeAsFileTime
         using rep                       = long long;
         using period                    = ratio<1, 10'000'000>; // 100 nanoseconds
@@ -671,7 +695,29 @@ namespace chrono {
         static constexpr bool is_steady = false;
 
         _NODISCARD static time_point now() noexcept { // get current time
-            return time_point(duration(_Xtime_get_ticks()));
+            constexpr long long __std_fs_file_time_epoch_adjustment = 0x19DB1DED53E8000LL; // TRANSITION, ABI
+
+            const duration _File_time{_Xtime_get_ticks() + __std_fs_file_time_epoch_adjustment};
+            const auto _File_seconds = _CHRONO duration_cast<seconds>(_File_time);
+
+            __std_utc_components_1s _Utc;
+            const __std_file_time_to_utc_errc _Ec = __std_file_seconds_to_utc_components(_File_seconds.count(), &_Utc);
+            _STL_INTERNAL_CHECK(_Ec == __std_file_time_to_utc_errc::_Success);
+            if (_Ec == __std_file_time_to_utc_errc::_Invalid_parameter) {
+                return time_point{_File_time - duration{__std_fs_file_time_epoch_adjustment}};
+            }
+
+            using _Days         = _CHRONO duration<int, ratio<86'400>>;
+            using _Int_seconds  = _CHRONO duration<int>;
+            const duration _Ymd = _Days{_Days_from_civil(_Utc._Year, _Utc._Month, _Utc._Day)};
+            const duration _Hms = hours{_Utc._Hour} + minutes{_Utc._Minute} + _Int_seconds{_Utc._Second};
+
+            if (_Utc._Second < 60) {
+                return time_point{_Ymd + _Hms + (_File_time - _File_seconds)};
+            } else {
+                // positive leap second
+                return time_point{_Ymd + _Hms - duration{1}};
+            }
         }
 
         _NODISCARD static __time64_t to_time_t(const time_point& _Time) noexcept { // convert to __time64_t
@@ -1589,19 +1635,10 @@ namespace chrono {
             const unsigned int _Month = _Mp + (_Mp < 10 ? 3 : static_cast<unsigned int>(-9)); // [1, 12]
             return year_month_day{_CHRONO year{_Yp + (_Month <= 2)}, _CHRONO month{_Month}, _CHRONO day{_Day}};
         }
-        // courtesy of Howard Hinnant
-        // https://howardhinnant.github.io/date_algorithms.html#days_from_civil
+
         _NODISCARD constexpr days _Days_from_civil() const noexcept {
-            static_assert(numeric_limits<unsigned int>::digits >= 18);
-            static_assert(numeric_limits<int>::digits >= 26);
-            const unsigned int _Mo = static_cast<unsigned int>(_Month); // [1, 12]
-            const int _Yp          = static_cast<int>(_Year) - (_Mo <= 2);
-            const int _Century     = (_Yp >= 0 ? _Yp : _Yp - 99) / 100;
-            const unsigned int _Mp = _Mo + (_Mo > 2 ? static_cast<unsigned int>(-3) : 9); // [0, 11]
-            // Formula 1
-            const int _Day_of_year = static_cast<int>(((979 * _Mp + 19) >> 5) + static_cast<unsigned int>(_Day)) - 1;
-            // Formula 2
-            return days{((1461 * _Yp) >> 2) - _Century + (_Century >> 2) + _Day_of_year - 719468};
+            return days{_CHRONO _Days_from_civil(
+                static_cast<int>(_Year), static_cast<unsigned int>(_Month), static_cast<unsigned int>(_Day))};
         }
     };
 
@@ -6523,15 +6560,15 @@ namespace chrono {
 
 // HELPERS
 template <class _Rep, class _Period>
-_NODISCARD bool _To_xtime_10_day_clamped(_CSTD xtime& _Xt, const _CHRONO duration<_Rep, _Period>& _Rel_time) noexcept(
-    is_arithmetic_v<_Rep>) {
+_NODISCARD bool _To_xtime_10_day_clamped_v2(
+    _CSTD xtime& _Xt, const _CHRONO duration<_Rep, _Period>& _Rel_time) noexcept(is_arithmetic_v<_Rep>) {
     // Convert duration to xtime, maximum 10 days from now, returns whether clamping occurred.
     // If clamped, timeouts will be transformed into spurious non-timeout wakes, due to ABI restrictions where
     // the other side of the DLL boundary overflows int32_t milliseconds.
     // Every function calling this one is TRANSITION, ABI
     constexpr _CHRONO nanoseconds _Ten_days{_CHRONO hours{24} * 10};
     constexpr _CHRONO duration<double> _Ten_days_d{_Ten_days};
-    _CHRONO nanoseconds _Tx0 = _CHRONO system_clock::now().time_since_epoch();
+    _CHRONO nanoseconds _Tx0 = _CHRONO system_clock::duration{_Xtime_get_ticks()};
     const bool _Clamped      = _Ten_days_d < _Rel_time;
     if (_Clamped) {
         _Tx0 += _Ten_days;
@@ -6546,6 +6583,12 @@ _NODISCARD bool _To_xtime_10_day_clamped(_CSTD xtime& _Xt, const _CHRONO duratio
     return _Clamped;
 }
 
+template <class _Rep, class _Period>
+_NODISCARD bool _To_xtime_10_day_clamped(_CSTD xtime& _Xt, const _CHRONO duration<_Rep, _Period>& _Rel_time) noexcept(
+    is_arithmetic_v<_Rep>) {
+    return _To_xtime_10_day_clamped_v2(_Xt, _Rel_time);
+}
+
 // duration LITERALS
 inline namespace literals {
     inline namespace chrono_literals {

stl/inc/condition_variable

@@ -124,7 +124,7 @@ public:
         // TRANSITION, ABI: The standard says that we should use a steady clock,
         // but unfortunately our ABI speaks struct xtime, which is relative to the system clock.
         _CSTD xtime _Tgt;
-        const bool _Clamped     = _To_xtime_10_day_clamped(_Tgt, _Rel_time);
+        const bool _Clamped     = _To_xtime_10_day_clamped_v2(_Tgt, _Rel_time);
         const cv_status _Result = _Wait_until(_Lck, &_Tgt);
         if (_Clamped) {
             return cv_status::no_timeout;
@@ -221,7 +221,7 @@ public:
             // TRANSITION, ABI: The standard says that we should use a steady clock,
             // but unfortunately our ABI speaks struct xtime, which is relative to the system clock.
             _CSTD xtime _Tgt;
-            (void) _To_xtime_10_day_clamped(_Tgt, _Rel_time);
+            (void) _To_xtime_10_day_clamped_v2(_Tgt, _Rel_time);
             const int _Res = _Cnd_timedwait(_Mycnd(), _Myptr->_Mymtx(), &_Tgt);
             _Guard.unlock();
 

stl/inc/mutex

@@ -625,7 +625,7 @@ public:
         // TRANSITION, ABI: The standard says that we should use a steady clock,
         // but unfortunately our ABI speaks struct xtime, which is relative to the system clock.
         _CSTD xtime _Tgt;
-        const bool _Clamped     = _To_xtime_10_day_clamped(_Tgt, _Rel_time);
+        const bool _Clamped     = _To_xtime_10_day_clamped_v2(_Tgt, _Rel_time);
         const cv_status _Result = wait_until(_Lck, &_Tgt);
         if (_Clamped) {
             return cv_status::no_timeout;
@@ -653,7 +653,7 @@ public:
             }
 
             _CSTD xtime _Tgt;
-            (void) _To_xtime_10_day_clamped(_Tgt, _Abs_time - _Now);
+            (void) _To_xtime_10_day_clamped_v2(_Tgt, _Abs_time - _Now);
             const cv_status _Result = wait_until(_Lck, &_Tgt);
             if (_Result == cv_status::no_timeout) {
                 return cv_status::no_timeout;
@@ -736,7 +736,7 @@ private:
             }
 
             _CSTD xtime _Tgt;
-            const bool _Clamped = _To_xtime_10_day_clamped(_Tgt, _Abs_time - _Now);
+            const bool _Clamped = _To_xtime_10_day_clamped_v2(_Tgt, _Abs_time - _Now);
             if (wait_until(_Lck, &_Tgt) == cv_status::timeout && !_Clamped) {
                 return _Pred();
             }

stl/inc/thread

@@ -196,7 +196,7 @@ namespace this_thread {
             }
 
             _CSTD xtime _Tgt;
-            (void) _To_xtime_10_day_clamped(_Tgt, _Abs_time - _Now);
+            (void) _To_xtime_10_day_clamped_v2(_Tgt, _Abs_time - _Now);
             _Thrd_sleep(&_Tgt);
         }
     }

stl/inc/xtime0.h

@@ -0,0 +1,99 @@
+// xtime0.h internal header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+// This must be as small as possible, because its contents are
+// injected into the msvcprt.lib and msvcprtd.lib import libraries.
+// Do not include or define anything else here.
+// In particular, basic_string must not be included here.
+
+#pragma once
+#ifndef _XTIME0_H
+#define _XTIME0_H
+
+#include <yvals_core.h>
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+_EXTERN_C
+
+// clang-format off
+struct __std_win_system_time {    // typedef struct _SYSTEMTIME {
+    unsigned short _Year;         //     WORD wYear;
+    unsigned short _Month;        //     WORD wMonth;
+    unsigned short _Day_of_week;  //     WORD wDayOfWeek;
+    unsigned short _Day;          //     WORD wDay;
+    unsigned short _Hour;         //     WORD wHour;
+    unsigned short _Minute;       //     WORD wMinute;
+    unsigned short _Second;       //     WORD wSecond;
+    unsigned short _Milliseconds; //     WORD wMilliseconds;
+};                                // } SYSTEMTIME, *PSYSTEMTIME, *LPSYSTEMTIME;
+// clang-format on
+
+struct __std_utc_components_1s {
+    short _Year;
+    unsigned char _Month;
+    unsigned char _Day;
+    unsigned char _Weekday;
+    unsigned char _Hour;
+    unsigned char _Minute;
+    unsigned char _Second;
+};
+
+// SystemTimeToFileTime
+// returns -1 on failure
+_NODISCARD long long __stdcall __std_win_system_time_to_file_time(const __std_win_system_time* _System_time) noexcept;
+
+// FileTimeToSystemTime
+_NODISCARD bool __stdcall __std_win_file_time_to_system_time(
+    long long _File_time, __std_win_system_time* _Out_system_time) noexcept;
+
+enum class __std_utc_to_file_time_errc {
+    _Success = 0,
+
+    // input is invalid regardless of whether there are leap seconds
+    // _Out_file_seconds is not set
+    _Invalid_parameter = 0b001,
+
+    // __std_utc_components_to_file_seconds only
+    // second 60 without a positive leap second, or second 59 deleted by a negative leap second
+    // sets _Out_file_seconds to the value corresponding to second 00 of the next minute
+    _Nonexistent = 0b010,
+
+    // SystemTimeToFileTime returns unexpected sub-second values
+    _Unknown_smear = 0b100,
+};
+
+enum class __std_file_time_to_utc_errc {
+    _Success = 0,
+
+    _Invalid_parameter = static_cast<int>(__std_utc_to_file_time_errc::_Invalid_parameter),
+
+    // FileTimeToSystemTime returns unexpected sub-second values
+    _Unknown_smear = static_cast<int>(__std_utc_to_file_time_errc::_Unknown_smear),
+};
+
+// converts UTC (whole seconds) into file_time<seconds>
+_NODISCARD __std_utc_to_file_time_errc __stdcall __std_utc_components_to_file_seconds(
+    const __std_utc_components_1s* _Utc_time, long long* _Out_file_seconds) noexcept;
+
+// converts file_time<seconds> into UTC
+_NODISCARD __std_file_time_to_utc_errc __stdcall __std_file_seconds_to_utc_components(
+    long long _File_seconds, __std_utc_components_1s* _Out_utc_time) noexcept;
+
+_END_EXTERN_C
+
+_BITMASK_OPS(__std_utc_to_file_time_errc)
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+
+#endif // defined(_XTIME0_H)