libstdc++: Add C++20 clocks

Also add the basic types for timezones, without the non-inline
definitions needed to actually use them.

The get_leap_second_info function currently uses a hardcoded list of
leap seconds, correct as of the end of 2022. That needs to be replaced
with a dynamically generated list read from the system tzdata. That will
be done in a later patch.

libstdc++-v3/ChangeLog:

	* include/std/chrono (utc_clock, tai_clock, gps_clock): Define.
	(clock_time_conversion, clock_cast): Define.
	(sys_info, local_info): Define structs for timezone information.
	(nonexistent_local_time, ambiguous_local_time): Define
	exceptions for invalid times.
	(time_zone, time_zone_link, leap_second, zoned_traits, tzdb)
	(tzdb_list): Define classes representing time zones.
	(get_leap_second_info): Define new function returning leap
	second offset for a given time point.
	* testsuite/std/time/clock/gps/1.cc: New test.
	* testsuite/std/time/clock/tai/1.cc: New test.
	* testsuite/std/time/clock/utc/1.cc: New test.

4 files changed, 844 insertions, 3 deletions

diff --git a/libstdc++-v3/include/std/chrono b/libstdc++-v3/include/std/chrono
index c0c3a67..90b73f8 100644
--- a/libstdc++-v3/include/std/chrono
+++ b/libstdc++-v3/include/std/chrono
@@ -39,9 +39,15 @@
 #else
 
 #include <bits/chrono.h>
-#if __cplusplus > 201703L
-# include <sstream> // ostringstream
-# include <bits/charconv.h>
+
+#if __cplusplus >= 202002L
+# include <sstream>
+# include <string>
+# include <vector>
+# include <bits/charconv.h> // __to_chars_len, __to_chars_10_impl
+# include <bits/stl_algo.h> // upper_bound TODO: move leap_second_info to .so
+# include <bits/shared_ptr.h>
+# include <bits/unique_ptr.h>
 #endif
 
 namespace std _GLIBCXX_VISIBILITY(default)
@@ -102,6 +108,357 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       seconds elapsed;
     };
 
+    template<typename _Duration>
+      leap_second_info
+      get_leap_second_info(const utc_time<_Duration>& __ut);
+
+    /** A clock that measures Universal Coordinated Time (UTC).
+     *
+     * The epoch is 1970-01-01 00:00:00.
+     *
+     * @since C++20
+     */
+    class utc_clock
+    {
+    public:
+      using rep                       = system_clock::rep;
+      using period                    = system_clock::period;
+      using duration                  = chrono::duration<rep, period>;
+      using time_point                = chrono::time_point<utc_clock>;
+      static constexpr bool is_steady = false;
+
+      static time_point
+      now()
+      { return from_sys(system_clock::now()); }
+
+      template<typename _Duration>
+	static sys_time<common_type_t<_Duration, seconds>>
+	to_sys(const utc_time<_Duration>& __t)
+	{
+	  using _CDur = common_type_t<_Duration, seconds>;
+	  const auto __li = chrono::get_leap_second_info(__t);
+	  sys_time<_CDur> __s{__t.time_since_epoch() - seconds{__li.elapsed}};
+	  if (__li.is_leap_second)
+	    __s = chrono::floor<seconds>(__s) + seconds{1} - _CDur{1};
+	  return __s;
+	}
+
+      template<typename _Duration>
+	static utc_time<common_type_t<_Duration, seconds>>
+	from_sys(const sys_time<_Duration>& __t)
+	{
+	  using _CDur = common_type_t<_Duration, seconds>;
+	  utc_time<_Duration> __u(__t.time_since_epoch());
+	  const auto __li = chrono::get_leap_second_info(__u);
+	  return utc_time<_CDur>{__u} + seconds{__li.elapsed};
+	}
+    };
+
+    /** A clock that measures International Atomic Time.
+     *
+     * The epoch is 1958-01-01 00:00:00.
+     *
+     * @since C++20
+     */
+    class tai_clock
+    {
+    public:
+      using rep                       = system_clock::rep;
+      using period                    = system_clock::period;
+      using duration                  = chrono::duration<rep, period>;
+      using time_point                = chrono::time_point<tai_clock>;
+      static constexpr bool is_steady = false; // XXX true for CLOCK_TAI?
+
+      // TODO move into lib, use CLOCK_TAI on linux, add extension point.
+      static time_point
+      now()
+      { return from_utc(utc_clock::now()); }
+
+      template<typename _Duration>
+	static utc_time<common_type_t<_Duration, seconds>>
+	to_utc(const tai_time<_Duration>& __t)
+	{
+	  using _CDur = common_type_t<_Duration, seconds>;
+	  return utc_time<_CDur>{__t.time_since_epoch()} - 378691210s;
+	}
+
+      template<typename _Duration>
+	static tai_time<common_type_t<_Duration, seconds>>
+	from_utc(const utc_time<_Duration>& __t)
+	{
+	  using _CDur = common_type_t<_Duration, seconds>;
+	  return tai_time<_CDur>{__t.time_since_epoch()} + 378691210s;
+	}
+    };
+
+    /** A clock that measures GPS time.
+     *
+     * The epoch is 1980-01-06 00:00:00.
+     *
+     * @since C++20
+     */
+    class gps_clock
+    {
+    public:
+      using rep                       = system_clock::rep;
+      using period                    = system_clock::period;
+      using duration                  = chrono::duration<rep, period>;
+      using time_point                = chrono::time_point<gps_clock>;
+      static constexpr bool is_steady = false; // XXX
+
+      // TODO move into lib, add extension point.
+      static time_point
+      now()
+      { return from_utc(utc_clock::now()); }
+
+      template<typename _Duration>
+	static utc_time<common_type_t<_Duration, seconds>>
+	to_utc(const gps_time<_Duration>& __t)
+	{
+	  using _CDur = common_type_t<_Duration, seconds>;
+	  return utc_time<_CDur>{__t.time_since_epoch()} + 315964809s;
+	}
+
+      template<typename _Duration>
+	static gps_time<common_type_t<_Duration, seconds>>
+	from_utc(const utc_time<_Duration>& __t)
+	{
+	  using _CDur = common_type_t<_Duration, seconds>;
+	  return gps_time<_CDur>{__t.time_since_epoch()} - 315964809s;
+	}
+    };
+
+
+    template<typename _DestClock, typename _SourceClock>
+      struct clock_time_conversion
+      { };
+
+    // Identity conversions
+
+    template<typename _Clock>
+      struct clock_time_conversion<_Clock, _Clock>
+      {
+	template<typename _Duration>
+	  time_point<_Clock, _Duration>
+	  operator()(const time_point<_Clock, _Duration>& __t) const
+	  { return __t; }
+      };
+
+    template<>
+      struct clock_time_conversion<system_clock, system_clock>
+      {
+	template<typename _Duration>
+	  sys_time<_Duration>
+	  operator()(const sys_time<_Duration>& __t) const
+	  { return __t; }
+      };
+
+    template<>
+      struct clock_time_conversion<utc_clock, utc_clock>
+      {
+	template<typename _Duration>
+	  utc_time<_Duration>
+	  operator()(const utc_time<_Duration>& __t) const
+	  { return __t; }
+      };
+
+    // Conversions between system_clock and utc_clock
+
+    template<>
+      struct clock_time_conversion<utc_clock, system_clock>
+      {
+	template<typename _Duration>
+	  utc_time<common_type_t<_Duration, seconds>>
+	  operator()(const sys_time<_Duration>& __t) const
+	  { return utc_clock::from_sys(__t); }
+      };
+
+    template<>
+      struct clock_time_conversion<system_clock, utc_clock>
+      {
+	template<typename _Duration>
+	  sys_time<common_type_t<_Duration, seconds>>
+	  operator()(const utc_time<_Duration>& __t) const
+	  { return utc_clock::to_sys(__t); }
+      };
+
+    template<typename _Tp, typename _Clock>
+      inline constexpr bool __is_time_point_for_v = false;
+
+    template<typename _Clock, typename _Duration>
+      inline constexpr bool
+       __is_time_point_for_v<time_point<_Clock, _Duration>, _Clock> = true;
+
+    // Conversions between system_clock and other clocks
+
+    template<typename _SourceClock>
+      struct clock_time_conversion<system_clock, _SourceClock>
+      {
+	template<typename _Duration, typename _Src = _SourceClock>
+	  auto
+	  operator()(const time_point<_SourceClock, _Duration>& __t) const
+	  -> decltype(_Src::to_sys(__t))
+	  {
+	    using _Ret = decltype(_SourceClock::to_sys(__t));
+	    static_assert(__is_time_point_for_v<_Ret, system_clock>);
+	    return _SourceClock::to_sys(__t);
+	  }
+      };
+
+    template<typename _DestClock>
+      struct clock_time_conversion<_DestClock, system_clock>
+      {
+	template<typename _Duration, typename _Dest = _DestClock>
+	  auto
+	  operator()(const sys_time<_Duration>& __t) const
+	  -> decltype(_Dest::from_sys(__t))
+	  {
+	    using _Ret = decltype(_DestClock::from_sys(__t));
+	    static_assert(__is_time_point_for_v<_Ret, _DestClock>);
+	    return _DestClock::from_sys(__t);
+	  }
+      };
+
+    // Conversions between utc_clock and other clocks
+
+    template<typename _SourceClock>
+      struct clock_time_conversion<utc_clock, _SourceClock>
+      {
+	template<typename _Duration, typename _Src = _SourceClock>
+	  auto
+	  operator()(const time_point<_SourceClock, _Duration>& __t) const
+	  -> decltype(_Src::to_utc(__t))
+	  {
+	    using _Ret = decltype(_SourceClock::to_utc(__t));
+	    static_assert(__is_time_point_for_v<_Ret, utc_clock>);
+	    return _SourceClock::to_utc(__t);
+	  }
+      };
+
+    template<typename _DestClock>
+      struct clock_time_conversion<_DestClock, utc_clock>
+      {
+	template<typename _Duration, typename _Dest = _DestClock>
+	  auto
+	  operator()(const utc_time<_Duration>& __t) const
+	  -> decltype(_Dest::from_utc(__t))
+	  {
+	    using _Ret = decltype(_DestClock::from_utc(__t));
+	    static_assert(__is_time_point_for_v<_Ret, _DestClock>);
+	    return _DestClock::from_utc(__t);
+	  }
+      };
+
+    /// @cond undocumented
+    namespace __detail
+    {
+      template<typename _DestClock, typename _SourceClock, typename _Duration>
+       concept __clock_convs
+	  = requires (const time_point<_SourceClock, _Duration>& __t) {
+	    clock_time_conversion<_DestClock, _SourceClock>{}(__t);
+	  };
+
+      template<typename _DestClock, typename _SourceClock, typename _Duration>
+       concept __clock_convs_sys
+	  = requires (const time_point<_SourceClock, _Duration>& __t) {
+	    clock_time_conversion<_DestClock, system_clock>{}(
+	      clock_time_conversion<system_clock, _SourceClock>{}(__t));
+	  };
+
+      template<typename _DestClock, typename _SourceClock, typename _Duration>
+       concept __clock_convs_utc
+	  = requires (const time_point<_SourceClock, _Duration>& __t) {
+	    clock_time_conversion<_DestClock, utc_clock>{}(
+	      clock_time_conversion<utc_clock, _SourceClock>{}(__t));
+	  };
+
+      template<typename _DestClock, typename _SourceClock, typename _Duration>
+	concept __clock_convs_sys_utc
+	  = requires (const time_point<_SourceClock, _Duration>& __t) {
+	    clock_time_conversion<_DestClock, utc_clock>{}(
+	      clock_time_conversion<utc_clock, system_clock>{}(
+		clock_time_conversion<system_clock, _SourceClock>{}(__t)));
+	  };
+
+      template<typename _DestClock, typename _SourceClock, typename _Duration>
+       concept __clock_convs_utc_sys
+	  = requires (const time_point<_SourceClock, _Duration>& __t) {
+	    clock_time_conversion<_DestClock, system_clock>{}(
+	      clock_time_conversion<system_clock, utc_clock>{}(
+		clock_time_conversion<utc_clock, _SourceClock>{}(__t)));
+	  };
+
+    } // namespace __detail
+    /// @endcond
+
+    /// Convert a time point to a different clock.
+    template<typename _DestClock, typename _SourceClock, typename _Duration>
+      inline auto
+      clock_cast(const time_point<_SourceClock, _Duration>& __t)
+      requires __detail::__clock_convs<_DestClock, _SourceClock, _Duration>
+	|| __detail::__clock_convs_sys<_DestClock, _SourceClock, _Duration>
+	|| __detail::__clock_convs_utc<_DestClock, _SourceClock, _Duration>
+	|| __detail::__clock_convs_sys_utc<_DestClock, _SourceClock, _Duration>
+	|| __detail::__clock_convs_utc_sys<_DestClock, _SourceClock, _Duration>
+      {
+       constexpr bool __direct
+	 = __detail::__clock_convs<_DestClock, _SourceClock, _Duration>;
+       if constexpr (__direct)
+	 {
+	   return clock_time_conversion<_DestClock, _SourceClock>{}(__t);
+	 }
+       else
+	 {
+	   constexpr bool __convert_via_sys_clock
+	     = __detail::__clock_convs_sys<_DestClock, _SourceClock, _Duration>;
+	   constexpr bool __convert_via_utc_clock
+	     = __detail::__clock_convs_utc<_DestClock, _SourceClock, _Duration>;
+	   if constexpr (__convert_via_sys_clock)
+	     {
+	       static_assert(!__convert_via_utc_clock,
+		 "clock_cast requires a unique best conversion, but "
+		 "conversion is possible via system_clock and also via"
+		 "utc_clock");
+	       return clock_time_conversion<_DestClock, system_clock>{}(
+			clock_time_conversion<system_clock, _SourceClock>{}(__t));
+	     }
+	   else if constexpr (__convert_via_utc_clock)
+	     {
+	       return clock_time_conversion<_DestClock, utc_clock>{}(
+			clock_time_conversion<utc_clock, _SourceClock>{}(__t));
+	     }
+	   else
+	     {
+	       constexpr bool __convert_via_sys_and_utc_clocks
+		 = __detail::__clock_convs_sys_utc<_DestClock,
+						   _SourceClock,
+						   _Duration>;
+
+	       if constexpr (__convert_via_sys_and_utc_clocks)
+		 {
+		   constexpr bool __convert_via_utc_and_sys_clocks
+		     = __detail::__clock_convs_utc_sys<_DestClock,
+						       _SourceClock,
+						       _Duration>;
+		   static_assert(!__convert_via_utc_and_sys_clocks,
+		     "clock_cast requires a unique best conversion, but "
+		     "conversion is possible via system_clock followed by "
+		     "utc_clock, and also via utc_clock followed by "
+		     "system_clock");
+		   return clock_time_conversion<_DestClock, utc_clock>{}(
+			    clock_time_conversion<utc_clock, system_clock>{}(
+			      clock_time_conversion<system_clock, _SourceClock>{}(__t)));
+		 }
+	       else
+		 {
+		   return clock_time_conversion<_DestClock, system_clock>{}(
+			    clock_time_conversion<system_clock, utc_clock>{}(
+			      clock_time_conversion<utc_clock, _SourceClock>{}(__t)));
+		 }
+	     }
+	 }
+      }
+
     // CALENDRICAL TYPES
 
     // CLASS DECLARATIONS
@@ -2055,6 +2412,387 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	    return __h + 12h;
 	}
     }
+
+    // C++20 [time.zones] Time zones
+
+    struct sys_info
+    {
+      sys_seconds begin;
+      sys_seconds end;
+      seconds offset;
+      minutes save;
+      string abbrev;
+    };
+
+    struct local_info
+    {
+      static constexpr int unique      = 0;
+      static constexpr int nonexistent = 1;
+      static constexpr int ambiguous   = 2;
+
+      int result;
+      sys_info first;
+      sys_info second;
+    };
+
+    class nonexistent_local_time : public runtime_error
+    {
+    public:
+      template<typename _Duration>
+	nonexistent_local_time(const local_time<_Duration>& __tp,
+			       const local_info& __i)
+	: runtime_error(_S_make_what_str(__tp, __i))
+	{ __glibcxx_assert(__i.result == local_info::nonexistent); }
+
+    private:
+      template<typename _Duration> // TODO
+	static string
+	_S_make_what_str(const local_time<_Duration>&, const local_info&);
+    };
+
+    class ambiguous_local_time : public runtime_error
+    {
+    public:
+      template<typename _Duration>
+	ambiguous_local_time(const local_time<_Duration>& __tp,
+			       const local_info& __i)
+	: runtime_error(_S_make_what_str(__tp, __i))
+	{ __glibcxx_assert(__i.result == local_info::nonexistent); }
+
+    private:
+      template<typename _Duration> // TODO
+	static string
+	_S_make_what_str(const local_time<_Duration>&, const local_info&);
+    };
+
+    enum class choose { earliest, latest };
+
+    class time_zone
+    {
+    public:
+      time_zone(time_zone&&) = default;
+      time_zone& operator=(time_zone&&) = default;
+
+      string_view name() const noexcept { return _M_name; }
+
+      template<typename _Duration>
+	sys_info
+	get_info(const sys_time<_Duration>& __st) const;
+
+      template<typename _Duration>
+	local_info
+	get_info(const local_time<_Duration>& __tp) const;
+
+      template<typename _Duration>
+	sys_time<common_type_t<_Duration, seconds>>
+	to_sys(const local_time<_Duration>& __tp) const;
+
+      template<typename _Duration>
+	sys_time<common_type_t<_Duration, seconds>>
+	to_sys(const local_time<_Duration>& __tp, choose __z) const;
+
+      template<typename _Duration>
+	local_time<common_type_t<_Duration, seconds>>
+	to_local(const sys_time<_Duration>& __tp) const;
+
+      friend bool
+      operator==(const time_zone& __x, const time_zone& __y) noexcept
+      { return __x.name() == __y.name(); }
+
+      friend strong_ordering
+      operator<=>(const time_zone& __x, const time_zone& __y) noexcept
+      { return __x.name() <=> __y.name(); }
+
+    private:
+      string _M_name;
+      struct _Impl;
+      unique_ptr<_Impl> _M_impl;
+    };
+
+    struct tzdb;
+    const time_zone* locate_zone(string_view __tz_name);
+    const time_zone* current_zone();
+
+    class time_zone_link
+    {
+    public:
+      time_zone_link(time_zone_link&&) = default;
+      time_zone_link& operator=(time_zone_link&&) = default;
+
+      string_view name() const noexcept { return _M_name; }
+      string_view target() const noexcept { return _M_target; }
+
+      friend bool
+      operator==(const time_zone_link& __x, const time_zone_link& __y) noexcept
+      { return __x.name() == __y.name(); }
+
+      friend strong_ordering
+      operator<=>(const time_zone_link& __x, const time_zone_link& __y) noexcept
+      { return __x.name() <=> __y.name(); }
+
+    private:
+      friend const tzdb& reload_tzdb();
+      // TODO unspecified additional constructors
+      string _M_name;
+      string _M_target;
+    };
+
+    class leap_second
+    {
+    public:
+      leap_second(const leap_second&) = default;
+      leap_second& operator=(const leap_second&) = default;
+
+      constexpr sys_seconds
+      date() const noexcept
+      {
+	if (_M_s >= _M_s.zero()) [[likely]]
+	  return sys_seconds(_M_s);
+	return sys_seconds(-_M_s);
+      }
+
+      constexpr seconds
+      value() const noexcept
+      {
+	if (_M_s >= _M_s.zero()) [[likely]]
+	  return seconds(1);
+	return seconds(-1);
+      }
+
+      // This can be defaulted because the database will never contain two
+      // leap_second objects with the same date but different signs.
+      friend constexpr bool
+      operator==(const leap_second&, const leap_second&) noexcept = default;
+
+      friend constexpr strong_ordering
+      operator<=>(const leap_second& __x, const leap_second& __y) noexcept
+      { return __x.date() <=> __y.date(); }
+
+      template<typename _Duration>
+	friend constexpr bool
+	operator==(const leap_second& __x,
+		   const sys_time<_Duration>& __y) noexcept
+	{ return __x.date() == __y; }
+
+      template<typename _Duration>
+	friend constexpr bool
+	operator<(const leap_second& __x,
+		  const sys_time<_Duration>& __y) noexcept
+	{ return __x.date() < __y; }
+
+      template<typename _Duration>
+	friend constexpr bool
+	operator<(const sys_time<_Duration>& __x,
+		  const leap_second& __y) noexcept
+	{ return __x < __y.date(); }
+
+      template<typename _Duration>
+	friend constexpr bool
+	operator>(const leap_second& __x,
+		  const sys_time<_Duration>& __y) noexcept
+	{ return __y < __x.date(); }
+
+      template<typename _Duration>
+	friend constexpr bool
+	operator>(const sys_time<_Duration>& __x,
+		  const leap_second& __y) noexcept
+	{ return __y.date() < __x; }
+
+      template<typename _Duration>
+	friend constexpr bool
+	operator<=(const leap_second& __x,
+		  const sys_time<_Duration>& __y) noexcept
+	{ return !(__y < __x.date()); }
+
+      template<typename _Duration>
+	friend constexpr bool
+	operator<=(const sys_time<_Duration>& __x,
+		  const leap_second& __y) noexcept
+	{ return !(__y.date() < __x); }
+
+      template<typename _Duration>
+	friend constexpr bool
+	operator>=(const leap_second& __x,
+		  const sys_time<_Duration>& __y) noexcept
+	{ return !(__x.date() < __y); }
+
+      template<typename _Duration>
+	friend constexpr bool
+	operator>=(const sys_time<_Duration>& __x,
+		  const leap_second& __y) noexcept
+	{ return !(__x < __y.date()); }
+
+      template<three_way_comparable_with<seconds> _Duration>
+	friend constexpr auto
+	operator<=>(const leap_second& __x,
+		   const sys_time<_Duration>& __y) noexcept
+	{ return __x.date() <=> __y; }
+
+    private:
+      explicit leap_second(seconds::rep __s) : _M_s(__s) { }
+
+      friend const tzdb& reload_tzdb();
+      template<typename _Dur>
+	friend leap_second_info
+	get_leap_second_info(const utc_time<_Dur>&);
+
+      seconds _M_s; // == date().time_since_epoch() * value().count()
+    };
+
+    template<class _Tp> struct zoned_traits { };
+
+    template<>
+      struct zoned_traits<const time_zone*>
+      {
+	static const time_zone*
+	default_zone()
+	{ return std::chrono::locate_zone("UTC"); }
+
+	static const time_zone*
+	locate_zone(string_view __name)
+	{ return std::chrono::locate_zone(__name); }
+      };
+
+    struct tzdb
+    {
+      string version;
+      vector<time_zone> zones;
+      vector<time_zone_link> links;
+      vector<leap_second> leap_seconds;
+
+      const time_zone*
+      locate_zone(string_view __tz_name) const;
+
+      const time_zone*
+      current_zone() const;
+
+    private:
+      friend const tzdb& reload_tzdb();
+
+      struct _Rule;
+      vector<_Rule> _M_rules;
+    };
+
+    class tzdb_list
+    {
+      struct _Node;
+    public:
+      tzdb_list(const tzdb_list&) = delete;
+      tzdb_list& operator=(const tzdb_list&) = delete;
+
+      class const_iterator
+      {
+      public:
+	using value_type        = tzdb;
+	using reference         = const tzdb&;
+	using pointer           = const tzdb*;
+	using difference_type   = ptrdiff_t;
+	using iterator_category = forward_iterator_tag;
+
+	constexpr const_iterator() = default;
+	const_iterator(const const_iterator&) = default;
+	const_iterator(const_iterator&&) = default;
+	const_iterator& operator=(const const_iterator&) = default;
+	const_iterator& operator=(const_iterator&&) = default;
+
+	reference operator*() const noexcept;
+	pointer operator->() const noexcept { return &**this; }
+	const_iterator& operator++();
+	const_iterator operator++(int);
+
+	bool operator==(const const_iterator&) const noexcept = default;
+
+      private:
+	explicit const_iterator(const shared_ptr<_Node>&) noexcept;
+
+	shared_ptr<_Node> _M_node;
+	void* _M_reserved = nullptr;
+      };
+
+      // TODO const tzdb& front() const noexcept;
+
+      const_iterator erase_after(const_iterator);
+
+      const_iterator begin() const noexcept;
+      const_iterator end() const noexcept { return {}; }
+      const_iterator cbegin() const noexcept { return begin(); }
+      const_iterator cend() const noexcept { return end(); }
+
+    private:
+      constexpr explicit tzdb_list(nullptr_t);
+
+      friend const tzdb_list& get_tzdb_list();
+      friend const tzdb& get_tzdb();
+      friend const tzdb& reload_tzdb();
+
+      static _Node* _S_head;
+      static shared_ptr<_Node> _S_head_owner;
+    };
+
+    // TODO
+    // const tzdb_list& get_tzdb_list();
+    // const tzdb& get_tzdb();
+
+    // const tzdb& reload_tzdb();
+    // string remove_version();
+
+    template<typename _Duration, typename _TimeZonePtr = const time_zone*>
+      class zoned_time; // TODO
+
+    using zoned_seconds = zoned_time<seconds>;
+
+    template<typename _Duration>
+      leap_second_info
+      get_leap_second_info(const utc_time<_Duration>& __ut)
+      {
+	if constexpr (is_same_v<_Duration, seconds>)
+	  {
+	    // TODO move this function into the library and get leaps from tzdb.
+	    vector<seconds::rep> __leaps
+	    {
+		78796800, // 1 Jul 1972
+		94694400, // 1 Jan 1973
+	       126230400, // 1 Jan 1974
+	       157766400, // 1 Jan 1975
+	       189302400, // 1 Jan 1976
+	       220924800, // 1 Jan 1977
+	       252460800, // 1 Jan 1978
+	       283996800, // 1 Jan 1979
+	       315532800, // 1 Jan 1980
+	       362793600, // 1 Jul 1981
+	       394329600, // 1 Jul 1982
+	       425865600, // 1 Jul 1983
+	       489024000, // 1 Jul 1985
+	       567993600, // 1 Jan 1988
+	       631152000, // 1 Jan 1990
+	       662688000, // 1 Jan 1991
+	       709948800, // 1 Jul 1992
+	       741484800, // 1 Jul 1993
+	       773020800, // 1 Jul 1994
+	       820454400, // 1 Jan 1996
+	       867715200, // 1 Jul 1997
+	       915148800, // 1 Jan 1999
+	      1136073600, // 1 Jan 2006
+	      1230768000, // 1 Jan 2009
+	      1341100800, // 1 Jul 2012
+	      1435708800, // 1 Jul 2015
+	      1483228800, // 1 Jan 2017
+	    };
+
+	    auto __s = __ut.time_since_epoch().count();
+	    auto __pos = std::upper_bound(__leaps.begin(), __leaps.end(), __s);
+	    return {
+	      __pos != __leaps.begin() && __pos[-1] == __s,
+	      seconds{__pos - __leaps.begin()}
+	    };
+	  }
+	else
+	  {
+	    auto __s = chrono::time_point_cast<seconds>(__ut);
+	    return chrono::get_leap_second_info(__s);
+	  }
+      }
+
     /// @} group chrono
 #endif // C++20
   } // namespace chrono
diff --git a/libstdc++-v3/testsuite/std/time/clock/gps/1.cc b/libstdc++-v3/testsuite/std/time/clock/gps/1.cc
new file mode 100644
index 0000000..9403ee1
--- /dev/null
+++ b/libstdc++-v3/testsuite/std/time/clock/gps/1.cc
@@ -0,0 +1,38 @@
+// { dg-options "-std=gnu++20" }
+// { dg-do run { target c++20 } }
+
+#include <chrono>
+#include <testsuite_hooks.h>
+
+void
+test01()
+{
+  using namespace std::chrono;
+
+  gps_seconds gps_epoch{0s};
+  utc_seconds gps_as_utc{sys_days{1980y/January/Sunday[1]}.time_since_epoch() + 9s};
+
+  VERIFY( clock_cast<utc_clock>(gps_epoch) == gps_as_utc );
+  VERIFY( gps_epoch == clock_cast<gps_clock>(gps_as_utc) );
+
+  tai_seconds tai_epoch{0s};
+  VERIFY( clock_cast<tai_clock>(clock_cast<gps_clock>(tai_epoch)) == tai_epoch );
+}
+
+void
+test02()
+{
+  using namespace std::chrono;
+
+  sys_days d{2022y/November/12};
+  VERIFY( clock_cast<system_clock>(clock_cast<gps_clock>(d)) == d );
+  gps_seconds t(1234567s);
+  VERIFY( clock_cast<gps_clock>(clock_cast<system_clock>(t)) == t );
+  VERIFY( clock_cast<gps_clock>(clock_cast<utc_clock>(t)) == t );
+}
+
+int main()
+{
+  test01();
+  test02();
+}
diff --git a/libstdc++-v3/testsuite/std/time/clock/tai/1.cc b/libstdc++-v3/testsuite/std/time/clock/tai/1.cc
new file mode 100644
index 0000000..9b36f02
--- /dev/null
+++ b/libstdc++-v3/testsuite/std/time/clock/tai/1.cc
@@ -0,0 +1,41 @@
+// { dg-options "-std=gnu++20" }
+// { dg-do run { target c++20 } }
+
+#include <chrono>
+#include <testsuite_hooks.h>
+
+void
+test01()
+{
+  using namespace std::chrono;
+
+  tai_seconds tai_epoch{0s};
+  utc_seconds tai_as_utc{sys_days{1958y/January/1}.time_since_epoch() - 10s};
+
+  VERIFY( clock_cast<utc_clock>(tai_epoch) == tai_as_utc );
+  VERIFY( tai_epoch == clock_cast<tai_clock>(tai_as_utc) );
+
+  sys_days y2k{2000y/January/1};
+  tai_seconds y2k_as_tai{clock_cast<tai_clock>(y2k)};
+  utc_seconds y2k_as_utc = utc_clock::from_sys(y2k);
+  VERIFY( clock_cast<utc_clock>(y2k_as_tai) == y2k_as_utc );
+  VERIFY( y2k_as_tai == clock_cast<tai_clock>(y2k_as_utc) );
+}
+
+void
+test02()
+{
+  using namespace std::chrono;
+
+  sys_days d{2022y/November/12};
+  VERIFY( clock_cast<system_clock>(clock_cast<tai_clock>(d)) == d );
+  tai_seconds t(1234567s);
+  VERIFY( clock_cast<tai_clock>(clock_cast<system_clock>(t)) == t );
+  VERIFY( clock_cast<tai_clock>(clock_cast<utc_clock>(t)) == t );
+}
+
+int main()
+{
+  test01();
+  test02();
+}
diff --git a/libstdc++-v3/testsuite/std/time/clock/utc/1.cc b/libstdc++-v3/testsuite/std/time/clock/utc/1.cc
new file mode 100644
index 0000000..eef5f3c
--- /dev/null
+++ b/libstdc++-v3/testsuite/std/time/clock/utc/1.cc
@@ -0,0 +1,24 @@
+// { dg-options "-std=gnu++20" }
+// { dg-do run { target c++20 } }
+
+#include <chrono>
+#include <testsuite_hooks.h>
+
+void
+test01()
+{
+  using namespace std::chrono;
+
+  auto epoch = sys_seconds{sys_days{1970y/January/1}};
+  auto utc_epoch = clock_cast<utc_clock>(epoch);
+  VERIFY( utc_epoch.time_since_epoch() == 0s );
+
+  auto y2k = sys_seconds{sys_days{2000y/January/1}};
+  auto utc_y2k = clock_cast<utc_clock>(y2k);
+  VERIFY( utc_y2k.time_since_epoch() == 946'684'822s );
+}
+
+int main()
+{
+  test01();
+}