[libc++][chrono] Adds tzdb_list implementation.

[Mordante]

Summary

This is the first step to implement time zone support in libc++. This
adds the complete tzdb_list class and a minimal tzdb class. The tzdb
class only contains the version, which is used by reload_tzdb.

Next to these classes it contains documentation and build system support
needed for time zone support. The code depends on the IANA Time Zone
Database, which should be available on the platform used or provided by
the libc++ vendors.

The code is labeled as experimental since there will be ABI breaks
during development; the tzdb class needs to have the standard headers.

Implements parts of:

• P0355 Extending <chrono> to Calendars and Time Zones

Addresses:

• LWG3319 Properly reference specification of IANA time zone database

[Mordante]

libcxx/CMakeLists.txt

325

This patch needs to be added to the release notes. However since this is the start of a rather large feature it makes sense to post-pone landing this after LLVM-17 has branched. To avoid merge conflicts the release notes aren't updated yet.

[Mordante]

CI fixes.

[Mordante]

CI fixes.

[Mordante]

Test CI.

[Mordante]

CI fixes.

[Mordante]

CI fixes.

[Mordante]

Retrigger CI.

[Mordante]

Reenable full CI.

[Mordante]

libcxx/include/module.modulemap.in

322

Add @requires_LIBCXX_ENABLE_LOCALIZATION@ and filesystem here and next file.

libcxx/src/CMakeLists.txt

322

Review note.

This patch can avoid the dependency to the file system. However future patches will require the file system std::chrono::current_zone() on Unix-like systems needs to resolve the target of the symlink /etc/localtime which points to something like /usr/share/zoneinfo/Europe/Berlin. In this case Europe/Berlin is the name of the current time zone.

Localization could be avoided by using a C file I/O API. This might make sense when there are a lot of vendors with filesystem support, but without locale support.

[philnik]

libcxx/docs/Status/Cxx20.rst

52

Maybe a status page would be appropriate?

libcxx/docs/UsingLibcxx.rst

564–567

Why do you make this a static? The string literal already has static storage duration.

libcxx/include/__chrono/tzdb.h

20

Including headers shouldn't depend on -fexperimental-library. Same for #pragma GCC system_header.

libcxx/include/__config

401

Why isn't the macro simply defined in the #ifdef above?

libcxx/src/tz.cpp

43

Why don't you put this in an anonymous namespace instead? Also, these functions and arguments don't have to be _Uglified, since they are only in the sources. I would also move this into the global namespace to avoid confusion.

125–141

I would keep all the annotations exclusively in the headers. That makes this code much nicer to read.

[Mordante]

libcxx/docs/Status/Cxx20.rst

52

I think keeping the note would be better. I expect most of the missing parts done this cycle. The Stream output remark is permanent. That part of the paper will never be done.

libcxx/docs/UsingLibcxx.rst

564–567

I've added a comment to explain the requirement.

libcxx/include/__chrono/tzdb.h

20

This is how we have done this in the past for format too.

libcxx/src/tz.cpp

43

I prefer static over anonymous namespaces. We have other parts of the dylib uglified too. This makes it easier to move code to the header when possible.

125–141

I prefer to keep the declaration and definition the same.

[Mordante]

Rebased and addresses review comments.

[ldionne]

libcxx/CMakeLists.txt

325

I think we should remove the ability to set a custom path and always use the system defaults. We should work with the various platforms we support to make sure that they provide these resources, and if they don't then it would be reasonable for that part of functionality not to be supported at all.

332

However, we should add something like LIBCXX_ENABLE_TIME_ZONE_SUPPORT, which would act like LIBCXX_ENABLE_FILESYSTEM and others. I would expect e.g. embedded systems to turn that off, but it should be on by default.

libcxx/docs/BuildingLibcxx.rst

25

I don't think this documentation is required anymore if we assume platform support when LIBCXX_ENABLE_TIME_ZONE_SUPPORT=ON.

307

This goes too.

libcxx/docs/DesignDocs/TimeZone.rst

20

46–49

51–54

56–61

65–66

81

86

This will go away.

92

Point of discussion: do we really want to let users override this? Unless we have clear uses cases for that, I would recommend not exposing this to users at first. We can do something ad-hoc for our testing needs.

If we decide not to expose this to users, let's make it clear by not saying "this allows applications to specify their own database path [...]".

115

116–119

128–131

132–136

144–146

libcxx/docs/UsingLibcxx.rst

533

This should be updated.

591

596–597

[Mordante]

libcxx/docs/DesignDocs/TimeZone.rst

92

I'll remove the part of user specific applications.

[Mordante]

Addresses review comments.

[Mordante]

Rebased and CI fixes.

[ldionne]

libcxx/CMakeLists.txt

94

We could instead disable this by default except on Linux. This would avoid breaking the build for everyone on major platforms right now (which would happen if we switch to #error in the dylib).

libcxx/docs/Status/Cxx20.rst

54

libcxx/docs/UsingLibcxx.rst

530

I think we should document this in a separate page with implementation-defined behavior.

libcxx/include/__availability

179

356

libcxx/include/__chrono/tzdb_list.h

42

As part of this patch?

80

94–97

I think we should try to make it as clear as possible that this is not intended to be used by users.

Actually, we don't have to declare it here at all, we can only declare + override it in the test suite. We should add a comment explaining that this is necessary for testing in tz.cpp where that function is marked as _LIBCPP_WEAK.

libcxx/include/__config

1428–1435

Since we need to implement __libcpp_tzdb_directory in the dylib anyway, I think we should move this to tz.cpp to keep it as localized as possible.

libcxx/include/chrono

835

Is this missing _LIBCPP_HAS_NO_TIME_ZONE_DATABASE?

libcxx/src/tz.cpp

23

119

This should be a #error instead.

libcxx/test/libcxx/transitive_includes.gen.py

67

Also no-tzdb?

libcxx/utils/libcxx/test/features.py

571

This one would be removed if we turned tzdb support to OFF by default on platforms that don't support it.

[Mordante]

libcxx/include/__chrono/tzdb_list.h

42

Had a look and I was wondering whether we want to keep documenting our _LIBCPP_NODISCARD_EXT since the list is incomplete.

[Mordante]

Rebased and addresses review comments.

[Mordante]

CI fixes.

[Mordante]

CI fixes.

[ldionne]

LGTM with comments!

libcxx/CMakeLists.txt

92–93

Seems clearer.

libcxx/include/__chrono/tzdb_list.h

42

I think we should try to be consistent in this patch. We can talk about not documenting all of the _LIBCPP_NODISCARD_EXT in a rst document anymore (and I think I'd be in favour of that), but I think we should just be consistent with the current state of the code as of checking this patch in.

45

Have you considered making this a pimpl to hide the definition of the class into the dylib? It might help with keeping the added dependencies minimal, and it would also give us more freedom to change the implementation in the future (although IDK whether we'll ever need/want that freedom). I'm not asking you to do that, but I think it should at least be considered.

libcxx/test/std/time/time.zone/time.zone.db/time.zone.db.tzdb/tzdb.members.pass.cpp

36

We also need to do something like static_assert(std::is_same<decltype(tzdb.version), std::string>), don't we?

Right now tzdb.version could be anything with an assignment operator that returns a std::string, and the test would still pass.

[Mordante]

Thanks for the review!

libcxx/include/__chrono/tzdb_list.h

45

I had not really considered that since it's typically not something we do. The big disadvantage of the pimpl pattern is that it moves code to the dylib causing it not to be available on Apple platforms. In this case that is not a real issue; other parts of the TZDB are already in the dylib.

Calling the dylib might give some overhead. I don't think that is a huge issue. Looking at the amount of work needed to use time zones I don't see it as very fast code in the first place.

libcxx/include/module.modulemap.in

322

No longer needed.

[Mordante]

Rebased and addresses review comments.

[Mordante]

Retrigger CI.

[Mordante]

CI fixes.

[EricWF]

OK, here's a ton of comments. Thanks for addressing them.

libcxx/include/__chrono/tzdb.h

2

Why is this its own header?

libcxx/include/__chrono/tzdb_list.h

31

This conjunct deserves its own macro.

38

This should not be a public easily accessible constructor. At minimum it should take an unspellable tag type and not be single argument.

46

And this function can be replaced with *begin().

The fewer functions we put in the dylib the better. It's not strictly about speed, it's about surface area.

50

It seems unnecessary to export this function given that it's only used internally.

Please remove it.

55

Please remove these two functions from the dylib and instead just have them call begin() and end().

libcxx/include/__config

401

This macro is poorly named.

libcxx/modules/std/chrono.inc

213

I understand this #if 0 was existing.

But it's never OK practice to check into source #if 0. In particular without any explanation as to why it exists.

Code that needs to be wrapped in #if 0 isn't ready to be checked in.

libcxx/src/CMakeLists.txt

328

Why are you checking three options here?

It seems like if LIBCXX_ENABLE_TIME_ZONE_DATABASE is set, we should either error because we can't provide it without localization and filesystem, or we should provide it.

libcxx/src/tz.cpp

78

Nit. It doesn't look like this function "parses a string".

108

__matches sounds like it's a predicate. __consume_match makes more sense.

Also you don't need ugly identifiers inside source files. And its preferable that you don't use them.
It makes it appear as though these function are exported from the dylib or are from the headers.

128

Should this be nodestroy?

128

I would find a different way to initialize this that doesn't require having a public constructor.

141

This whole parsing bit seems overly complicated considering the pattern it's matching.
Can't we just read some large chunk out of the file, and then use string_view to walk it and parse it?

libcxx/src/tzdb_list.cpp

43

Doesn't this operation make the whole "thread safety" bit moot?

If you can erase an arbitrary member in the list, then that erase is potentially racy for any iterator on or before that element?

So either all the locking is unneeded, or we need to replace forward_list with a hand rolled atomic linked list. (Which shouldn't be too hard given the limited operations it needs to support).

73

Why is this a shared_mutex?

84

This should never be called.

libcxx/test/libcxx/diagnostics/chrono.nodiscard_extensions.compile.pass.cpp

26

Just make these normal tests and call the functions.

libcxx/test/libcxx/experimental/fexperimental-library.compile.pass.cpp

34

So it has complete TZDB?

libcxx/test/std/time/time.zone/time.zone.db/time.zone.db.list/iterators.pass.cpp

13

This is expected to fail if we have a complete tzdb implementation?

libcxx/test/support/test_tzdb.h

24

This is a clever way to test the internals. Good thinking.

Though it feels like this should probably return a string?

libcxx/utils/ci/buildkite-pipeline.yml

684

Please remove this configuration.

We don't have the capacity for it.

libcxx/utils/ci/run-buildbot

461

this doesn't need its own configuration right now.

It's also not clear to me that we need a configuration switch here.

If the user doesn't touch the tzdb interface, the fact that there is no database won't crop up.
So introducing a whole new configuration here is a bad idea.

Also, we effectively test this configuration when we test without filesystem.
Please remove it.

[abrachet]

We are seeing build failures after this patch. See https://ci.chromium.org/ui/p/fuchsia/builders/toolchain.ci/clang-mac-xarm64/b8770674124156502625/overview.

FAILED: libcxx/src/CMakeFiles/cxx_experimental.dir/tzdb_list.cpp.o 
/opt/s/w/ir/x/w/llvm_build/./bin/clang++ --target=armv7-unknown-linux-gnueabihf --sysroot=/opt/s/w/ir/x/w/cipd/linux -DLIBCXX_BUILDING_LIBCXXABI -D_DEBUG -D_GLIBCXX_ASSERTIONS -D_LIBCPP_BUILDING_LIBRARY -D_LIBCPP_ENABLE_HARDENED_MODE -D_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER -D_LIBCPP_LINK_PTHREAD_LIB -D_LIBCPP_LINK_RT_LIB -D_LIBCPP_REMOVE_TRANSITIVE_INCLUDES -D__STDC_CONSTANT_MACROS -D__STDC_FORMAT_MACROS -D__STDC_LIMIT_MACROS -I/opt/s/w/ir/x/w/llvm_build/tools/clang/stage2-bins/include/c++/v1 -I/opt/s/w/ir/x/w/llvm_build/tools/clang/stage2-bins/include/armv7-unknown-linux-gnueabihf/c++/v1 -I/opt/s/w/ir/x/w/llvm-llvm-project/libcxxabi/include -resource-dir=/opt/s/w/ir/x/w/llvm_build/tools/clang/stage2-bins/./lib/clang/18 --target=armv7-unknown-linux-gnueabihf -fPIC -fno-semantic-interposition -fvisibility-inlines-hidden -Werror=date-time -Werror=unguarded-availability-new -Wall -Wextra -Wno-unused-parameter -Wwrite-strings -Wcast-qual -Wmissing-field-initializers -Wimplicit-fallthrough -Wcovered-switch-default -Wno-noexcept-type -Wnon-virtual-dtor -Wdelete-non-virtual-dtor -Wsuggest-override -Wstring-conversion -Wmisleading-indentation -Wctad-maybe-unsupported -fdiagnostics-color -ffunction-sections -fdata-sections -ffile-prefix-map=/opt/s/w/ir/x/w/llvm_build/tools/clang/stage2-bins/runtimes/runtimes-armv7-unknown-linux-gnueabihf-bins=../llvm_build/tools/clang/stage2-bins/runtimes/runtimes-armv7-unknown-linux-gnueabihf-bins -ffile-prefix-map=/opt/s/w/ir/x/w/llvm-llvm-project/= -no-canonical-prefixes -O2 -g -DNDEBUG -std=c++20 -UNDEBUG -faligned-allocation -nostdinc++ -fvisibility-inlines-hidden -fvisibility=hidden -Wall -Wextra -Wnewline-eof -Wshadow -Wwrite-strings -Wno-unused-parameter -Wno-long-long -Werror=return-type -Wextra-semi -Wundef -Wunused-template -Wformat-nonliteral -Wno-user-defined-literals -Wno-covered-switch-default -Wno-suggest-override -Wno-error -D_LIBCPP_ENABLE_EXPERIMENTAL -MD -MT libcxx/src/CMakeFiles/cxx_experimental.dir/tzdb_list.cpp.o -MF libcxx/src/CMakeFiles/cxx_experimental.dir/tzdb_list.cpp.o.d -o libcxx/src/CMakeFiles/cxx_experimental.dir/tzdb_list.cpp.o -c /opt/s/w/ir/x/w/llvm-llvm-project/libcxx/src/tzdb_list.cpp
/opt/s/w/ir/x/w/llvm-llvm-project/libcxx/src/tzdb_list.cpp:29:7: error: use of undeclared identifier 'tzdb_list'
   29 | class tzdb_list::__impl {
      |       ^
/opt/s/w/ir/x/w/llvm-llvm-project/libcxx/src/tzdb_list.cpp:81:27: error: use of undeclared identifier 'tzdb_list'
   81 | _LIBCPP_EXPORTED_FROM_ABI tzdb_list::tzdb_list(tzdb&& __tzdb) : __impl_{new __impl(std::move(__tzdb))} {}
      |                           ^
...

Would you mind taking a look?

[vvereschaka]

Hi @Mordante ,

here is few failed libc++ tests on Arm/Aarch64 Ubuntu targets with the following error:

libc++abi: terminating due to uncaught exception of type std::runtime_error: corrupt tzdb: expected character '#'

• https://lab.llvm.org/buildbot/#/builders/60/builds/13787
• https://lab.llvm.org/buildbot/#/builders/119/builds/14997

[Mordante]

Thanks for the reports. I'll have a look at the failed builds now.

[Mordante]

@abrachet @vvereschaka I added work-arounds for the issues you encountered. These are not proper fixes but should unblock the CI. Please let me know when the issues are not solved. I will keep an eye on the llvm buildbots too.

[Mordante]

@EricWF Please ping me on Discord when you have finished the review, then I will look at a followup patch.

libcxx/include/__chrono/tzdb.h

2

Because nowadays (for at least two years) we tend to work with small headers. I'm open to discuss that, but then we should have a general policy discussion about this and not in individual patches.

libcxx/modules/std/chrono.inc

213

In general I agree with that statement, however I feel this is a great exception of the rule.

I added the entire synopis to all module files and commented out the parts libc++ has not implemented. This makes it easier to enable them once these parts are implemented. Especially when the CI fails it shows a named declaration std::chrono::ambiguous_local_time which can be grepped here.

libcxx/src/CMakeLists.txt

328

There are other places in libc++ that use multiple macros to guard them. For example, fstream requires both LIBCXX_ENABLE_FILESYSTEM and LIBCXX_ENABLE_LOCALIZATION. I did the same here based on that precedence.

libcxx/src/tz.cpp

108

We use both ugly and non-uqly naming in our dylib. I prefer ugly; it makes it easy to move code from the dylib to header without the need for uglyfication.

141

I used that in the past and I was not happy with that code. Note at the moment only a version number is parsed. There is a lot more to be parsed in followup patches,

libcxx/src/tzdb_list.cpp

43

Based on the wording in http://eel.is/c++draft/time.zone.db.list#lib:begin,tzdb_list this matches the wording and its intend. Which part does not make sense to you?

73

The write access is only needed when this object is modified. In practice this should be very rare so read operations should be concurrent.

The main reason for writing is when reloading the TZDB, which requires a new database to be released and updated by the system administrator. New databases happen a handful of times per year, so it's only useful for long running applications.

I'll add a comment to explain this.

84

What do you mean?

libcxx/test/libcxx/diagnostics/chrono.nodiscard_extensions.compile.pass.cpp

26

I really don't understand what you mean. Note this test only tests the nodiscard extension nothing else. This is the same of other tests in this directory. There are different tests that test the behaviour of these funtions.

What is the problem with this test?

libcxx/test/libcxx/experimental/fexperimental-library.compile.pass.cpp

34

Can you elaborate what you mean. The TZDB feature is experimental and incomplete. There are several additional patches in the works to get somewhat useful behaviour.

libcxx/test/support/test_tzdb.h

24

Why the returned value is only used for parsing so a temporary is fine. Note that this is only used for testing purposes.

libcxx/utils/ci/buildkite-pipeline.yml

684

Since we intend to ship libc++ with TZDB disabled we should test it. The TZDB adds quite some code in its final incarnation. This is useful for embedded systems.

I agree we should look at how we want to do testing. What I would like is something GitLab offers. Make some tests manually. These are not executed by default, but you can start them manually when you want to test them. Next to that nightly builds will enable them automatically.

I think this would apply to several of our parts disabled tests. Most of them are very specific.
I hope we can look at that when Phabricator is retired and we can move our CI to GitHub actions.

libcxx/CMakeLists.txt

option(LIBCXX_ENABLE_UNICODE
    be useful when porting to platforms that don't support UTF-8 encoding (e.g.
    embedded)." ON)
 option(LIBCXX_ENABLE_WIDE_CHARACTERS
   "Whether to include support for wide characters in the library. Disabling
    wide character support can be useful when porting to platforms that don't
    support the C functionality for wide characters. When wide characters are
    not supported, several parts of the library will be disabled, notably the
    wide character specializations of std::basic_string." ON)
+
+# To use time zone support in libc++ the platform needs to have the IANA
+# database installed. Libc++ will fail to build if this is enabled on a
+# platform that does not provide the IANA database. The default is set to the
+# current implementation state on the different platforms.
+#
+# TODO TZDB make the default always ON when most platforms ship with the IANA
+# database.
+if(${CMAKE_SYSTEM_NAME} MATCHES "Linux")
+  set(ENABLE_TIME_ZONE_DATABASE_DEFAULT ON)
+else()
+  set(ENABLE_TIME_ZONE_DATABASE_DEFAULT OFF)
+endif()
+option(LIBCXX_ENABLE_TIME_ZONE_DATABASE
+  "Whether to include support for time zones in the library. Disabling
+  time zone support can be useful when porting to platforms that don't
+  ship the IANA time zone database. When time zones are not supported,
+  time zone support in <chrono> will be disabled." ${ENABLE_TIME_ZONE_DATABASE_DEFAULT})
 option(LIBCXX_ENABLE_VENDOR_AVAILABILITY_ANNOTATIONS
   "Whether to turn on vendor availability annotations on declarations that depend
    on definitions in a shared library. By default, we assume that we're not building
    libc++ for any specific vendor, and we disable those annotations. Vendors wishing
    to provide compile-time errors when using features unavailable on some version of
    the shared library they shipped should turn this on and see `include/__availability`
    for more details." OFF)
 option(LIBCXX_ENABLE_CLANG_TIDY "Whether to compile and run clang-tidy checks" OFF)

 
 set(LIBCXX_HERMETIC_STATIC_LIBRARY_DEFAULT OFF)
 if (WIN32)
   set(LIBCXX_HERMETIC_STATIC_LIBRARY_DEFAULT ON)
 endif()
 option(LIBCXX_HERMETIC_STATIC_LIBRARY
   "Do not export any symbols from the static library." ${LIBCXX_HERMETIC_STATIC_LIBRARY_DEFAULT})
 
 #===============================================================================
 # Check option configurations
 #===============================================================================
 
 # Ensure LIBCXX_ENABLE_MONOTONIC_CLOCK is set to ON only when
 # LIBCXX_ENABLE_THREADS is on.
 if(LIBCXX_ENABLE_THREADS AND NOT LIBCXX_ENABLE_MONOTONIC_CLOCK)
   message(FATAL_ERROR "LIBCXX_ENABLE_MONOTONIC_CLOCK can only be set to OFF"
                       " when LIBCXX_ENABLE_THREADS is also set to OFF.")
 endif()
 
 if(NOT LIBCXX_ENABLE_THREADS)
   if(LIBCXX_HAS_PTHREAD_API)
     message(FATAL_ERROR "LIBCXX_HAS_PTHREAD_API can only be set to ON"
                         " when LIBCXX_ENABLE_THREADS is also set to ON.")
   endif()

 config_define_if(LIBCXX_HAS_MUSL_LIBC _LIBCPP_HAS_MUSL_LIBC)
 config_define_if(LIBCXX_NO_VCRUNTIME _LIBCPP_NO_VCRUNTIME)
 config_define_if_not(LIBCXX_ENABLE_FILESYSTEM _LIBCPP_HAS_NO_FILESYSTEM)
 config_define_if_not(LIBCXX_ENABLE_RANDOM_DEVICE _LIBCPP_HAS_NO_RANDOM_DEVICE)
 config_define_if_not(LIBCXX_ENABLE_LOCALIZATION _LIBCPP_HAS_NO_LOCALIZATION)
 config_define_if_not(LIBCXX_ENABLE_UNICODE _LIBCPP_HAS_NO_UNICODE)
 config_define_if_not(LIBCXX_ENABLE_WIDE_CHARACTERS _LIBCPP_HAS_NO_WIDE_CHARACTERS)
 config_define_if_not(LIBCXX_ENABLE_STD_MODULES _LIBCPP_HAS_NO_STD_MODULES)
+config_define_if_not(LIBCXX_ENABLE_TIME_ZONE_DATABASE _LIBCPP_HAS_NO_TIME_ZONE_DATABASE)
 config_define_if_not(LIBCXX_ENABLE_VENDOR_AVAILABILITY_ANNOTATIONS _LIBCPP_HAS_NO_VENDOR_AVAILABILITY_ANNOTATIONS)
 if (LIBCXX_HARDENING_MODE STREQUAL "hardened")
   config_define(1 _LIBCPP_ENABLE_HARDENED_MODE_DEFAULT)
   config_define(0 _LIBCPP_ENABLE_DEBUG_MODE_DEFAULT)
 elseif (LIBCXX_HARDENING_MODE STREQUAL "debug")
   config_define(0 _LIBCPP_ENABLE_HARDENED_MODE_DEFAULT)
   config_define(1 _LIBCPP_ENABLE_DEBUG_MODE_DEFAULT)
 elseif (LIBCXX_HARDENING_MODE STREQUAL "unchecked")

libcxx/cmake/caches/Generic-no-tzdb.cmake

+set(LIBCXX_ENABLE_TIME_ZONE_DATABASE OFF CACHE BOOL "")

libcxx/docs/BuildingLibcxx.rst

 
 .. warning::
   If your operating system already provides libc++, it is important to be careful
   not to replace it. Replacing your system's libc++ installation could render it
   non-functional. Use the CMake option ``CMAKE_INSTALL_PREFIX`` to select a safe
   place to install libc++.
 
 
 The default build
 =================
 
 The default way of building libc++, libc++abi and libunwind is to root the CMake
 invocation at ``<monorepo>/runtimes``. While those projects are under the LLVM
 umbrella, they are different in nature from other build tools, so it makes sense
 to treat them as a separate set of entities. The default build can be achieved
 with the following CMake invocation:
 
.. option:: LIBCXX_ENABLE_WIDE_CHARACTERS:BOOL
 
    **Default**: ``ON``
 
    This option can be used to disable support for ``wchar_t`` in the library. It also
    allows the library to work on top of a C Standard Library that does not provide
    support for ``wchar_t``. This is especially useful in embedded settings where
    C Standard Libraries don't always provide all the usual bells and whistles.
 
+.. option:: LIBCXX_ENABLE_TIME_ZONE_DATABASE:BOOL
+
+   **Default**: ``ON``
+
+   Whether to include support for time zones in the library. Disabling
+   time zone support can be useful when porting to platforms that don't
+   ship the IANA time zone database. When time zones are not supported,
+   time zone support in <chrono> will be disabled.
+
 .. option:: LIBCXX_INSTALL_LIBRARY_DIR:PATH
 
   **Default**: ``lib${LIBCXX_LIBDIR_SUFFIX}``
 
   Path where built libc++ libraries should be installed. If a relative path,
   relative to ``CMAKE_INSTALL_PREFIX``.
 
 .. option:: LIBCXX_INSTALL_INCLUDE_DIR:PATH
.. option:: LIBCXX_ADDITIONAL_COMPILE_FLAGS:STRING
   Additional Compile only flags which can be provided in cache.
 
 .. option:: LIBCXX_ADDITIONAL_LIBRARIES:STRING
 
   **Default**: ``""``
 
   Additional libraries libc++ is linked to which can be provided in cache.
 
 
 .. _ABI Library Specific Options:
 
 ABI Library Specific Options
 ----------------------------
 
 .. option:: LIBCXX_CXX_ABI:STRING
 
   **Values**: ``none``, ``libcxxabi``, ``system-libcxxabi``, ``libcxxrt``, ``libstdc++``, ``libsupc++``, ``vcruntime``.

libcxx/docs/DesignDocs/TimeZone.rst

+=================
+Time Zone Support
+=================
+
+Introduction
+============
+
+Starting with C++20 the ``<chrono>`` library has support for time zones.
+These are available in the
+`IANA Time Zone Database <https://data.iana.org/time-zones/tz-link.html>`_.
+This page describes the design decisions and trade-offs made to implement this
+feature. This page contains several links with more information regarding the
+contents of the IANA database, this page assumes the reader is familiar with
+this information.
+
+Which version of the Time Zone Database to use
+==============================================
+
+The data of the database is available on several platforms in different forms:
+
+- Typically Unix systems ship the database as
+  `TZif files <https://www.rfc-editor.org/rfc/rfc8536.html>`_. This format has
+  3 versions and the ``time_zone_link`` information is not always available.
+  If available, they are symlinks in the file system.
+  These files don't provide the database version information. This information
+  is needed for the functions ``std::chrono:: remote_version()`` and
+  ``std::chrono::reload_tzdb()``.
+
+- On several Unix systems the time zone source files are available. These files
+  are stored in several regions, mainly the continents. This file contains a
+  large amount of comment with historical information regarding time zones.
+  The format is documented in the
+  `IANA documentation <https://data.iana.org/time-zones/tz-how-to.html>`_
+  and in the `man page <https://man7.org/linux/man-pages/man8/zic.8.html>`_ of zic.
+  The disadvantage of this version is that at least Linux versions don't have
+  the database version information. This information is needed for the functions
+  ``std::chrono:: remote_version()`` and ``std::chrono::reload_tzdb()``.
+
+- On Linux systems ``tzdata.zi`` is available. This contains the same
+  information as the source files but in one file without the comments. This
+  file uses the same format as the sources, but shortens the names. For example
+  ``Rule`` is abbreviated to ``R``. This file contains the database version
+  information.
+
+The disadvantage of the ``TZif`` format (which is a binary format) is that it's
+not possible to get the proper ``time_zone_link`` information on all platforms.
+The time zone database version number is also missing from ``TZif`` files.
+Since the time zone database is supposed to contain both these informations,
+``TZif`` files can't be used to create a conforming implementation.
+
+Since it's easier to parse one file than a set of files we decided
+to use the ``tzdata.zi``. The other benefit is that the ``tzdata.zi`` file
+contains the database version information needed for a conforming
+implementation.
+
+The ``tzdata.zi`` file is not available on all platforms as of August 2023, so
+some vendors will need to make changes to their platform. Most vendors already
+ship the database, so they only need to adjust the packaging of their time zone
+package to include the files we require. One notable exception is Windows,
+where no IANA time zone database is provided at all. However it's possible for
+Windows packagers to add these files to their libc++ packages. The IANA
+databases can be
+`downloaded <https://data.iana.org/time-zones/releases/>`_.
+
+An alternative would be to ship the database with libc++, either as a file or
+compiled in the dylib. The text file is about 112 KB. For now libc++ will not
+ship this file. If it's hard to get vendors to ship these files we can
+reconsider based on that information.
+
+Leap seconds
+------------
+
+For the leap seconds libc++ will use the source file ``leap-seconds.list``.
+This file is easier to parse than the ``leapseconds`` file. Both files are
+present on Linux, but not always on other platforms. Since these platforms need
+to change their packaging for ``tzdata.zi``, adding two instead of one files
+seems a small change.
+
+
+Updating the Time Zone Database
+===============================
+
+Per `[time.zone.db.remote]/1 <http://eel.is/c++draft/time.zone#db.remote-1>`_
+
+.. code-block:: text
+
+  The local time zone database is that supplied by the implementation when the
+  program first accesses the database, for example via current_zone(). While the
+  program is running, the implementation may choose to update the time zone
+  database. This update shall not impact the program in any way unless the
+  program calls the functions in this subclause. This potentially updated time
+  zone database is referred to as the remote time zone database.
+
+There is an update mechanism in libc++, however this is not done automatically.
+Invoking the function ``std::chrono::remote_version()`` will parse the version
+information of the ``tzdata.zi`` file and return that information. Similarly,
+``std::chrono::reload_tzdb()`` will parse the ``tzdata.zi`` and
+``leap-seconds.list`` again. This makes it possible to update the database if
+needed by the application and gives the user full power over the update policy.
+
+This approach has several advantages:
+
+- It is simple to implement.
+- The library does not need to start a periodic background process to poll
+  changes to the filesystem. When using a background process, it may become
+  active when the application is busy with its core task, taking away resources
+  from that task.
+- If there is no threading available this polling
+  becomes more involved. For example, query the file every *x* calls to
+  ``std::chrono::get_tzdb()``. This mean calls to ``std::chrono::get_tzdb()``
+  would have different performance characteristics.
+
+The small drawback is:
+
+- On platforms with threading enabled updating the database may take longer.
+  On these platforms the remote database could have been loaded in a background
+  process.
+
+Another issue with the automatic update is that it may not be considered
+Standard compliant, since the Standard uses the wording "This update shall not
+impact the program in any way". Using resources could be considered as
+impacting the program.

libcxx/docs/ImplementationDefinedBehavior.rst

+.. _implementation-defined-behavior:
+
+===============================
+Implementation-defined behavior
+===============================
+
+Contains the implementation details of the implementation-defined behavior in
+libc++. Implementation-defined is mandated to be documented by the Standard.
+
+.. note:
+   This page is far from complete.
+
+
+Implementation-defined behavior
+===============================
+
+Updating the Time Zone Database
+-------------------------------
+
+The Standard allows implementations to automatically update the
+*remote time zone database*. Libc++ opts not to do that. Instead calling
+
+ - ``std::chrono::remote_version()`` will update the version information of the
+   *remote time zone database*,
+ - ``std::chrono::reload_tzdb()``, if needed, will update the entire
+   *remote time zone database*.
+
+This offers a way for users to update the *remote time zone database* and
+give them full control over the process.
+
+Listed in the index of implementation-defined behavior
+======================================================
+
+The order of the entries matches the entries in the
+`draft of the Standard <http://eel.is/c++draft/impldefindex>`_.

libcxx/docs/Status/Cxx20.rst

.. note::
    .. [#note-P0645] P0645: The paper is implemented but still marked as an incomplete feature
       (the feature-test macro is not set).
    .. [#note-P0966] P0966: It was previously erroneously marked as complete in version 8.0. See `bug 45368 <https://llvm.org/PR45368>`__.
    .. [#note-P0619] P0619: Only sections D.8, D.9, D.10 and D.13 are implemented. Sections D.4, D.7, D.11, D.12, and D.14 remain undone.
    .. [#note-P0883.1] P0883: shared_ptr and floating-point changes weren't applied as they themselves aren't implemented yet.
    .. [#note-P0883.2] P0883: ``ATOMIC_FLAG_INIT`` was marked deprecated in version 14.0, but was undeprecated with the implementation of LWG3659 in version 15.0.
    .. [#note-P2231] P2231: Optional is complete. The changes to variant haven't been implemented yet.
    .. [#note-P0660] P0660: Section 32.3 Stop Tokens is complete. ``jthread`` hasn't been implemented yet.
+   .. [#note-P0355] P0355: The implementation status is:
+
+      * ``Calendars`` mostly done in Clang 7
+      * ``Input parsers`` not done
+      * ``Stream output`` Obsolete due to `P1361R2 <https://wg21.link/P1361R2>`_ "Integration of chrono with text formatting"
+      * ``Time zone and leap seconds`` In Progress
+      * ``TAI clock`` not done
+      * ``GPS clock`` not done
+      * ``UTC clock`` not done
 
 .. _issues-status-cxx20:
 
 Library Working Group Issues Status
 ====================================
 
 .. csv-table::
    :file: Cxx20Issues.csv
    :header-rows: 1
    :widths: auto

libcxx/docs/Status/Cxx20Issues.csv

 "`3307 <https://wg21.link/LWG3307>`__","``std::allocator<void>().allocate(n)``\ ","Prague","",""
 "`3310 <https://wg21.link/LWG3310>`__","Replace ``SIZE_MAX``\  with ``numeric_limits<size_t>::max()``\ ","Prague","|Complete|","16.0"
 "`3313 <https://wg21.link/LWG3313>`__","``join_view::iterator::operator--``\  is incorrectly constrained","Prague","|Complete|","14.0","|ranges|"
 "`3314 <https://wg21.link/LWG3314>`__","Is stream insertion behavior locale dependent when ``Period::type``\  is ``micro``\ ?","Prague","|Complete|","16.0","|chrono|"
 "`3315 <https://wg21.link/LWG3315>`__","Correct Allocator Default Behavior","Prague","",""
 "`3316 <https://wg21.link/LWG3316>`__","Correctly define epoch for ``utc_clock``\  / ``utc_timepoint``\ ","Prague","","","|chrono|"
 "`3317 <https://wg21.link/LWG3317>`__","Incorrect ``operator<<``\  for floating-point durations","Prague","","","|chrono|"
 "`3318 <https://wg21.link/LWG3318>`__","Clarify whether clocks can represent time before their epoch","Prague","","","|chrono|"
-"`3319 <https://wg21.link/LWG3319>`__","Properly reference specification of IANA time zone database","Prague","","","|chrono|"
+"`3319 <https://wg21.link/LWG3319>`__","Properly reference specification of IANA time zone database","Prague","|Nothing To Do|","","|chrono|"
 "`3320 <https://wg21.link/LWG3320>`__","``span::cbegin/cend``\  methods produce different results than ``std::[ranges::]cbegin/cend``\ ","Prague","|Complete|",""
 "`3321 <https://wg21.link/LWG3321>`__","``uninitialized_construct_using_allocator``\  should use ``construct_at``\ ","Prague","|Complete|","16.0"
 "`3323 <https://wg21.link/LWG3323>`__","``*has-tuple-element*``\  helper concept needs ``convertible_to``\ ","Prague","|Complete|","16.0","|ranges|"
 "`3324 <https://wg21.link/LWG3324>`__","Special-case ``std::strong/weak/partial_order``\  for pointers","Prague","|Complete|","14.0","|spaceship|"
 "`3325 <https://wg21.link/LWG3325>`__","Constrain return type of transformation function for ``transform_view``\ ","Prague","|Complete|","15.0","|ranges|"
 "`3326 <https://wg21.link/LWG3326>`__","``enable_view``\  has false positives","Prague","|Complete|","15.0","|ranges|"
 "`3327 <https://wg21.link/LWG3327>`__","Format alignment specifiers vs. text direction","Prague","|Nothing To Do|","","|format|"
 "`3328 <https://wg21.link/LWG3328>`__","Clarify that ``std::string``\  is not good for UTF-8","Prague","",""

libcxx/docs/Status/Cxx20Papers.csv

 "`P0600R1 <https://wg21.link/P0600R1>`__","LWG","nodiscard in the Library","Albuquerque","|Complete|","16.0"
 "`P0616R0 <https://wg21.link/P0616R0>`__","LWG","de-pessimize legacy <numeric> algorithms with std::move","Albuquerque","|Complete|","12.0"
 "`P0653R2 <https://wg21.link/P0653R2>`__","LWG","Utility to convert a pointer to a raw pointer","Albuquerque","|Complete|","6.0"
 "`P0718R2 <https://wg21.link/P0718R2>`__","LWG","Atomic shared_ptr","Albuquerque","",""
 "`P0767R1 <https://wg21.link/P0767R1>`__","CWG","Deprecate POD","Albuquerque","|Complete|","7.0"
 "`P0768R1 <https://wg21.link/P0768R1>`__","CWG","Library Support for the Spaceship (Comparison) Operator","Albuquerque","|Complete|",""
 "`P0777R1 <https://wg21.link/P0777R1>`__","LWG","Treating Unnecessary ``decay``\ ","Albuquerque","|Complete|","7.0"
 "`P0122R7 <https://wg21.link/P0122R7>`__","LWG","<span>","Jacksonville","|Complete|","7.0"
-"`P0355R7 <https://wg21.link/P0355R7>`__","LWG","Extending chrono to Calendars and Time Zones","Jacksonville","|In Progress|",""
+"`P0355R7 <https://wg21.link/P0355R7>`__","LWG","Extending chrono to Calendars and Time Zones","Jacksonville","|Partial| [#note-P0355]_",""
 "`P0551R3 <https://wg21.link/P0551R3>`__","LWG","Thou Shalt Not Specialize ``std``\  Function Templates!","Jacksonville","|Complete|","11.0"
 "`P0753R2 <https://wg21.link/P0753R2>`__","LWG","Manipulators for C++ Synchronized Buffered Ostream","Jacksonville","",""
 "`P0754R2 <https://wg21.link/P0754R2>`__","LWG","<version>","Jacksonville","|Complete|","7.0"
 "`P0809R0 <https://wg21.link/P0809R0>`__","LWG","Comparing Unordered Containers","Jacksonville","|Nothing To Do|",""
 "`P0858R0 <https://wg21.link/P0858R0>`__","LWG","Constexpr iterator requirements","Jacksonville","|Complete|","12.0"
 "`P0905R1 <https://wg21.link/P0905R1>`__","CWG","Symmetry for spaceship","Jacksonville","",""
 "`P0966R1 <https://wg21.link/P0966R1>`__","LWG","``string::reserve``\  Should Not Shrink","Jacksonville","|Complete| [#note-P0966]_","12.0"
 "","","","","","",""

libcxx/docs/UsingLibcxx.rst

 * ``binary_search``
 * ``bit_cast``
 * ``bit_ceil``
 * ``bit_floor``
 * ``bit_width``
 * ``byteswap``
 * ``cbrt``
 * ``ceil``
+* ``chrono::tzdb_list::begin``
+* ``chrono::tzdb_list::cbegin``
+* ``chrono::tzdb_list::cend``
+* ``chrono::tzdb_list::end``
+* ``chrono::get_tzdb_list``
+* ``chrono::get_tzdb``
+* ``chrono::remote_version``
 * ``clamp``
 * ``copysign``
 * ``count_if``
 * ``count``
 * ``countl_zero``
 * ``countl_one``
 * ``countr_zero``
 * ``countr_one``

 Standard. Libc++ retroactively updates the Unicode Standard in older C++
 versions. This allows the library to have better estimates for newly introduced
 Unicode code points, without requiring the user to use the latest C++ version
 in their code base.
 
 In C++26 formatting pointers gained a type ``P`` and allows to use
 zero-padding. These options have been retroactively applied to C++20.
 
 Extensions to the C++23 modules ``std`` and ``std.compat``
 ----------------------------------------------------------
 
 Like other major implementations, libc++ provides C++23 modules ``std`` and
 ``std.compat`` in C++20 as an extension"
 
 .. _turning-off-asan:
 
 Turning off ASan annotation in containers
 -----------------------------------------
 
 ``__asan_annotate_container_with_allocator`` is a customization point to allow users to disable
.. code-block:: cpp
   #endif
 
 Why may I want to turn it off?
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 There are a few reasons why you may want to turn off annotations for an allocator.
 Unpoisoning may not be an option, if (for example) you are not maintaining the allocator.
 
 * You are using allocator, which does not call destructor during deallocation.
 * You are aware that memory allocated with an allocator may be accessed, even when unused by container.
 
 Platform specific behavior
 ==========================
 
 Windows
 -------
 
 The ``stdout``, ``stderr``, and ``stdin`` file streams can be placed in
 Unicode mode by a suitable call to ``_setmode()``. When in this mode,
 the sequence of bytes read from, or written to, these streams is interpreted
 as a sequence of little-endian ``wchar_t`` elements. Thus, use of
 ``std::cout``, ``std::cerr``, or ``std::cin`` with streams in Unicode mode
 will not behave as they usually do since bytes read or written won't be
 interpreted as individual ``char`` elements. However, ``std::wcout``,
 ``std::wcerr``, and ``std::wcin`` will behave as expected.
 
 Wide character stream such as ``std::wcin`` or ``std::wcout`` imbued with a
 locale behave differently than they otherwise do. By default, wide character
 streams don't convert wide characters but input/output them as is. If a
 specific locale is imbued, the IO with the underlying stream happens with
 regular ``char`` elements, which are converted to/from wide characters
 according to the locale. Note that this doesn't behave as expected if the
 stream has been set in Unicode mode.

libcxx/docs/index.rst

.. toctree::
    :maxdepth: 1
 
    ReleaseNotes/17
    ReleaseNotes/18
    UsingLibcxx
    BuildingLibcxx
    TestingLibcxx
    Contributing
+   ImplementationDefinedBehavior
    Modules
    Hardening
    ReleaseProcedure
    Status/Cxx14
    Status/Cxx17
    Status/Cxx20
    Status/Cxx23
    Status/Cxx2c
.. toctree::
    DesignDocs/FileTimeType
    DesignDocs/HeaderRemovalPolicy
    DesignDocs/NoexceptPolicy
    DesignDocs/PSTLIntegration
    DesignDocs/ThreadingSupportAPI
    DesignDocs/UniquePtrTrivialAbi
    DesignDocs/UnspecifiedBehaviorRandomization
    DesignDocs/VisibilityMacros
+   DesignDocs/TimeZone
 
 
 Build Bots and Test Coverage
 ============================
 
 * `Buildkite CI pipeline <https://buildkite.com/llvm-project/libcxx-ci>`_
 * `LLVM Buildbot Builders <https://lab.llvm.org/buildbot>`_
 * :ref:`Adding New CI Jobs <AddingNewCIJobs>`

libcxx/include/CMakeLists.txt

set(files
   __chrono/month_weekday.h
   __chrono/monthday.h
   __chrono/ostream.h
   __chrono/parser_std_format_spec.h
   __chrono/statically_widen.h
   __chrono/steady_clock.h
   __chrono/system_clock.h
   __chrono/time_point.h
+  __chrono/tzdb.h
+  __chrono/tzdb_list.h
   __chrono/weekday.h
   __chrono/year.h
   __chrono/year_month.h
   __chrono/year_month_day.h
   __chrono/year_month_weekday.h
   __compare/common_comparison_category.h
   __compare/compare_partial_order_fallback.h
   __compare/compare_strong_order_fallback.h

libcxx/include/__availability

 // #   define _LIBCPP_AVAILABILITY_HAS_NO_VERBOSE_ABORT
 #   define _LIBCPP_AVAILABILITY_VERBOSE_ABORT
 
     // This controls the availability of the C++17 std::pmr library,
     // which is implemented in large part in the built library.
 // #   define _LIBCPP_AVAILABILITY_HAS_NO_PMR
 #   define _LIBCPP_AVAILABILITY_PMR
 
+    // This controls the availability of the C++20 time zone database.
+    // The parser code is built in the library.
+// #   define _LIBCPP_AVAILABILITY_HAS_NO_TZDB
+#   define _LIBCPP_AVAILABILITY_TZDB
+
 #elif defined(__APPLE__)
 
     // shared_mutex and shared_timed_mutex
 #   if (defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ < 101200) ||    \
         (defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ < 100000) || \
         (defined(__ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__ < 100000) ||         \
         (defined(__ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__ < 30000)
 #       define _LIBCPP_AVAILABILITY_HAS_NO_SHARED_MUTEX
#    define _LIBCPP_AVAILABILITY_PMR                                                                                   \
       __attribute__((availability(macos, strict, introduced = 14.0)))                                                  \
       __attribute__((availability(ios, strict, introduced = 17.0)))                                                    \
       __attribute__((availability(tvos, strict, introduced = 17.0)))                                                   \
       __attribute__((availability(watchos, strict, introduced = 10.0)))
 #  else
 #    define _LIBCPP_AVAILABILITY_PMR
 #  endif
 
+#  define _LIBCPP_AVAILABILITY_HAS_NO_TZDB
+#  define _LIBCPP_AVAILABILITY_TZDB __attribute__((unavailable))
+
 #else
 
 // ...New vendors can add availability markup here...
 
 #   error "It looks like you're trying to enable vendor availability markup, but you haven't defined the corresponding macros yet!"
 
 #endif
 

libcxx/include/__chrono/tzdb.h

+// -*- 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
+//
+//===----------------------------------------------------------------------===//
+
+// For information see https://libcxx.llvm.org/DesignDocs/TimeZone.html
+
+#ifndef _LIBCPP___CHRONO_TZDB_H
+#define _LIBCPP___CHRONO_TZDB_H
+
+#include <version>
+// Enable the contents of the header only when libc++ was built with experimental features enabled.
+#if !defined(_LIBCPP_HAS_NO_INCOMPLETE_TZDB)
+
+#  include <string>
+
+#  if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#    pragma GCC system_header
+#  endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#  if _LIBCPP_STD_VER >= 20 && !defined(_LIBCPP_HAS_NO_TIME_ZONE_DATABASE) && !defined(_LIBCPP_HAS_NO_FILESYSTEM) &&   \
+      !defined(_LIBCPP_HAS_NO_LOCALIZATION)
+
+namespace chrono {
+
+struct _LIBCPP_AVAILABILITY_TZDB tzdb {
+  string version;
+};
+
+} // namespace chrono
+
+#  endif // _LIBCPP_STD_VER >= 20 && !defined(_LIBCPP_HAS_NO_TIME_ZONE_DATABASE) && !defined(_LIBCPP_HAS_NO_FILESYSTEM)
+         // && !defined(_LIBCPP_HAS_NO_LOCALIZATION)
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // !defined(_LIBCPP_HAS_NO_INCOMPLETE_TZDB)
+
+#endif // _LIBCPP___CHRONO_TZDB_H

libcxx/include/__chrono/tzdb_list.h

+// -*- 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
+//
+//===----------------------------------------------------------------------===//
+
+// For information see https://libcxx.llvm.org/DesignDocs/TimeZone.html
+
+#ifndef _LIBCPP___CHRONO_TZDB_LIST_H
+#define _LIBCPP___CHRONO_TZDB_LIST_H
+
+#include <version>
+// Enable the contents of the header only when libc++ was built with experimental features enabled.
+#if !defined(_LIBCPP_HAS_NO_INCOMPLETE_TZDB)
+
+#  include <__availability>
+#  include <__chrono/tzdb.h>
+#  include <forward_list>
+#  include <string_view>
+
+#  if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#    pragma GCC system_header
+#  endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#  if _LIBCPP_STD_VER >= 20 && !defined(_LIBCPP_HAS_NO_TIME_ZONE_DATABASE) && !defined(_LIBCPP_HAS_NO_FILESYSTEM) &&   \
+      !defined(_LIBCPP_HAS_NO_LOCALIZATION)
+
+namespace chrono {
+
+class _LIBCPP_AVAILABILITY_TZDB tzdb_list {
+public:
+  _LIBCPP_EXPORTED_FROM_ABI explicit tzdb_list(tzdb&& __tzdb);
+  _LIBCPP_EXPORTED_FROM_ABI ~tzdb_list();
+
+  tzdb_list(const tzdb_list&)            = delete;
+  tzdb_list& operator=(const tzdb_list&) = delete;
+
+  using const_iterator = forward_list<tzdb>::const_iterator;
+
+  _LIBCPP_NODISCARD_EXT _LIBCPP_EXPORTED_FROM_ABI const tzdb& front() const noexcept;
+
+  _LIBCPP_EXPORTED_FROM_ABI const_iterator erase_after(const_iterator __p);
+
+  _LIBCPP_EXPORTED_FROM_ABI tzdb& __emplace_front(tzdb&& __tzdb);
+
+  _LIBCPP_NODISCARD_EXT _LIBCPP_EXPORTED_FROM_ABI const_iterator begin() const noexcept;
+  _LIBCPP_NODISCARD_EXT _LIBCPP_EXPORTED_FROM_ABI const_iterator end() const noexcept;
+
+  _LIBCPP_NODISCARD_EXT _LIBCPP_EXPORTED_FROM_ABI const_iterator cbegin() const noexcept;
+  _LIBCPP_NODISCARD_EXT _LIBCPP_EXPORTED_FROM_ABI const_iterator cend() const noexcept;
+
+private:
+  class __impl;
+  __impl* __impl_;
+};
+
+_LIBCPP_NODISCARD_EXT _LIBCPP_AVAILABILITY_TZDB _LIBCPP_EXPORTED_FROM_ABI tzdb_list& get_tzdb_list();
+
+_LIBCPP_NODISCARD_EXT _LIBCPP_AVAILABILITY_TZDB _LIBCPP_HIDE_FROM_ABI inline const tzdb& get_tzdb() {
+  return get_tzdb_list().front();
+}
+
+_LIBCPP_AVAILABILITY_TZDB _LIBCPP_EXPORTED_FROM_ABI const tzdb& reload_tzdb();
+
+_LIBCPP_NODISCARD_EXT _LIBCPP_AVAILABILITY_TZDB _LIBCPP_EXPORTED_FROM_ABI string remote_version();
+
+} // namespace chrono
+
+#  endif // _LIBCPP_STD_VER >= 20 && !defined(_LIBCPP_HAS_NO_TIME_ZONE_DATABASE) && !defined(_LIBCPP_HAS_NO_FILESYSTEM)
+         // && !defined(_LIBCPP_HAS_NO_LOCALIZATION)
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // !defined(_LIBCPP_HAS_NO_INCOMPLETE_TZDB)
+
+#endif // _LIBCPP___CHRONO_TZDB_LIST_H

libcxx/include/__config

 #      define _LIBCPP_ENABLE_EXPERIMENTAL
 #    endif
 #  endif
 
 // Incomplete features get their own specific disabling flags. This makes it
 // easier to grep for target specific flags once the feature is complete.
 #  if !defined(_LIBCPP_ENABLE_EXPERIMENTAL) && !defined(_LIBCPP_BUILDING_LIBRARY)
 #    define _LIBCPP_HAS_NO_INCOMPLETE_PSTL
-#  endif
-
-#  if !defined(_LIBCPP_ENABLE_EXPERIMENTAL) && !defined(_LIBCPP_BUILDING_LIBRARY)
 #    define _LIBCPP_HAS_NO_EXPERIMENTAL_STOP_TOKEN
+#    define _LIBCPP_HAS_NO_INCOMPLETE_TZDB
 #  endif
 
 // Need to detect which libc we're using if we're on Linux.
 #  if defined(__linux__)
 #    include <features.h>
 #    if defined(__GLIBC_PREREQ)
 #      define _LIBCPP_GLIBC_PREREQ(a, b) __GLIBC_PREREQ(a, b)
 #    else

 #    define _PSTL_PRAGMA_SIMD_INCLUSIVE_SCAN(PRM)
 #    define _PSTL_PRAGMA_SIMD_EXCLUSIVE_SCAN(PRM)
 #    define _PSTL_PRAGMA_DECLARE_REDUCTION(NAME, OP)
 
 #  endif // (defined(_OPENMP) && _OPENMP >= 201307)
 
 #  define _PSTL_USE_NONTEMPORAL_STORES_IF_ALLOWED
 
 #endif // __cplusplus
 
 #endif // _LIBCPP___CONFIG

libcxx/include/__config_site.in

 #cmakedefine _LIBCPP_HAS_NO_VENDOR_AVAILABILITY_ANNOTATIONS
 #cmakedefine _LIBCPP_NO_VCRUNTIME
 #cmakedefine _LIBCPP_TYPEINFO_COMPARISON_IMPLEMENTATION @_LIBCPP_TYPEINFO_COMPARISON_IMPLEMENTATION@
 #cmakedefine _LIBCPP_HAS_NO_FILESYSTEM
 #cmakedefine _LIBCPP_HAS_NO_RANDOM_DEVICE
 #cmakedefine _LIBCPP_HAS_NO_LOCALIZATION
 #cmakedefine _LIBCPP_HAS_NO_WIDE_CHARACTERS
 #cmakedefine _LIBCPP_HAS_NO_STD_MODULES
+#cmakedefine _LIBCPP_HAS_NO_TIME_ZONE_DATABASE
 
 // PSTL backends
 #cmakedefine _LIBCPP_PSTL_CPU_BACKEND_SERIAL
 #cmakedefine _LIBCPP_PSTL_CPU_BACKEND_THREAD
 #cmakedefine _LIBCPP_PSTL_CPU_BACKEND_LIBDISPATCH
 
 // Hardening.
 #cmakedefine01 _LIBCPP_ENABLE_HARDENED_MODE_DEFAULT

libcxx/include/chrono

basic_ostream<charT, traits>&
     operator<<(basic_ostream<charT, traits>& os, const hh_mm_ss<Duration>& hms); // C++20
 
 // 26.10, 12/24 hour functions
 constexpr bool is_am(hours const& h) noexcept;
 constexpr bool is_pm(hours const& h) noexcept;
 constexpr hours make12(const hours& h) noexcept;
 constexpr hours make24(const hours& h, bool is_pm) noexcept;
 
+// [time.zone.db], time zone database
+struct tzdb {                                                                    // C++20
+  string                 version;
+};
+
+class tzdb_list {                                                                // C++20
+public:
+  tzdb_list(const tzdb_list&) = delete;
+  tzdb_list& operator=(const tzdb_list&) = delete;
+
+  // unspecified additional constructors
+
+  class const_iterator;
+
+  const tzdb& front() const noexcept;
+
+  const_iterator erase_after(const_iterator p);
+
+  const_iterator begin() const noexcept;
+  const_iterator end()   const noexcept;
+
+  const_iterator cbegin() const noexcept;
+  const_iterator cend()   const noexcept;
+};
+
+// [time.zone.db.access], time zone database access
+const tzdb& get_tzdb();                                                          // C++20
+tzdb_list& get_tzdb_list();                                                      // C++20
+
+// [time.zone.db.remote], remote time zone database support
+const tzdb& reload_tzdb();                                                       // C++20
+string remote_version();                                                         // C++20
+
 // 25.10.5, class time_zone    // C++20
 enum class choose {earliest, latest};
 class time_zone;
 bool operator==(const time_zone& x, const time_zone& y) noexcept;
 bool operator!=(const time_zone& x, const time_zone& y) noexcept;
 bool operator<(const time_zone& x, const time_zone& y) noexcept;
 bool operator>(const time_zone& x, const time_zone& y) noexcept;
 bool operator<=(const time_zone& x, const time_zone& y) noexcept;

 
 #if !defined(_LIBCPP_HAS_NO_LOCALIZATION) && _LIBCPP_STD_VER >= 20
 #  include <__chrono/formatter.h>
 #  include <__chrono/ostream.h>
 #  include <__chrono/parser_std_format_spec.h>
 #  include <__chrono/statically_widen.h>
 #endif
 
+#if !defined(_LIBCPP_HAS_NO_TIME_ZONE_DATABASE) && !defined(_LIBCPP_HAS_NO_FILESYSTEM) &&                              \
+    !defined(_LIBCPP_HAS_NO_LOCALIZATION)
+#  include <__chrono/tzdb.h>
+#  include <__chrono/tzdb_list.h>
+#endif
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <bit>
 #  include <concepts>
 #  include <cstring>
 #endif
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER == 20
 #  include <charconv>
 #endif
 
 #endif // _LIBCPP_CHRONO

libcxx/include/module.modulemap.in

module std_vector [system] {
   export *
 }
 module std_version [system] {
   header "version"
   export *
 }
 
 // C standard library interface wrappers
 module std_cassert [system] {
   // <cassert>'s use of NDEBUG requires textual inclusion.
   textual header "cassert"
 }
 module std_ccomplex [system] {
   header "ccomplex"
   export *
 }
 module std_cctype [system] {

 module std_private_chrono_steady_clock           [system] {
   header "__chrono/steady_clock.h"
   export std_private_chrono_time_point
 }
 module std_private_chrono_system_clock           [system] {
   header "__chrono/system_clock.h"
   export std_private_chrono_time_point
 }
+module std_private_chrono_tzdb                   [system] {
+  header "__chrono/tzdb.h"
+  export *
+}
+module std_private_chrono_tzdb_list              [system] {
+  header "__chrono/tzdb_list.h"
+  export *
+}
 module std_private_chrono_time_point             [system] { header "__chrono/time_point.h" }
 module std_private_chrono_weekday                [system] { header "__chrono/weekday.h" }
 module std_private_chrono_year                   [system] { header "__chrono/year.h" }
 module std_private_chrono_year_month             [system] { header "__chrono/year_month.h" }
 module std_private_chrono_year_month_day         [system] { header "__chrono/year_month_day.h" }
 module std_private_chrono_year_month_weekday     [system] { header "__chrono/year_month_weekday.h" }
 
 module std_private_compare_common_comparison_category     [system] { header "__compare/common_comparison_category.h" }

libcxx/modules/std/chrono.inc

#endif
     using std::chrono::hh_mm_ss;
 
     // [time.12], 12/24 hour functions
     using std::chrono::is_am;
     using std::chrono::is_pm;
     using std::chrono::make12;
     using std::chrono::make24;
 
-#if 0
+#if !defined(_LIBCPP_HAS_NO_TIME_ZONE_DATABASE) && !defined(_LIBCPP_HAS_NO_FILESYSTEM) &&                              \
+    !defined(_LIBCPP_HAS_NO_LOCALIZATION)
+
     // [time.zone.db], time zone database
     using std::chrono::tzdb;
     using std::chrono::tzdb_list;
 
     // [time.zone.db.access], time zone database access
-    using std::chrono::current_zone;
+    // using std::chrono::current_zone;
     using std::chrono::get_tzdb;
     using std::chrono::get_tzdb_list;
-    using std::chrono::locate_zone;
+    // using std::chrono::locate_zone;
 
     // [time.zone.db.remote], remote time zone database support
     using std::chrono::reload_tzdb;
     using std::chrono::remote_version;
 
+#endif //  !defined(_LIBCPP_HAS_NO_TIME_ZONE_DATABASE) && !defined(_LIBCPP_HAS_NO_FILESYSTEM) &&
+       //    !defined(_LIBCPP_HAS_NO_LOCALIZATION)
+
+#if 0
     // [time.zone.exception], exception classes
     using std::chrono::ambiguous_local_time;
     using std::chrono::nonexistent_local_time;
 
     // [time.zone.info], information classes
     using std::chrono::sys_info;
 
     // [time.zone.timezone], class time_zone

libcxx/src/CMakeLists.txt

 
 # Add a meta-target for both libraries.
 add_custom_target(cxx DEPENDS ${LIBCXX_BUILD_TARGETS})
 
 set(LIBCXX_EXPERIMENTAL_SOURCES
   experimental/memory_resource.cpp
   )
 
 if (LIBCXX_PSTL_CPU_BACKEND STREQUAL "libdispatch")
   list(APPEND LIBCXX_EXPERIMENTAL_SOURCES
     pstl/libdispatch.cpp
     )
 endif()
 
+if (LIBCXX_ENABLE_LOCALIZATION AND LIBCXX_ENABLE_FILESYSTEM AND LIBCXX_ENABLE_TIME_ZONE_DATABASE)
+  list(APPEND LIBCXX_EXPERIMENTAL_SOURCES
+    tz.cpp
+    tzdb_list.cpp
+    )
+endif()
+
 add_library(cxx_experimental STATIC ${LIBCXX_EXPERIMENTAL_SOURCES})
 target_link_libraries(cxx_experimental PUBLIC cxx-headers)
 if (LIBCXX_ENABLE_SHARED)
   target_link_libraries(cxx_experimental PRIVATE cxx_shared)
 else()
   target_link_libraries(cxx_experimental PRIVATE cxx_static)
 endif()
 

libcxx/src/tz.cpp

+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// For information see https://libcxx.llvm.org/DesignDocs/TimeZone.html
+
+#include <chrono>
+#include <filesystem>
+#include <fstream>
+#include <stdexcept>
+#include <string>
+
+// Contains a parser for the IANA time zone data files.
+//
+// These files can be found at https://data.iana.org/time-zones/ and are in the
+// public domain. Information regarding the input can be found at
+// https://data.iana.org/time-zones/tz-how-to.html and
+// https://man7.org/linux/man-pages/man8/zic.8.html.
+//
+// As indicated at https://howardhinnant.github.io/date/tz.html#Installation
+// For Windows another file seems to be required
+// https://raw.githubusercontent.com/unicode-org/cldr/master/common/supplemental/windowsZones.xml
+// This file seems to contain the mapping of Windows time zone name to IANA
+// time zone names.
+//
+// However this article mentions another way to do the mapping on Windows
+// https://devblogs.microsoft.com/oldnewthing/20210527-00/?p=105255
+// This requires Windows 10 Version 1903, which was released in May of 2019
+// and considered end of life in December 2020
+// https://learn.microsoft.com/en-us/lifecycle/announcements/windows-10-1903-end-of-servicing
+//
+// TODO TZDB Implement the Windows mapping in tzdb::current_zone
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+namespace chrono {
+
+// This function is weak so it can be overriden in the tests. The
+// declaration is in the test header test/support/test_tzdb.h
+_LIBCPP_WEAK string_view __libcpp_tzdb_directory() {
+#if defined(__linux__)
+  return "/usr/share/zoneinfo/";
+#else
+#  error "unknown path to the IANA Time Zone Database"
+#endif
+}
+
+[[nodiscard]] static bool __is_whitespace(int __c) { return __c == ' ' || __c == '\t'; }
+
+static void __skip_optional_whitespace(istream& __input) {
+  while (chrono::__is_whitespace(__input.peek()))
+    __input.get();
+}
+
+static void __skip_mandatory_whitespace(istream& __input) {
+  if (!chrono::__is_whitespace(__input.get()))
+    std::__throw_runtime_error("corrupt tzdb: expected whitespace");
+
+  chrono::__skip_optional_whitespace(__input);
+}
+
+static void __matches(istream& __input, char __expected) {
+  if (std::tolower(__input.get()) != __expected)
+    std::__throw_runtime_error((string("corrupt tzdb: expected character '") + __expected + '\'').c_str());
+}
+
+static void __matches(istream& __input, string_view __expected) {
+  for (auto __c : __expected)
+    if (std::tolower(__input.get()) != __c)
+      std::__throw_runtime_error((string("corrupt tzdb: expected string '") + string(__expected) + '\'').c_str());
+}
+
+[[nodiscard]] static string __parse_string(istream& __input) {
+  string __result;
+  while (true) {
+    int __c = __input.get();
+    switch (__c) {
+    case ' ':
+    case '\t':
+    case '\n':
+      __input.unget();
+      [[fallthrough]];
+    case istream::traits_type::eof():
+      if (__result.empty())
+        std::__throw_runtime_error("corrupt tzdb: expected a string");
+
+      return __result;
+
+    default:
+      __result.push_back(__c);
+    }
+  }
+}
+
+static string __parse_version(istream& __input) {
+  // The first line in tzdata.zi contains
+  //    # version YYYYw
+  // The parser expects this pattern
+  // #\s*version\s*\(.*)
+  // This part is not documented.
+  chrono::__matches(__input, '#');
+  chrono::__skip_optional_whitespace(__input);
+  chrono::__matches(__input, "version");
+  chrono::__skip_mandatory_whitespace(__input);
+  return chrono::__parse_string(__input);
+}
+
+static tzdb __make_tzdb() {
+  tzdb __result;
+
+  filesystem::path __root = chrono::__libcpp_tzdb_directory();
+  ifstream __tzdata{__root / "tzdata.zi"};
+
+  __result.version = chrono::__parse_version(__tzdata);
+  return __result;
+}
+
+//===----------------------------------------------------------------------===//
+//                           Public API
+//===----------------------------------------------------------------------===//
+
+_LIBCPP_NODISCARD_EXT _LIBCPP_AVAILABILITY_TZDB _LIBCPP_EXPORTED_FROM_ABI tzdb_list& get_tzdb_list() {
+  static tzdb_list __result{chrono::__make_tzdb()};
+  return __result;
+}
+
+_LIBCPP_AVAILABILITY_TZDB _LIBCPP_EXPORTED_FROM_ABI const tzdb& reload_tzdb() {
+  if (chrono::remote_version() == chrono::get_tzdb().version)
+    return chrono::get_tzdb();
+
+  return chrono::get_tzdb_list().__emplace_front(chrono::__make_tzdb());
+}
+
+_LIBCPP_NODISCARD_EXT _LIBCPP_AVAILABILITY_TZDB _LIBCPP_EXPORTED_FROM_ABI string remote_version() {
+  filesystem::path __root = chrono::__libcpp_tzdb_directory();
+  ifstream __tzdata{__root / "tzdata.zi"};
+  return chrono::__parse_version(__tzdata);
+}
+
+} // namespace chrono
+
+_LIBCPP_END_NAMESPACE_STD

libcxx/src/tzdb_list.cpp

+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// For information see https://libcxx.llvm.org/DesignDocs/TimeZone.html
+
+#include <chrono>
+
+#include <__mutex/unique_lock.h>
+#include <forward_list>
+
+// When threads are not available the locking is not required.
+#ifndef _LIBCPP_HAS_NO_THREADS
+#  include <shared_mutex>
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+namespace chrono {
+
+//===----------------------------------------------------------------------===//
+//                          Private API
+//===----------------------------------------------------------------------===//
+
+class tzdb_list::__impl {
+public:
+  explicit __impl(tzdb&& __tzdb) { __tzdb_.push_front(std::move(__tzdb)); }
+
+  using const_iterator = tzdb_list::const_iterator;
+
+  const tzdb& front() const noexcept {
+#ifndef _LIBCPP_HAS_NO_THREADS
+    shared_lock __lock{__mutex_};
+#endif
+    return __tzdb_.front();
+  }
+
+  const_iterator erase_after(const_iterator __p) {
+#ifndef _LIBCPP_HAS_NO_THREADS
+    unique_lock __lock{__mutex_};
+#endif
+    return __tzdb_.erase_after(__p);
+  }
+
+  tzdb& __emplace_front(tzdb&& __tzdb) {
+#ifndef _LIBCPP_HAS_NO_THREADS
+    unique_lock __lock{__mutex_};
+#endif
+    return __tzdb_.emplace_front(std::move(__tzdb));
+  }
+
+  const_iterator begin() const noexcept {
+#ifndef _LIBCPP_HAS_NO_THREADS
+    shared_lock __lock{__mutex_};
+#endif
+    return __tzdb_.begin();
+  }
+  const_iterator end() const noexcept {
+    //  forward_list<T>::end does not access the list, so no need to take a lock.
+    return __tzdb_.end();
+  }
+
+  const_iterator cbegin() const noexcept { return begin(); }
+  const_iterator cend() const noexcept { return end(); }
+
+private:
+#ifndef _LIBCPP_HAS_NO_THREADS
+  mutable shared_mutex __mutex_;
+#endif
+  forward_list<tzdb> __tzdb_;
+};
+
+//===----------------------------------------------------------------------===//
+//                           Public API
+//===----------------------------------------------------------------------===//
+
+_LIBCPP_EXPORTED_FROM_ABI tzdb_list::tzdb_list(tzdb&& __tzdb) : __impl_{new __impl(std::move(__tzdb))} {}
+
+_LIBCPP_EXPORTED_FROM_ABI tzdb_list::~tzdb_list() { delete __impl_; }
+
+_LIBCPP_NODISCARD_EXT _LIBCPP_EXPORTED_FROM_ABI const tzdb& tzdb_list::front() const noexcept {
+  return __impl_->front();
+}
+
+_LIBCPP_EXPORTED_FROM_ABI tzdb_list::const_iterator tzdb_list::erase_after(const_iterator __p) {
+  return __impl_->erase_after(__p);
+}
+
+_LIBCPP_EXPORTED_FROM_ABI tzdb& tzdb_list::__emplace_front(tzdb&& __tzdb) {
+  return __impl_->__emplace_front(std::move(__tzdb));
+}
+
+_LIBCPP_NODISCARD_EXT _LIBCPP_EXPORTED_FROM_ABI tzdb_list::const_iterator tzdb_list::begin() const noexcept {
+  return __impl_->begin();
+}
+_LIBCPP_NODISCARD_EXT _LIBCPP_EXPORTED_FROM_ABI tzdb_list::const_iterator tzdb_list::end() const noexcept {
+  return __impl_->end();
+}
+
+_LIBCPP_NODISCARD_EXT _LIBCPP_EXPORTED_FROM_ABI tzdb_list::const_iterator tzdb_list::cbegin() const noexcept {
+  return __impl_->cbegin();
+}
+_LIBCPP_NODISCARD_EXT _LIBCPP_EXPORTED_FROM_ABI tzdb_list::const_iterator tzdb_list::cend() const noexcept {
+  return __impl_->cend();
+}
+
+} // namespace chrono
+
+_LIBCPP_END_NAMESPACE_STD

libcxx/test/libcxx/diagnostics/chrono.nodiscard_extensions.compile.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// Check that format functions aren't marked [[nodiscard]] when
+// _LIBCPP_DISBALE_NODISCARD_EXT is defined
+
+// UNSUPPORTED: c++03, c++11, c++14 ,c++17
+// UNSUPPORTED: no-filesystem, no-localization, no-tzdb
+
+// XFAIL: libcpp-has-no-incomplete-tzdb
+// XFAIL: availability-tzdb-missing
+
+// <chrono>
+
+// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_NODISCARD_EXT
+
+#include <chrono>
+
+#include "test_macros.h"
+
+void test() {
+  std::chrono::tzdb_list& list = std::chrono::get_tzdb_list();
+  list.front();
+  list.begin();
+  list.end();
+  list.cbegin();
+  list.cend();
+
+  std::chrono::get_tzdb_list();
+  std::chrono::get_tzdb();
+  std::chrono::remote_version();
+}

libcxx/test/libcxx/diagnostics/chrono.nodiscard_extensions.verify.cpp

+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// Check that format functions are marked [[nodiscard]] as a conforming extension
+
+// UNSUPPORTED: c++03, c++11, c++14 ,c++17
+// UNSUPPORTED: no-filesystem, no-localization, no-tzdb
+
+// XFAIL: libcpp-has-no-incomplete-tzdb
+// XFAIL: availability-tzdb-missing
+
+// <chrono>
+
+#include <chrono>
+
+#include "test_macros.h"
+
+void test() {
+  std::chrono::tzdb_list& list = std::chrono::get_tzdb_list();
+  list.front();  // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
+  list.begin();  // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
+  list.end();    // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
+  list.cbegin(); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
+  list.cend();   // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
+
+  namespace crno = std::chrono;
+  crno::get_tzdb_list();  // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
+  crno::get_tzdb();       // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
+  crno::remote_version(); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
+}

libcxx/test/libcxx/experimental/fexperimental-library.compile.pass.cpp

 
 #ifdef _LIBCPP_HAS_NO_INCOMPLETE_PSTL
 #  error "-fexperimental-library should enable the PSTL"
 #endif
 
 #ifdef _LIBCPP_HAS_NO_EXPERIMENTAL_STOP_TOKEN
 #  error "-fexperimental-library should enable the stop_token"
 #endif
+
+#ifdef _LIBCPP_HAS_NO_INCOMPLETE_TZDB
+#  error "-fexperimental-library should enable the chrono TZDB"
+#endif

libcxx/test/libcxx/time/time.zone/time.zone.db/time.zone.db.list/erase_after.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: no-filesystem, no-localization, no-tzdb
+
+// XFAIL: libcpp-has-no-incomplete-tzdb
+// XFAIL: availability-tzdb-missing
+
+// <chrono>
+//
+// class tzdb_list;
+//
+// const_iterator erase_after(const_iterator p);
+
+#include <cassert>
+#include <chrono>
+#include <fstream>
+#include <iterator>
+
+#include "filesystem_test_helper.h"
+#include "test_macros.h"
+#include "test_tzdb.h"
+
+scoped_test_env env;
+[[maybe_unused]] const std::filesystem::path dir = env.create_dir("zoneinfo");
+const std::filesystem::path data                 = env.create_file("zoneinfo/tzdata.zi");
+
+std::string_view std::chrono::__libcpp_tzdb_directory() {
+  static std::string result = dir.string();
+  return result;
+}
+
+static void write(std::string_view input) { std::ofstream{data}.write(input.data(), input.size()); }
+
+int main(int, const char**) {
+  write("# version 1");
+  std::chrono::tzdb_list& list = std::chrono::get_tzdb_list(); // [1]
+
+  write("# version 2");
+  std::chrono::reload_tzdb(); // [2, 1]
+
+  assert(std::distance(list.begin(), list.end()) == 2);
+  assert(list.front().version == "2");
+
+  list.erase_after(list.begin()); // [2]
+  assert(std::distance(list.begin(), list.end()) == 1);
+  assert(list.front().version == "2");
+
+  write("# version 3");
+  std::chrono::reload_tzdb(); // [3, 2]
+  assert(std::distance(list.begin(), list.end()) == 2);
+
+  write("# version 4");
+  std::chrono::reload_tzdb(); // [4, 3, 2]
+  assert(std::distance(list.begin(), list.end()) == 3);
+  assert(list.front().version == "4");
+
+  std::chrono::tzdb_list::const_iterator it = ++list.begin();
+  assert(it->version == "3");
+
+  list.erase_after(it); // [4, 3]
+  assert(std::distance(list.begin(), list.end()) == 2);
+  assert(list.front().version == "4");
+  assert(it->version == "3");
+}

libcxx/test/libcxx/time/time.zone/time.zone.db/time.zone.db.remote/reload_tzdb.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: no-filesystem, no-localization, no-tzdb
+
+// XFAIL: libcpp-has-no-incomplete-tzdb
+// XFAIL: availability-tzdb-missing
+
+// <chrono>
+
+// const tzdb& reload_tzdb();
+
+#include <cassert>
+#include <chrono>
+#include <fstream>
+#include <iterator>
+
+#include "filesystem_test_helper.h"
+#include "test_macros.h"
+#include "test_tzdb.h"
+
+scoped_test_env env;
+[[maybe_unused]] const std::filesystem::path dir = env.create_dir("zoneinfo");
+const std::filesystem::path data                 = env.create_file("zoneinfo/tzdata.zi");
+
+std::string_view std::chrono::__libcpp_tzdb_directory() {
+  static std::string result = dir.string();
+  return result;
+}
+
+static void write(std::string_view input) { std::ofstream{data}.write(input.data(), input.size()); }
+
+int main(int, const char**) {
+  write("# version old_version");
+  const std::chrono::tzdb_list& list = std::chrono::get_tzdb_list();
+  std::string version                = "new_version";
+
+  assert(list.front().version == "old_version");
+  assert(std::distance(list.begin(), list.end()) == 1);
+  assert(std::distance(list.cbegin(), list.cend()) == 1);
+
+  write("# version new_version");
+  assert(std::chrono::remote_version() == version);
+
+  std::chrono::reload_tzdb();
+
+  assert(std::distance(list.begin(), list.end()) == 2);
+  assert(std::distance(list.cbegin(), list.cend()) == 2);
+  assert(list.front().version == version);
+
+  return 0;
+}

libcxx/test/libcxx/time/time.zone/time.zone.db/version.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: no-filesystem, no-localization, no-tzdb
+
+// XFAIL: libcpp-has-no-incomplete-tzdb
+// XFAIL: availability-tzdb-missing
+
+// <chrono>
+
+// Tests the IANA database version parsing.
+// This is not part of the public tzdb interface.
+
+#include <chrono>
+#include <fstream>
+#include <string>
+#include <string_view>
+
+#include "assert_macros.h"
+#include "concat_macros.h"
+#include "filesystem_test_helper.h"
+#include "test_tzdb.h"
+
+scoped_test_env env;
+[[maybe_unused]] const std::filesystem::path dir = env.create_dir("zoneinfo");
+const std::filesystem::path data                 = env.create_file("zoneinfo/tzdata.zi");
+
+std::string_view std::chrono::__libcpp_tzdb_directory() {
+  static std::string result = dir.string();
+  return result;
+}
+
+static void test(std::string_view input, std::string_view expected) {
+  std::ofstream{data}.write(input.data(), input.size());
+  std::string version = std::chrono::remote_version();
+
+  TEST_REQUIRE(
+      version == expected,
+      TEST_WRITE_CONCATENATED(
+          "\nInput            ", input, "\nExpected version ", expected, "\nActual version   ", version, '\n'));
+}
+
+static void test_exception(std::string_view input, [[maybe_unused]] std::string_view what) {
+  std::ofstream{data}.write(input.data(), input.size());
+
+  TEST_VALIDATE_EXCEPTION(
+      std::runtime_error,
+      [&]([[maybe_unused]] const std::runtime_error& e) {
+        TEST_LIBCPP_REQUIRE(
+            e.what() == what,
+            TEST_WRITE_CONCATENATED("\nExpected exception ", what, "\nActual exception   ", e.what(), '\n'));
+      },
+      TEST_IGNORE_NODISCARD std::chrono::remote_version());
+}
+
+int main(int, const char**) {
+  test_exception("", "corrupt tzdb: expected character '#'");
+  test_exception("#version", "corrupt tzdb: expected whitespace");
+  test("#version     \t                      ABCD", "ABCD");
+  test("#Version     \t                      ABCD", "ABCD");
+  test("#vErsion     \t                      ABCD", "ABCD");
+  test("#verSion     \t                      ABCD", "ABCD");
+  test("#VERSION     \t                      ABCD", "ABCD");
+  test("#          \t   version      \t      2023a", "2023a");
+
+  return 0;
+}

libcxx/test/libcxx/transitive_includes.gen.py

for header in public_headers:
     # Escape slashes for the awk command below
     escaped_header = header.replace('/', '\/')
 
     print(f"""\
 //--- {header}.sh.cpp
 {lit_header_restrictions.get(header, '')}
 
 // TODO: Fix this test to make it work with localization or wide characters disabled
-// UNSUPPORTED{BLOCKLIT}: no-localization, no-wide-characters
+// UNSUPPORTED{BLOCKLIT}: no-localization, no-wide-characters, no-threads, no-filesystem, libcpp-has-no-incomplete-tzdb, no-tzdb
 
 // When built with modules, this test doesn't work because --trace-includes doesn't
 // report the stack of includes correctly.
 // UNSUPPORTED{BLOCKLIT}: modules-build
 
 // This test uses --trace-includes, which is not supported by GCC.
 // UNSUPPORTED{BLOCKLIT}: gcc
 

libcxx/test/libcxx/transitive_includes/cxx03.csv

 charconv type_traits
 chrono bit
 chrono compare
 chrono concepts
 chrono cstddef
 chrono cstdint
 chrono cstring
 chrono ctime
+chrono forward_list
 chrono limits
 chrono ratio
 chrono stdexcept
+chrono string
 chrono string_view
 chrono tuple
 chrono type_traits
 chrono version
 cinttypes cstdint
 cmath limits
 cmath type_traits
 cmath version

libcxx/test/libcxx/transitive_includes/cxx11.csv

 charconv type_traits
 chrono bit
 chrono compare
 chrono concepts
 chrono cstddef
 chrono cstdint
 chrono cstring
 chrono ctime
+chrono forward_list
 chrono limits
 chrono ratio
 chrono stdexcept
+chrono string
 chrono string_view
 chrono tuple
 chrono type_traits
 chrono version
 cinttypes cstdint
 cmath limits
 cmath type_traits
 cmath version

libcxx/test/libcxx/transitive_includes/cxx14.csv

 charconv type_traits
 chrono bit
 chrono compare
 chrono concepts
 chrono cstddef
 chrono cstdint
 chrono cstring
 chrono ctime
+chrono forward_list
 chrono limits
 chrono ratio
 chrono stdexcept
+chrono string
 chrono string_view
 chrono tuple
 chrono type_traits
 chrono version
 cinttypes cstdint
 cmath limits
 cmath type_traits
 cmath version

libcxx/test/libcxx/transitive_includes/cxx17.csv

 charconv type_traits
 chrono bit
 chrono compare
 chrono concepts
 chrono cstddef
 chrono cstdint
 chrono cstring
 chrono ctime
+chrono forward_list
 chrono limits
 chrono ratio
 chrono stdexcept
+chrono string
 chrono string_view
 chrono tuple
 chrono type_traits
 chrono version
 cinttypes cstdint
 cmath limits
 cmath type_traits
 cmath version

libcxx/test/libcxx/transitive_includes/cxx20.csv

 chrono charconv
 chrono cmath
 chrono compare
 chrono concepts
 chrono cstddef
 chrono cstdint
 chrono cstring
 chrono ctime
+chrono forward_list
 chrono limits
 chrono locale
 chrono optional
 chrono ostream
 chrono ratio
 chrono sstream
 chrono stdexcept
 chrono string

libcxx/test/libcxx/transitive_includes/cxx23.csv

 charconv limits
 charconv new
 chrono array
 chrono cmath
 chrono compare
 chrono cstddef
 chrono cstdint
 chrono ctime
+chrono forward_list
 chrono initializer_list
 chrono limits
 chrono locale
 chrono new
 chrono optional
 chrono ostream
 chrono ratio
 chrono sstream

libcxx/test/libcxx/transitive_includes/cxx26.csv

 charconv limits
 charconv new
 chrono array
 chrono cmath
 chrono compare
 chrono cstddef
 chrono cstdint
 chrono ctime
+chrono forward_list
 chrono initializer_list
 chrono limits
 chrono locale
 chrono new
 chrono optional
 chrono ostream
 chrono ratio
 chrono sstream

libcxx/test/std/time/time.zone/time.zone.db/time.zone.db.access/get_tzdb.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: no-filesystem, no-localization, no-tzdb
+
+// XFAIL: libcpp-has-no-incomplete-tzdb
+// XFAIL: availability-tzdb-missing
+
+// <chrono>
+
+// const tzdb& get_tzdb();
+
+#include <chrono>
+
+#include <cassert>
+
+#include "test_macros.h"
+
+int main(int, const char**) {
+  const std::chrono::tzdb& db = std::chrono::get_tzdb();
+
+  assert(!db.version.empty());
+
+  return 0;
+}

libcxx/test/std/time/time.zone/time.zone.db/time.zone.db.access/get_tzdb_list.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: no-filesystem, no-localization, no-tzdb
+
+// XFAIL: libcpp-has-no-incomplete-tzdb
+// XFAIL: availability-tzdb-missing
+
+// <chrono>
+
+// const tzdb& get_tzdb_list();
+
+#include <chrono>
+
+#include <iterator>
+#include <cassert>
+
+#include "test_macros.h"
+
+int main(int, const char**) {
+  const std::chrono::tzdb_list& list = std::chrono::get_tzdb_list();
+
+  assert(!list.front().version.empty());
+  assert(std::distance(list.begin(), list.end()) == 1);
+  assert(std::distance(list.cbegin(), list.cend()) == 1);
+
+  return 0;
+}

libcxx/test/std/time/time.zone/time.zone.db/time.zone.db.list/erase_after.compile.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: no-filesystem, no-localization, no-tzdb
+
+// XFAIL: libcpp-has-no-incomplete-tzdb
+// XFAIL: availability-tzdb-missing
+
+// <chrono>
+//
+// class tzdb_list;
+//
+// const_iterator erase_after(const_iterator p);
+//
+// [time.zone.db.list]/5
+//   Preconditions: The iterator following p is dereferenceable.
+//
+// Since there is no Standard way to create a second entry it's not
+// possible to fullfill this precondition. This is tested in a libc++
+// specific test.
+
+#include <chrono>
+#include <concepts>
+
+std::chrono::tzdb_list& list = std::chrono::get_tzdb_list();
+static_assert(std::same_as<decltype(list.erase_after(std::chrono::tzdb_list::const_iterator{})),
+                           std::chrono::tzdb_list::const_iterator>);

libcxx/test/std/time/time.zone/time.zone.db/time.zone.db.list/front.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: no-filesystem, no-localization, no-tzdb
+
+// XFAIL: libcpp-has-no-incomplete-tzdb
+// XFAIL: availability-tzdb-missing
+
+// <chrono>
+//
+// class tzdb_list;
+//
+// const tzdb& front() const noexcept;
+
+#include <chrono>
+
+int main(int, char**) {
+  const std::chrono::tzdb_list& list          = std::chrono::get_tzdb_list();
+  [[maybe_unused]] const std::chrono::tzdb& _ = list.front();
+  static_assert(noexcept(list.front()));
+
+  return 0;
+}

libcxx/test/std/time/time.zone/time.zone.db/time.zone.db.list/iterators.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: no-filesystem, no-localization, no-tzdb
+
+// XFAIL: libcpp-has-no-incomplete-tzdb
+// XFAIL: availability-tzdb-missing
+
+// <chrono>
+//
+// class tzdb_list;
+//
+// const_iterator begin() const noexcept;
+// const_iterator end()   const noexcept;
+//
+// const_iterator cbegin() const noexcept;
+// const_iterator cend()   const noexcept;
+
+#include <chrono>
+#include <iterator>
+#include <cassert>
+
+int main(int, char**) {
+  const std::chrono::tzdb_list& list = std::chrono::get_tzdb_list();
+  using it                           = std::chrono::tzdb_list::const_iterator;
+
+  static_assert(noexcept(list.begin()));
+  static_assert(noexcept(list.end()));
+  static_assert(noexcept(list.cbegin()));
+  static_assert(noexcept(list.cend()));
+
+  std::same_as<it> auto begin = list.begin();
+  std::same_as<it> auto end   = list.end();
+  assert(std::distance(begin, end) == 1);
+
+  std::same_as<it> auto cbegin = list.cbegin();
+  assert(begin == cbegin);
+
+  std::same_as<it> auto cend = list.cend();
+  assert(end == cend);
+
+  return 0;
+}

libcxx/test/std/time/time.zone/time.zone.db/time.zone.db.list/types.compile.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: no-filesystem, no-localization, no-tzdb
+
+// XFAIL: libcpp-has-no-incomplete-tzdb
+// XFAIL: availability-tzdb-missing
+
+// <chrono>
+
+// class tzdb_list {
+//  public:
+//    tzdb_list(const tzdb_list&) = delete;
+//    tzdb_list& operator=(const tzdb_list&) = delete;
+//
+//    ...
+//
+//  };
+//
+// [time.zone.db.list]/1
+//   The tzdb_list database is a singleton; the unique object of type
+//   tzdb_list can be accessed via the get_tzdb_list() function.
+////
+// This means the class may not have a default constructor.
+
+#include <chrono>
+#include <concepts>
+
+static_assert(!std::copyable<std::chrono::tzdb_list>);
+static_assert(!std::movable<std::chrono::tzdb_list>);
+static_assert(!std::default_initializable<std::chrono::tzdb_list>);

libcxx/test/std/time/time.zone/time.zone.db/time.zone.db.remote/reload_tzdb.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: no-filesystem, no-localization, no-tzdb
+
+// XFAIL: libcpp-has-no-incomplete-tzdb
+// XFAIL: availability-tzdb-missing
+
+// <chrono>
+
+// Note there is no Standard way to change the remote database used.
+// That is tested in
+//   test/libcxx/time/time.zone/time.zone.db/time.zone.db.remote/reload_tzdb.pass.cpp
+
+// const tzdb& reload_tzdb();
+
+#include <cassert>
+#include <chrono>
+#include <iterator>
+
+#include "test_macros.h"
+
+int main(int, const char**) {
+  const std::chrono::tzdb_list& list = std::chrono::get_tzdb_list();
+  std::string version                = list.front().version;
+  assert(!version.empty());
+
+  assert(std::distance(list.begin(), list.end()) == 1);
+  assert(std::distance(list.cbegin(), list.cend()) == 1);
+  assert(std::chrono::remote_version() == version);
+
+  std::chrono::reload_tzdb();
+
+  assert(std::distance(list.begin(), list.end()) == 1);
+  assert(std::distance(list.cbegin(), list.cend()) == 1);
+  assert(std::chrono::remote_version() == version);
+
+  return 0;
+}

libcxx/test/std/time/time.zone/time.zone.db/time.zone.db.remote/remote_version.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: no-filesystem, no-localization, no-tzdb
+
+// XFAIL: libcpp-has-no-incomplete-tzdb
+// XFAIL: availability-tzdb-missing
+
+// <chrono>
+
+// const string remote_version();
+
+#include <chrono>
+
+#include <cassert>
+
+#include "test_macros.h"
+
+int main(int, const char**) {
+  std::string version = std::chrono::remote_version();
+  assert(!version.empty());
+
+  assert(version == std::chrono::get_tzdb().version);
+  assert(version == std::chrono::get_tzdb_list().front().version);
+
+  return 0;
+}

libcxx/test/std/time/time.zone/time.zone.db/time.zone.db.tzdb/tzdb.members.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: no-filesystem, no-localization, no-tzdb
+
+// XFAIL: libcpp-has-no-incomplete-tzdb
+// XFAIL: availability-tzdb-missing
+
+// <chrono>
+
+//  struct tzdb {
+//    string                 version;
+//    vector<time_zone>      zones;
+//    vector<time_zone_link> links;
+//    vector<leap_second>    leap_seconds;
+//
+//    ...
+//  };
+
+#include <chrono>
+#include <cassert>
+#include <concepts>
+#include <string>
+
+#include "assert_macros.h"
+
+int main(int, const char**) {
+  std::chrono::tzdb tzdb;
+
+  static_assert(std::same_as<decltype(tzdb.version), std::string>);
+  tzdb.version = "version";
+  assert(tzdb.version == "version");
+
+  // TODO TZDB add the other data members
+
+  return 0;
+}

libcxx/test/support/test_tzdb.h

+// -*- 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 SUPPORT_TEST_TZDB_H
+#define SUPPORT_TEST_TZDB_H
+
+#include <string_view>
+
+#if defined(_LIBCPP_VERSION)
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+namespace chrono {
+
+// This function is marked as "overridable" in libc++ only for the test
+// suite. Therefore the declaration is not in <chrono>.
+_LIBCPP_AVAILABILITY_TZDB _LIBCPP_OVERRIDABLE_FUNC_VIS string_view __libcpp_tzdb_directory();
+
+} // namespace chrono
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif
+
+#endif // SUPPORT_TEST_TZDB_H

libcxx/utils/ci/buildkite-pipeline.yml

- label: "No wide characters"
         queue: "libcxx-builders"
         os: "linux"
       retry:
         automatic:
           - exit_status: -1  # Agent was lost
             limit: 2
       timeout_in_minutes: 120
 
+    - label: "No time zone database"
+      command: "libcxx/utils/ci/run-buildbot generic-no-tzdb"
+      artifact_paths:
+        - "**/test-results.xml"
+        - "**/*.abilist"
+      env:
+          CC: "clang-${LLVM_HEAD_VERSION}"
+          CXX: "clang++-${LLVM_HEAD_VERSION}"
+          ENABLE_CLANG_TIDY: "On"
+      agents:
+        queue: "libcxx-builders"
+        os: "linux"
+      retry:
+        automatic:
+          - exit_status: -1  # Agent was lost
+            limit: 2
+      timeout_in_minutes: 120
+
     - label: "No experimental features"
       command: "libcxx/utils/ci/run-buildbot generic-no-experimental"
       artifact_paths:
         - "**/test-results.xml"
         - "**/*.abilist"
       env:
           CC: "clang-${LLVM_HEAD_VERSION}"
           CXX: "clang++-${LLVM_HEAD_VERSION}"

libcxx/utils/ci/run-buildbot

generic-no-unicode)
     generate-cmake -C "${MONOREPO_ROOT}/libcxx/cmake/caches/Generic-no-unicode.cmake"
     check-runtimes
 ;;
 generic-no-wide-characters)
     clean
     generate-cmake -C "${MONOREPO_ROOT}/libcxx/cmake/caches/Generic-no-wide-characters.cmake"
     check-runtimes
 ;;
+generic-no-tzdb)
+    clean
+    generate-cmake -C "${MONOREPO_ROOT}/libcxx/cmake/caches/Generic-no-tzdb.cmake"
+    check-runtimes
+;;
 generic-no-experimental)
     clean
     generate-cmake -C "${MONOREPO_ROOT}/libcxx/cmake/caches/Generic-no-experimental.cmake"
     check-runtimes
     check-abi-list
 ;;
 generic-no-exceptions)
     clean

libcxx/utils/libcxx/test/features.py

macros = {
     "_LIBCPP_HAS_THREAD_API_EXTERNAL": "libcpp-has-thread-api-external",
     "_LIBCPP_HAS_THREAD_API_PTHREAD": "libcpp-has-thread-api-pthread",
     "_LIBCPP_NO_VCRUNTIME": "libcpp-no-vcruntime",
     "_LIBCPP_ABI_VERSION": "libcpp-abi-version",
     "_LIBCPP_HAS_NO_FILESYSTEM": "no-filesystem",
     "_LIBCPP_HAS_NO_RANDOM_DEVICE": "no-random-device",
     "_LIBCPP_HAS_NO_LOCALIZATION": "no-localization",
     "_LIBCPP_HAS_NO_WIDE_CHARACTERS": "no-wide-characters",
+    "_LIBCPP_HAS_NO_TIME_ZONE_DATABASE": "no-tzdb",
     "_LIBCPP_HAS_NO_UNICODE": "libcpp-has-no-unicode",
     "_LIBCPP_HAS_NO_STD_MODULES":  "libcpp-has-no-std-modules",
     "_LIBCPP_PSTL_CPU_BACKEND_LIBDISPATCH": "libcpp-pstl-cpu-backend-libdispatch",
 }
 for macro, feature in macros.items():
     DEFAULT_FEATURES.append(
         Feature(
             name=lambda cfg, m=macro, f=feature: f + ("={}".format(compilerMacros(cfg)[m]) if compilerMacros(cfg)[m] else ""),
DEFAULT_FEATURES += [
     # not other forms of aligned allocation.
     Feature(
         name="availability-aligned_allocation-missing",
         when=lambda cfg: BooleanExpression.evaluate(
             "stdlib=apple-libc++ && target={{.+}}-apple-macosx10.{{(9|10|11|12)(.0)?}}",
             cfg.available_features,
         ),
     ),
+    # Tests that require time zone database support in the built library
+    Feature(
+        name="availability-tzdb-missing",
+        when=lambda cfg: BooleanExpression.evaluate(
+            # TODO(ldionne) Please provide the correct value.
+            "(stdlib=apple-libc++ && target={{.+}}-apple-macosx{{(10.9|10.10|10.11|10.12|10.13|10.14|10.15|11.0|12.0|13.0)(.0)?}})",
+            cfg.available_features,
+        ),
+    ),
     # Tests that require 64-bit architecture
     Feature(
         name="32-bit-pointer",
         when=lambda cfg: sourceBuilds(
             cfg,
             """
             int main(int, char**) {
               static_assert(sizeof(void *) == 4);
             }
           """,
         ),
     ),
 ]

libcxx/utils/libcxx/test/params.py

Parameter(
             AddFeature("c++experimental"),
             PrependLinkFlag(lambda cfg: "-llibc++experimental" if _isMSVC(cfg) else "-lc++experimental"),
             AddCompileFlag("-D_LIBCPP_ENABLE_EXPERIMENTAL"),
         ]
         if experimental
         else [
             AddFeature("libcpp-has-no-incomplete-pstl"),
             AddFeature("libcpp-has-no-experimental-stop_token"),
+            AddFeature("libcpp-has-no-incomplete-tzdb"),
         ],
     ),
     Parameter(
         name="long_tests",
         choices=[True, False],
         type=bool,
         default=True,
         help="Whether to enable tests that take longer to run. This can be useful when running on a very slow device.",