libstdc++: Implement C++20 time zone support in <chrono>

This is the largest missing piece of C++20 support. Only the cxx11 ABI
is supported, due to the use of std::string in the API for time zones.
For the old gcc4 ABI, utc_clock and leap seconds are supported, but only
using a hardcoded list of leap seconds, no up-to-date tzdb::leap_seconds
information is available, and no time zones or zoned_time conversions.

The implementation currently depends on a tzdata.zi file being provided
by the OS or the user. The expected location is /usr/share/zoneinfo but
that can be changed using --with-libstdcxx-zoneinfo-dir=PATH. On targets
that support it there is also a weak symbol that users can override in
their own program (which also helps with testing):

extern "C++" const char* __gnu_cxx::zoneinfo_dir_override();

If no file is found, a fallback tzdb object will be created which only
contains the "Etc/UTC" and "Etc/GMT" time zones.

A leapseconds file is also expected in the same directory, but if that
isn't present then a hardcoded list of leapseconds is used, which is
correct at least as far as 2023-06-28 (and it currently looks like no
leap second will be inserted for a few years).

The tzdata.zi and leapseconds files from https://www.iana.org/time-zones
are in the public domain, so shipping copies of them with GCC would be
an option. However, the tzdata.zi file will rapidly become outdated, so
users should really provide it themselves (or convince their OS vendor
to do so). It would also be possible to implement an alternative parser
for the compiled tzdata files (one per time zone) under
/usr/share/zoneinfo. Those files are present on more operating systems,
but do not contain all the information present in tzdata.zi.
Specifically, the "links" are not present, so that e.g. "UTC" and
"Universal" are distinct time zones, rather than both being links to the
canonical "Etc/UTC" zone. For some platforms those files are hard links
to the same file, but there's no indication which zone is the canonical
name and which is a link. Other platforms just store them in different
inodes anyway. I do not plan to add such an alternative parser for the
compiled files. That would need to be contributed by maintainers or
users of targets that require it, if making tzdata.zi available is not
an option. The library ABI would not need to change for a new tzdb
implementation, because everything in tzdb_list, tzdb and time_zone is
implemented as a pimpl (except for the shared_ptr links between nodes,
described below). That means the new exported symbols added by this
commit should be stable even if the implementation is completely
rewritten.

The information from tzdata.zi is parsed and stored in data structures
that closely model the info in the file. This is a space-efficient
representation that uses less memory that storing every transition for
every time zone.  It also avoids spending time expanding that
information into time zone transitions that might never be needed by the
program.  When a conversion to/from a local time to UTC is requested the
information will be processed to determine the time zone transitions
close to the time being converted.

There is a bug in some time zone transitions. When generating a sys_info
object immediately after one that was previously generated, we need to
find the previous rule that was in effect and note its offset and
letters. This is so that the start time and abbreviation of the new
sys_info will be correct. This only affects time zones that use a format
like "C%sT" where the LETTERS replacing %s are non-empty for standard
time, e.g. "Asia/Shanghai" which uses "CST" for standard time and "CDT"
for daylight time.

The tzdb_list structure maintains a linked list of tzdb nodes using
shared_ptr links. This allows the iterators into the list to share
ownership with the list itself. This offers a non-portable solution to a
lifetime issue in the API. Because tzdb objects can be erased from the
list using tzdb_list::erase_after, separate modules/libraries in a large
program cannot guarantee that any const tzdb& or const time_zone*
remains valid indefinitely. Holding onto a tzdb_list::const_iterator
will extend the tzdb object's lifetime, even if it's erased from the
list. An alternative design would be for the list iterator to hold a
weak_ptr. This would allow users to test whether the tzdb still exists
when the iterator is dereferenced, which is better than just having a
dangling raw pointer. That doesn't actually extend the tzdb's lifetime
though, and every use of it would need to be preceded by checking the
weak_ptr. Using shared_ptr adds a little bit of overhead but allows
users to solve the lifetime issue if they rely on the libstdc++-specific
iterator property.

libstdc++-v3/ChangeLog:

	* acinclude.m4 (GLIBCXX_ZONEINFO_DIR): New macro.
	* config.h.in: Regenerate.
	* config/abi/pre/gnu.ver: Export new symbols.
	* configure: Regenerate.
	* configure.ac (GLIBCXX_ZONEINFO_DIR): Use new macro.
	* include/std/chrono (utc_clock::from_sys): Correct handling
	of leap seconds.
	(nonexistent_local_time::_M_make_what_str): Define.
	(ambiguous_local_time::_M_make_what_str): Define.
	(__throw_bad_local_time): Define new function.
	(time_zone, tzdb_list, tzdb): Implement all members.
	(remote_version, zoned_time, get_leap_second_info): Define.
	* include/std/version: Add comment for __cpp_lib_chrono.
	* src/c++20/Makefile.am: Add new file.
	* src/c++20/Makefile.in: Regenerate.
	* src/c++20/tzdb.cc: New file.
	* testsuite/lib/libstdc++.exp: Define effective target tzdb.
	* testsuite/std/time/clock/file/members.cc: Check file_time
	alias and file_clock::now() member.
	* testsuite/std/time/clock/gps/1.cc: Likewise for gps_clock.
	* testsuite/std/time/clock/tai/1.cc: Likewise for tai_clock.
	* testsuite/std/time/syn_c++20.cc: Uncomment everything except
	parse.
	* testsuite/std/time/clock/utc/leap_second_info.cc: New test.
	* testsuite/std/time/exceptions.cc: New test.
	* testsuite/std/time/time_zone/get_info_local.cc: New test.
	* testsuite/std/time/time_zone/get_info_sys.cc: New test.
	* testsuite/std/time/time_zone/requirements.cc: New test.
	* testsuite/std/time/tzdb/1.cc: New test.
	* testsuite/std/time/tzdb/leap_seconds.cc: New test.
	* testsuite/std/time/tzdb_list/1.cc: New test.
	* testsuite/std/time/tzdb_list/requirements.cc: New test.
	* testsuite/std/time/zoned_time/1.cc: New test.
	* testsuite/std/time/zoned_time/custom.cc: New test.
	* testsuite/std/time/zoned_time/deduction.cc: New test.
	* testsuite/std/time/zoned_time/req_neg.cc: New test.
	* testsuite/std/time/zoned_time/requirements.cc: New test.
	* testsuite/std/time/zoned_traits.cc: New test.

2 files changed, 551 insertions, 147 deletions

diff --git a/libstdc++-v3/include/std/chrono b/libstdc++-v3/include/std/chrono
index 33653f8..aeb8f6f 100644
--- a/libstdc++-v3/include/std/chrono
+++ b/libstdc++-v3/include/std/chrono
@@ -46,11 +46,17 @@
 # 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/stl_algo.h> // upper_bound
 # include <bits/shared_ptr.h>
 # include <bits/unique_ptr.h>
 #endif
 
+#if __cplusplus >= 202002L
+// TODO formatting and parsing
+// # undef __cpp_lib_chrono
+// # define __cpp_lib_chrono 201907L
+#endif
+
 namespace std _GLIBCXX_VISIBILITY(default)
 {
 _GLIBCXX_BEGIN_NAMESPACE_VERSION
@@ -140,7 +146,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	{
 	  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}};
+	  sys_time<_CDur> __s{__t.time_since_epoch() - __li.elapsed};
 	  if (__li.is_leap_second)
 	    __s = chrono::floor<seconds>(__s) + seconds{1} - _CDur{1};
 	  return __s;
@@ -149,13 +155,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       template<typename _Duration>
 	[[nodiscard]]
 	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};
-	}
+	from_sys(const sys_time<_Duration>& __t);
     };
 
     /** A clock that measures International Atomic Time.
@@ -2056,7 +2056,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 		    - chrono::weekday{sys_days{_M_y / _M_m / 1}}
 		    + days((_M_wdi.index()-1)*7 + 1));
 	__glibcxx_assert(__d.count() >= 1);
-	return __d.count() <= unsigned{(_M_y / _M_m / last).day()};
+	return (unsigned)__d.count() <= (unsigned)(_M_y / _M_m / last).day();
       }
 
       friend constexpr bool
@@ -2500,8 +2500,11 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	}
     }
 
+#if _GLIBCXX_USE_CXX11_ABI || ! _GLIBCXX_USE_DUAL_ABI
     // C++20 [time.zones] Time zones
 
+    struct tzdb;
+
     struct sys_info
     {
       sys_seconds begin;
@@ -2532,9 +2535,25 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	{ __glibcxx_assert(__i.result == local_info::nonexistent); }
 
     private:
-      template<typename _Duration> // TODO
+      template<typename _Duration>
 	static string
-	_S_make_what_str(const local_time<_Duration>&, const local_info&);
+	_S_make_what_str(const local_time<_Duration>& __tp,
+			 const local_info& __i)
+	{
+#if 1
+	  return "local time is non-existent";
+#else
+	  std::ostringstream __os;
+	  __os << __tp << " is in a gap between\n"
+	       << local_seconds(__i.first.end.time_since_epoch())
+	       + __i.first.offset << ' ' << __i.first.abbrev << " and\n"
+	       << local_seconds(__i.second.begin.time_since_epoch())
+	       + __i.second.offset << ' ' << __i.second.abbrev
+	       << " which are both equivalent to\n"
+	       << __i.first.end << " UTC";
+	  return std::move(__os).str();
+#endif
+	}
     };
 
     class ambiguous_local_time : public runtime_error
@@ -2542,16 +2561,44 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     public:
       template<typename _Duration>
 	ambiguous_local_time(const local_time<_Duration>& __tp,
-			       const local_info& __i)
+			     const local_info& __i)
 	: runtime_error(_S_make_what_str(__tp, __i))
-	{ __glibcxx_assert(__i.result == local_info::nonexistent); }
+	{ __glibcxx_assert(__i.result == local_info::ambiguous); }
 
     private:
-      template<typename _Duration> // TODO
+      template<typename _Duration>
 	static string
-	_S_make_what_str(const local_time<_Duration>&, const local_info&);
+	_S_make_what_str(const local_time<_Duration>& __tp,
+			 const local_info& __i)
+	{
+#if 1
+	  return "local time is ambiguous";
+#else
+	  std::ostringstream __os;
+	  __os << __tp << " is ambiguous.  It could be\n"
+	       << __tp << ' ' << __i.first.abbrev << " == "
+	       << __tp - __i.first.offset << " UTC or\n"
+	       << __tp << ' ' << __i.second.abbrev << " == "
+	       << __tp - __i.second.offset << " UTC";
+	  return std::move(__os).str();
+#endif
+	}
     };
 
+    template<typename _Duration>
+      [[noreturn]] void
+      __throw_bad_local_time(const local_time<_Duration>& __tp,
+			     const local_info& __i)
+      {
+#if __cpp_exceptions
+	if (__i.result == local_info::nonexistent)
+	  throw nonexistent_local_time(__tp, __i);
+	throw ambiguous_local_time(__tp, __i);
+#else
+	__builtin_abort();
+#endif
+      }
+
     enum class choose { earliest, latest };
 
     class time_zone
@@ -2560,46 +2607,188 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       time_zone(time_zone&&) = default;
       time_zone& operator=(time_zone&&) = default;
 
+      ~time_zone();
+
+      [[nodiscard]]
       string_view name() const noexcept { return _M_name; }
 
       template<typename _Duration>
 	sys_info
-	get_info(const sys_time<_Duration>& __st) const;
+	get_info(const sys_time<_Duration>& __st) const
+	{ return _M_get_sys_info(chrono::floor<seconds>(__st)); }
 
       template<typename _Duration>
 	local_info
-	get_info(const local_time<_Duration>& __tp) const;
+	get_info(const local_time<_Duration>& __tp) const
+	{ return _M_get_local_info(chrono::floor<seconds>(__tp)); }
 
       template<typename _Duration>
 	sys_time<common_type_t<_Duration, seconds>>
-	to_sys(const local_time<_Duration>& __tp) const;
+	to_sys(const local_time<_Duration>& __tp) const
+	{
+	  local_info __info = get_info(__tp);
+
+	  if (__info.result != local_info::unique)
+	    __throw_bad_local_time(__tp, __info);
+
+	  return sys_time<_Duration>(__tp.time_since_epoch())
+		   - __info.first.offset;
+	}
 
       template<typename _Duration>
 	sys_time<common_type_t<_Duration, seconds>>
-	to_sys(const local_time<_Duration>& __tp, choose __z) const;
+	to_sys(const local_time<_Duration>& __tp, choose __z) const
+	{
+	  local_info __info = get_info(__tp);
+
+	  if (__info.result == local_info::nonexistent)
+	    return __info.first.end; // Last second of the previous sys_info.
+
+	  sys_time<_Duration> __st(__tp.time_since_epoch());
+
+	  if (__info.result == local_info::ambiguous && __z == choose::latest)
+	    return __st - __info.second.offset; // Time in the later sys_info.
+	  // else if __z == earliest, use __info.first.offset as below:
+
+	  return __st - __info.first.offset;
+	}
 
       template<typename _Duration>
 	local_time<common_type_t<_Duration, seconds>>
-	to_local(const sys_time<_Duration>& __tp) const;
+	to_local(const sys_time<_Duration>& __tp) const
+	{
+	  auto __d = (__tp + get_info(__tp).offset).time_since_epoch();
+	  return local_time<common_type_t<_Duration, seconds>>(__d);
+	}
 
-      friend bool
+      [[nodiscard]] friend bool
       operator==(const time_zone& __x, const time_zone& __y) noexcept
-      { return __x.name() == __y.name(); }
+      { return __x._M_name == __y._M_name; }
 
-      friend strong_ordering
+      [[nodiscard]] friend strong_ordering
       operator<=>(const time_zone& __x, const time_zone& __y) noexcept
-      { return __x.name() <=> __y.name(); }
+      { return __x._M_name <=> __y._M_name; }
 
     private:
-      string _M_name;
+      sys_info _M_get_sys_info(sys_seconds) const;
+      local_info _M_get_local_info(local_seconds) const;
+
+      friend const tzdb& reload_tzdb();
+      friend struct tzdb;
+      friend class tzdb_list;
+
       struct _Impl;
+
+      explicit time_zone(unique_ptr<_Impl> __p);
+      string _M_name;
       unique_ptr<_Impl> _M_impl;
     };
 
-    struct tzdb;
     const time_zone* locate_zone(string_view __tz_name);
     const time_zone* current_zone();
 
+    /** The list of `chrono::tzdb` objects
+     *
+     * A single object of this type is constructed by the C++ runtime,
+     * and can be accessed by calling `chrono::get_tzdb_list()`.
+     *
+     * The front of the list is the current `tzdb` object and can be accessed
+     * via `chrono::get_tzdb_list().front()` or `chrono::get_tzdb()` or
+     * `*chrono::get_tzdb_list().begin()`.
+     *
+     * The `chrono::reload_tzdb()` function will check for a newer version
+     * and if found, insert it at the front of the list.
+     *
+     * @since C++20
+     */
+    class tzdb_list
+    {
+      struct _Node;
+
+    public:
+      tzdb_list(const tzdb_list&) = delete;
+      tzdb_list& operator=(const tzdb_list&) = delete;
+
+      /** An iterator into the `tzdb_list`
+       *
+       * As a extension, in libstdc++ each `tzdb` is reference-counted
+       * and the `const_iterator` type shares ownership of the object it
+       * refers to. This ensures that a `tzdb` erased from the list will
+       * not be destroyed while there is an iterator that refers to it.
+       */
+      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;
+
+	friend class tzdb_list;
+
+	shared_ptr<_Node> _M_node;
+	void* _M_reserved = nullptr;
+      };
+
+      /** Access the current `tzdb` at the front of the list.
+       *
+       * This returns a reference to the same object as `chrono::get_tzdb()`.
+       *
+       * @returns A reference to the current tzdb object.
+       * @since C++20
+       */
+      const tzdb& front() const noexcept;
+
+      /** Remove the tzdb object _after_ the one the iterator refers to.
+       *
+       * Calling this function concurently with any of `front()`, `begin()`,
+       * or `end()` does not cause a data race, but in general this function
+       * is not thread-safe. The behaviour may be undefined if erasing an
+       * element from the list while another thread is calling the same
+       * function, or incrementing an iterator into the list, or accessing
+       * the element being erased (unless it is accessed through an iterator).
+       *
+       * @param __p A dereferenceable iterator.
+       * @returns An iterator the element after the one that was erased
+       *          (or `end()` if there is no such element).
+       * @since C++20
+       */
+      const_iterator erase_after(const_iterator __p);
+
+      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 tzdb_list& get_tzdb_list();
+      friend const tzdb& get_tzdb();
+      friend const tzdb& reload_tzdb();
+      friend struct tzdb;
+      friend class leap_second;
+      friend struct time_zone::_Impl;
+      friend class time_zone_link;
+    };
+
     class time_zone_link
     {
     public:
@@ -2619,7 +2808,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 
     private:
       friend const tzdb& reload_tzdb();
-      // TODO unspecified additional constructors
+      friend class tzdb_list::_Node;
+
+      explicit time_zone_link(nullptr_t) { }
+
       string _M_name;
       string _M_target;
     };
@@ -2720,10 +2912,13 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     private:
       explicit leap_second(seconds::rep __s) : _M_s(__s) { }
 
+      friend class tzdb_list::_Node;
+
       friend const tzdb& reload_tzdb();
-      template<typename _Dur>
+
+      template<typename _Duration>
 	friend leap_second_info
-	get_leap_second_info(const utc_time<_Dur>&);
+	get_leap_second_info(const utc_time<_Duration>&);
 
       seconds _M_s; // == date().time_since_epoch() * value().count()
     };
@@ -2745,9 +2940,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     struct tzdb
     {
       string version;
-      vector<time_zone> zones;
-      vector<time_zone_link> links;
-      vector<leap_second> leap_seconds;
+      _GLIBCXX_STD_C::vector<time_zone> zones;
+      _GLIBCXX_STD_C::vector<time_zone_link> links;
+      _GLIBCXX_STD_C::vector<leap_second> leap_seconds;
 
       const time_zone*
       locate_zone(string_view __tz_name) const;
@@ -2757,146 +2952,353 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 
     private:
       friend const tzdb& reload_tzdb();
-
-      struct _Rule;
-      vector<_Rule> _M_rules;
+      friend class time_zone;
+      friend class tzdb_list::_Node;
     };
 
-    class tzdb_list
-    {
-      struct _Node;
-    public:
-      tzdb_list(const tzdb_list&) = delete;
-      tzdb_list& operator=(const tzdb_list&) = delete;
+    tzdb_list& get_tzdb_list();
+    const tzdb& get_tzdb();
 
-      class const_iterator
+    const tzdb& reload_tzdb();
+    string remote_version();
+
+    template<typename _Duration, typename _TimeZonePtr = const time_zone*>
+      class zoned_time
       {
+	static_assert(__is_duration_v<_Duration>);
+
+	using _Traits = zoned_traits<_TimeZonePtr>;
+
+	// Every constructor that accepts a string_view as its first parameter
+	// does not participate in class template argument deduction.
+	using string_view = type_identity_t<std::string_view>;
+
       public:
-	using value_type        = tzdb;
-	using reference         = const tzdb&;
-	using pointer           = const tzdb*;
-	using difference_type   = ptrdiff_t;
-	using iterator_category = forward_iterator_tag;
+	using duration = common_type_t<_Duration, seconds>;
 
-	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;
+	zoned_time() requires requires { _Traits::default_zone(); }
+	{ }
 
-	reference operator*() const noexcept;
-	pointer operator->() const noexcept { return &**this; }
-	const_iterator& operator++();
-	const_iterator operator++(int);
+	zoned_time(const zoned_time&) = default;
+	zoned_time& operator=(const zoned_time&) = default;
 
-	bool operator==(const const_iterator&) const noexcept = default;
+	zoned_time(const sys_time<_Duration>& __st)
+	  requires requires { _Traits::default_zone(); }
+	: _M_tp(__st)
+	{ }
 
-      private:
-	explicit const_iterator(const shared_ptr<_Node>&) noexcept;
+	explicit
+	zoned_time(_TimeZonePtr __z) : _M_zone(std::move(__z)) { }
 
-	shared_ptr<_Node> _M_node;
-	void* _M_reserved = nullptr;
-      };
+	explicit
+	zoned_time(string_view __name)
+	  requires requires {
+	    _TimeZonePtr{_Traits::locate_zone(std::string_view{})};
+	  }
+	: _M_zone(_Traits::locate_zone(__name))
+	{ }
 
-      // TODO const tzdb& front() const noexcept;
+	template<typename _Duration2>
+	  zoned_time(const zoned_time<_Duration2, _TimeZonePtr>& __zt)
+	  requires is_convertible_v<sys_time<_Duration2>, sys_time<_Duration>>
+	  : _M_zone(__zt._M_zone), _M_tp(__zt._M_tp)
+	  { }
 
-      const_iterator erase_after(const_iterator);
+	zoned_time(_TimeZonePtr __z, const sys_time<_Duration>& __st)
+	: _M_zone(std::move(__z)), _M_tp(__st)
+	{ }
 
-      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(); }
+	zoned_time(string_view __name, const sys_time<_Duration>& __st)
+	: zoned_time(_Traits::locate_zone(__name), __st)
+	{ }
 
-    private:
-      constexpr explicit tzdb_list(nullptr_t);
+	zoned_time(_TimeZonePtr __z, const local_time<_Duration>& __tp)
+	requires requires {
+	  { __z->to_sys(__tp) } -> convertible_to<sys_time<_Duration>>;
+	}
+	: _M_zone(std::move(__z)), _M_tp(_M_zone->to_sys(__tp))
+	{ }
 
-      friend const tzdb_list& get_tzdb_list();
-      friend const tzdb& get_tzdb();
-      friend const tzdb& reload_tzdb();
+	zoned_time(string_view __name, const local_time<_Duration>& __tp)
+	requires requires (_TimeZonePtr __z) {
+	  { _Traits::locate_zone(__name) } -> convertible_to<_TimeZonePtr>;
+	  { __z->to_sys(__tp) } -> convertible_to<sys_time<_Duration>>;
+	}
+	: zoned_time(_Traits::locate_zone(__name), __tp)
+	{ }
 
-      static _Node* _S_head;
-      static shared_ptr<_Node> _S_head_owner;
-    };
+	zoned_time(_TimeZonePtr __z, const local_time<_Duration>& __tp,
+		   choose __c)
+	requires requires {
+	  { __z->to_sys(__tp, __c) } -> convertible_to<sys_time<_Duration>>;
+	}
+	: _M_zone(std::move(__z)), _M_tp(_M_zone->to_sys(__tp, __c))
+	{ }
 
-    // TODO
-    // const tzdb_list& get_tzdb_list();
-    // const tzdb& get_tzdb();
+	zoned_time(string_view __name, const local_time<_Duration>& __tp,
+		   choose __c)
+	requires requires (_TimeZonePtr __z) {
+	  { _Traits::locate_zone(__name) } -> convertible_to<_TimeZonePtr>;
+	  { __z->to_sys(__tp, __c) } -> convertible_to<sys_time<_Duration>>;
+	}
+	: _M_zone(_Traits::locate_zone(__name)),
+	  _M_tp(_M_zone->to_sys(__tp, __c))
+	{ }
 
-    // const tzdb& reload_tzdb();
-    // string remove_version();
+	template<typename _Duration2, typename _TimeZonePtr2>
+	  zoned_time(_TimeZonePtr __z,
+		     const zoned_time<_Duration2, _TimeZonePtr2>& __zt)
+	  requires is_convertible_v<sys_time<_Duration2>, sys_time<_Duration>>
+	  : _M_zone(__z), _M_tp(__zt._M_tp)
+	  { }
+
+	template<typename _Duration2, typename _TimeZonePtr2>
+	  zoned_time(_TimeZonePtr __z,
+		     const zoned_time<_Duration2, _TimeZonePtr2>& __zt,
+		     choose __c)
+	  requires is_convertible_v<sys_time<_Duration2>, sys_time<_Duration>>
+	  : _M_zone(__z), _M_tp(__zt._M_tp)
+	  { }
+
+	template<typename _Duration2, typename _TimeZonePtr2>
+	  zoned_time(string_view __name,
+		     const zoned_time<_Duration2, _TimeZonePtr2>& __zt)
+	  requires is_convertible_v<sys_time<_Duration2>, sys_time<_Duration>>
+	  && requires {
+	    { _Traits::locate_zone(__name) } -> convertible_to<_TimeZonePtr>;
+	  }
+	  : _M_zone(_Traits::locate_zone(__name)), _M_tp(__zt._M_tp)
+	  { }
+
+	template<typename _Duration2, typename _TimeZonePtr2>
+	  zoned_time(string_view __name,
+		     const zoned_time<_Duration2, _TimeZonePtr2>& __zt,
+		     choose __c)
+	  requires is_convertible_v<sys_time<_Duration2>, sys_time<_Duration>>
+	  && requires {
+	    { _Traits::locate_zone(__name) } -> convertible_to<_TimeZonePtr>;
+	  }
+	  : _M_zone(_Traits::locate_zone(__name)), _M_tp(__zt._M_tp)
+	  { }
 
-    template<typename _Duration, typename _TimeZonePtr = const time_zone*>
-      class zoned_time; // TODO
+	zoned_time&
+	operator=(const sys_time<_Duration>& __st)
+	{
+	  _M_tp = __st;
+	  return *this;
+	}
+
+	zoned_time&
+	operator=(const local_time<_Duration>& __lt)
+	{
+	  _M_tp = _M_zone->to_sys(__lt);
+	  return *this;
+	}
+
+	[[nodiscard]]
+	operator sys_time<duration>() const { return _M_tp; }
+
+	[[nodiscard]]
+	explicit operator local_time<duration>() const
+	{ return get_local_time(); }
+
+	[[nodiscard]]
+	_TimeZonePtr
+	get_time_zone() const
+	{ return _M_zone; }
+
+	[[nodiscard]]
+	local_time<duration>
+	get_local_time() const
+	{ return _M_zone->to_local(_M_tp); }
+
+	[[nodiscard]]
+	sys_time<duration>
+	get_sys_time() const
+	{ return _M_tp; }
+
+	[[nodiscard]]
+	sys_info
+	get_info() const
+	{ return _M_zone->get_info(_M_tp); }
+
+	[[nodiscard]] friend bool
+	operator==(const zoned_time&, const zoned_time&) = default;
+
+      private:
+	_TimeZonePtr       _M_zone{ _Traits::default_zone() };
+	sys_time<duration> _M_tp{};
+
+	template<typename _Duration2, typename _TimeZonePtr2>
+	  friend class zoned_time;
+      };
+
+    zoned_time() -> zoned_time<seconds>;
+
+    template<typename _Duration>
+    zoned_time(sys_time<_Duration>)
+      -> zoned_time<common_type_t<_Duration, seconds>>;
+
+  /// @cond undocumented
+  template<typename _TimeZonePtrOrName>
+    using __time_zone_representation
+      = __conditional_t<is_convertible_v<_TimeZonePtrOrName, string_view>,
+			const time_zone*,
+			remove_cvref_t<_TimeZonePtrOrName>>;
+  /// @endcond
+
+  template<typename _TimeZonePtrOrName>
+    zoned_time(_TimeZonePtrOrName&&)
+      -> zoned_time<seconds, __time_zone_representation<_TimeZonePtrOrName>>;
+
+  template<typename _TimeZonePtrOrName, typename _Duration>
+    zoned_time(_TimeZonePtrOrName&&, sys_time<_Duration>)
+      -> zoned_time<common_type_t<_Duration, seconds>,
+                    __time_zone_representation<_TimeZonePtrOrName>>;
+
+  template<typename _TimeZonePtrOrName, typename _Duration>
+    zoned_time(_TimeZonePtrOrName&&, local_time<_Duration>,
+               choose = choose::earliest)
+      -> zoned_time<common_type_t<_Duration, seconds>,
+                    __time_zone_representation<_TimeZonePtrOrName>>;
+
+  template<typename _Duration, typename _TimeZonePtrOrName,
+	   typename _TimeZonePtr2>
+    zoned_time(_TimeZonePtrOrName&&, zoned_time<_Duration, _TimeZonePtr2>,
+               choose = choose::earliest)
+      -> zoned_time<common_type_t<_Duration, seconds>,
+                    __time_zone_representation<_TimeZonePtrOrName>>;
+
+  template<typename _Dur1, typename _TZPtr1, typename _Dur2, typename _TZPtr2>
+    [[nodiscard]]
+    inline bool
+    operator==(const zoned_time<_Dur1, _TZPtr1>& __x,
+	       const zoned_time<_Dur2, _TZPtr2>& __y)
+    {
+      return __x.get_time_zone() == __y.get_time_zone()
+	       && __x.get_sys_time() == __y.get_sys_time();
+    }
 
     using zoned_seconds = zoned_time<seconds>;
+#endif // _GLIBCXX_USE_CXX11_ABI || ! _GLIBCXX_USE_DUAL_ABI
+
+namespace __detail
+{
+    inline leap_second_info
+    __get_leap_second_info(sys_seconds __ss, bool __is_utc)
+    {
+      if (__ss < sys_seconds{}) [[unlikely]]
+	return {};
+
+      const 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
+      };
+      // The list above is known to be valid until (at least) this date
+      // and only contains positive leap seconds.
+      const sys_seconds __expires(1687910400s); // 2023-06-28 00:00:00 UTC
+
+#if _GLIBCXX_USE_CXX11_ABI || ! _GLIBCXX_USE_DUAL_ABI
+      if (__ss > __expires)
+	{
+	  // Use updated leap_seconds from tzdb.
+	  size_t __n = std::size(__leaps);
+
+	  auto __db = get_tzdb_list().begin();
+	  auto __first = __db->leap_seconds.begin() + __n;
+	  auto __last = __db->leap_seconds.end();
+	  auto __pos = std::upper_bound(__first, __last, __ss);
+	  seconds __elapsed(__n);
+	  for (auto __i = __first; __i != __pos; ++__i)
+	    __elapsed += __i->value();
+
+	  if (__is_utc)
+	    {
+	      // Convert utc_time to sys_time:
+	      __ss -= __elapsed;
+	      // See if that sys_time is before (or during) previous leap sec:
+	      if (__pos != __first && __ss < __pos[-1])
+		{
+		  if ((__ss + 1s) >= __pos[-1])
+		    return {true, __elapsed};
+		  __elapsed -= __pos[-1].value();
+		}
+	    }
+	  return {false, __elapsed};
+	}
+      else
+#endif
+	{
+	  seconds::rep __s = __ss.time_since_epoch().count();
+	  const seconds::rep* __first = std::begin(__leaps);
+	  const seconds::rep* __last = std::end(__leaps);
+
+	  // Don't bother searching the list if we're after the last one.
+	  if (__s > (__last[-1] + (__last - __first) + 1))
+	    return { false, seconds(__last - __first) };
+
+	  auto __pos = std::upper_bound(__first, __last, __s);
+	  seconds __elapsed{__pos - __first};
+	  if (__is_utc)
+	    {
+	      // Convert utc_time to sys_time:
+	      __s -= __elapsed.count();
+	      // See if that sys_time is before (or during) previous leap sec:
+	      if (__pos != __first && __s < __pos[-1])
+		{
+		  if ((__s + 1) >= __pos[-1])
+		    return {true, __elapsed};
+		  --__elapsed;
+		}
+	    }
+	  return {false, __elapsed};
+	}
+    }
+} // namespace __detail
 
     template<typename _Duration>
-      leap_second_info
+      [[nodiscard]]
+      inline leap_second_info
       get_leap_second_info(const utc_time<_Duration>& __ut)
       {
-	if constexpr (is_same_v<_Duration, seconds>)
-	  {
-	    const 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
-	    };
-	    // The list above is known to be valid until 2023-06-28 00:00:00 UTC
-	    const seconds::rep __expires = 1687910400;
-	    const seconds::rep __s = __ut.time_since_epoch().count();
-
-	    const seconds::rep* __first = std::begin(__leaps);
-	    const seconds::rep* __last = std::end(__leaps);
-
-	    if (__s > __expires)
-	      {
-		// TODO: use updated leap_seconds from tzdb
-#if 0
-		auto __db = get_tzdb_list().begin();
-		__first = __db->leap_seconds.data();
-		__last = __first + __db->leap_seconds.size();
-#endif
-	      }
-
-	    // Don't bother searching the list if we're after the last one.
-	    if (__s > __last[-1])
-	      return { false, seconds(__last - __first) };
+	auto __s = chrono::duration_cast<seconds>(__ut.time_since_epoch());
+	return __detail::__get_leap_second_info(sys_seconds(__s), true);
+      }
 
-	    auto __pos = std::upper_bound(__first, __last, __s);
-	    return {
-	      __pos != begin(__leaps) && __pos[-1] == __s,
-	      seconds{__pos - __first}
-	    };
-	  }
-	else
-	  {
-	    auto __s = chrono::time_point_cast<seconds>(__ut);
-	    return chrono::get_leap_second_info(__s);
-	  }
+    template<typename _Duration>
+      [[nodiscard]]
+      inline utc_time<common_type_t<_Duration, seconds>>
+      utc_clock::from_sys(const sys_time<_Duration>& __t)
+      {
+	using _CDur = common_type_t<_Duration, seconds>;
+	auto __s = chrono::time_point_cast<seconds>(__t);
+	const auto __li = __detail::__get_leap_second_info(__s, false);
+	return utc_time<_CDur>{__t.time_since_epoch()} + __li.elapsed;
       }
 
     /// @} group chrono
diff --git a/libstdc++-v3/include/std/version b/libstdc++-v3/include/std/version
index 576eebc..c1a9896 100644
--- a/libstdc++-v3/include/std/version
+++ b/libstdc++-v3/include/std/version
@@ -251,6 +251,8 @@
 #  define __cpp_lib_barrier 201907L
 # endif
 #endif
+// #undef __cpp_lib_chrono
+// #define __cpp_lib_chrono 201907L
 // FIXME: #define __cpp_lib_execution 201902L
 #define __cpp_lib_constexpr_algorithms 201806L
 #ifdef __cpp_lib_is_constant_evaluated