karellen-llvm-core 22.1.0rc1.post26__py3-none-manylinux_2_28_x86_64.whl

karellen_llvm_core-22.1.0rc1.post26.data/data/share/libc++/v1/std/atomic.inc

@@ -0,0 +1,141 @@
+// -*- 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
+//
+//===----------------------------------------------------------------------===//
+
+export namespace std {
+
+  // [atomics.order], order and consistency
+  using std::memory_order _LIBCPP_USING_IF_EXISTS;
+  using std::memory_order_acq_rel _LIBCPP_USING_IF_EXISTS;
+  using std::memory_order_acquire _LIBCPP_USING_IF_EXISTS;
+  using std::memory_order_consume _LIBCPP_USING_IF_EXISTS;
+  using std::memory_order_relaxed _LIBCPP_USING_IF_EXISTS;
+  using std::memory_order_release _LIBCPP_USING_IF_EXISTS;
+  using std::memory_order_seq_cst _LIBCPP_USING_IF_EXISTS;
+
+  using std::kill_dependency _LIBCPP_USING_IF_EXISTS;
+
+  // [atomics.ref.generic], class template atomic_ref
+  // [atomics.ref.pointer], partial specialization for pointers
+  using std::atomic_ref _LIBCPP_USING_IF_EXISTS;
+
+  // [atomics.types.generic], class template atomic
+  using std::atomic _LIBCPP_USING_IF_EXISTS;
+
+  // [atomics.nonmembers], non-member functions
+  using std::atomic_compare_exchange_strong _LIBCPP_USING_IF_EXISTS;
+  using std::atomic_compare_exchange_strong_explicit _LIBCPP_USING_IF_EXISTS;
+  using std::atomic_compare_exchange_weak _LIBCPP_USING_IF_EXISTS;
+  using std::atomic_compare_exchange_weak_explicit _LIBCPP_USING_IF_EXISTS;
+  using std::atomic_exchange _LIBCPP_USING_IF_EXISTS;
+  using std::atomic_exchange_explicit _LIBCPP_USING_IF_EXISTS;
+  using std::atomic_is_lock_free _LIBCPP_USING_IF_EXISTS;
+  using std::atomic_load _LIBCPP_USING_IF_EXISTS;
+  using std::atomic_load_explicit _LIBCPP_USING_IF_EXISTS;
+  using std::atomic_store _LIBCPP_USING_IF_EXISTS;
+  using std::atomic_store_explicit _LIBCPP_USING_IF_EXISTS;
+
+  using std::atomic_fetch_add _LIBCPP_USING_IF_EXISTS;
+  using std::atomic_fetch_add_explicit _LIBCPP_USING_IF_EXISTS;
+  using std::atomic_fetch_and _LIBCPP_USING_IF_EXISTS;
+  using std::atomic_fetch_and_explicit _LIBCPP_USING_IF_EXISTS;
+  using std::atomic_fetch_or _LIBCPP_USING_IF_EXISTS;
+  using std::atomic_fetch_or_explicit _LIBCPP_USING_IF_EXISTS;
+  using std::atomic_fetch_sub _LIBCPP_USING_IF_EXISTS;
+  using std::atomic_fetch_sub_explicit _LIBCPP_USING_IF_EXISTS;
+  using std::atomic_fetch_xor _LIBCPP_USING_IF_EXISTS;
+  using std::atomic_fetch_xor_explicit _LIBCPP_USING_IF_EXISTS;
+  using std::atomic_notify_all _LIBCPP_USING_IF_EXISTS;
+  using std::atomic_notify_one _LIBCPP_USING_IF_EXISTS;
+  using std::atomic_wait _LIBCPP_USING_IF_EXISTS;
+  using std::atomic_wait_explicit _LIBCPP_USING_IF_EXISTS;
+
+  // [atomics.alias], type aliases
+  using std::atomic_bool _LIBCPP_USING_IF_EXISTS;
+  using std::atomic_char _LIBCPP_USING_IF_EXISTS;
+  using std::atomic_char16_t _LIBCPP_USING_IF_EXISTS;
+  using std::atomic_char32_t _LIBCPP_USING_IF_EXISTS;
+#if _LIBCPP_HAS_CHAR8_T
+  using std::atomic_char8_t _LIBCPP_USING_IF_EXISTS;
+#endif
+  using std::atomic_int _LIBCPP_USING_IF_EXISTS;
+  using std::atomic_llong _LIBCPP_USING_IF_EXISTS;
+  using std::atomic_long _LIBCPP_USING_IF_EXISTS;
+  using std::atomic_schar _LIBCPP_USING_IF_EXISTS;
+  using std::atomic_short _LIBCPP_USING_IF_EXISTS;
+  using std::atomic_uchar _LIBCPP_USING_IF_EXISTS;
+  using std::atomic_uint _LIBCPP_USING_IF_EXISTS;
+  using std::atomic_ullong _LIBCPP_USING_IF_EXISTS;
+  using std::atomic_ulong _LIBCPP_USING_IF_EXISTS;
+  using std::atomic_ushort _LIBCPP_USING_IF_EXISTS;
+#if _LIBCPP_HAS_WIDE_CHARACTERS
+  using std::atomic_wchar_t _LIBCPP_USING_IF_EXISTS;
+#endif
+
+  using std::atomic_int16_t _LIBCPP_USING_IF_EXISTS;
+  using std::atomic_int32_t _LIBCPP_USING_IF_EXISTS;
+  using std::atomic_int64_t _LIBCPP_USING_IF_EXISTS;
+  using std::atomic_int8_t _LIBCPP_USING_IF_EXISTS;
+  using std::atomic_uint16_t _LIBCPP_USING_IF_EXISTS;
+  using std::atomic_uint32_t _LIBCPP_USING_IF_EXISTS;
+  using std::atomic_uint64_t _LIBCPP_USING_IF_EXISTS;
+  using std::atomic_uint8_t _LIBCPP_USING_IF_EXISTS;
+
+  using std::atomic_int_least16_t _LIBCPP_USING_IF_EXISTS;
+  using std::atomic_int_least32_t _LIBCPP_USING_IF_EXISTS;
+  using std::atomic_int_least64_t _LIBCPP_USING_IF_EXISTS;
+  using std::atomic_int_least8_t _LIBCPP_USING_IF_EXISTS;
+  using std::atomic_uint_least16_t _LIBCPP_USING_IF_EXISTS;
+  using std::atomic_uint_least32_t _LIBCPP_USING_IF_EXISTS;
+  using std::atomic_uint_least64_t _LIBCPP_USING_IF_EXISTS;
+  using std::atomic_uint_least8_t _LIBCPP_USING_IF_EXISTS;
+
+  using std::atomic_int_fast16_t _LIBCPP_USING_IF_EXISTS;
+  using std::atomic_int_fast32_t _LIBCPP_USING_IF_EXISTS;
+  using std::atomic_int_fast64_t _LIBCPP_USING_IF_EXISTS;
+  using std::atomic_int_fast8_t _LIBCPP_USING_IF_EXISTS;
+  using std::atomic_uint_fast16_t _LIBCPP_USING_IF_EXISTS;
+  using std::atomic_uint_fast32_t _LIBCPP_USING_IF_EXISTS;
+  using std::atomic_uint_fast64_t _LIBCPP_USING_IF_EXISTS;
+  using std::atomic_uint_fast8_t _LIBCPP_USING_IF_EXISTS;
+
+  using std::atomic_intmax_t _LIBCPP_USING_IF_EXISTS;
+  using std::atomic_intptr_t _LIBCPP_USING_IF_EXISTS;
+  using std::atomic_ptrdiff_t _LIBCPP_USING_IF_EXISTS;
+  using std::atomic_size_t _LIBCPP_USING_IF_EXISTS;
+  using std::atomic_uintmax_t _LIBCPP_USING_IF_EXISTS;
+  using std::atomic_uintptr_t _LIBCPP_USING_IF_EXISTS;
+
+#ifndef _LIBCPP_NO_LOCK_FREE_TYPES
+  using std::atomic_signed_lock_free _LIBCPP_USING_IF_EXISTS;
+  using std::atomic_unsigned_lock_free _LIBCPP_USING_IF_EXISTS;
+#endif
+
+  // [atomics.flag], flag type and operations
+  using std::atomic_flag _LIBCPP_USING_IF_EXISTS;
+
+  using std::atomic_flag_clear _LIBCPP_USING_IF_EXISTS;
+  using std::atomic_flag_clear_explicit _LIBCPP_USING_IF_EXISTS;
+  using std::atomic_flag_test _LIBCPP_USING_IF_EXISTS;
+  using std::atomic_flag_test_and_set _LIBCPP_USING_IF_EXISTS;
+  using std::atomic_flag_test_and_set_explicit _LIBCPP_USING_IF_EXISTS;
+  using std::atomic_flag_test_explicit _LIBCPP_USING_IF_EXISTS;
+
+  using std::atomic_flag_notify_all _LIBCPP_USING_IF_EXISTS;
+  using std::atomic_flag_notify_one _LIBCPP_USING_IF_EXISTS;
+  using std::atomic_flag_wait _LIBCPP_USING_IF_EXISTS;
+  using std::atomic_flag_wait_explicit _LIBCPP_USING_IF_EXISTS;
+
+  // [atomics.fences], fences
+  using std::atomic_signal_fence _LIBCPP_USING_IF_EXISTS;
+  using std::atomic_thread_fence _LIBCPP_USING_IF_EXISTS;
+
+  // [depr.atomics.nonmembers]
+  using std::atomic_init _LIBCPP_USING_IF_EXISTS;
+
+} // namespace std

karellen_llvm_core-22.1.0rc1.post26.data/data/share/libc++/v1/std/barrier.inc

@@ -0,0 +1,14 @@
+// -*- 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
+//
+//===----------------------------------------------------------------------===//
+
+export namespace std {
+#if _LIBCPP_HAS_THREADS
+  using std::barrier;
+#endif
+} // namespace std

karellen_llvm_core-22.1.0rc1.post26.data/data/share/libc++/v1/std/bit.inc

@@ -0,0 +1,38 @@
+// -*- 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
+//
+//===----------------------------------------------------------------------===//
+
+export namespace std {
+  // [bit.cast], bit_cast
+  using std::bit_cast;
+
+#if _LIBCPP_STD_VER >= 23
+  // [bit.byteswap], byteswap
+  using std::byteswap;
+#endif
+
+  // [bit.pow.two], integral powers of 2
+  using std::bit_ceil;
+  using std::bit_floor;
+  using std::bit_width;
+  using std::has_single_bit;
+
+  // [bit.rotate], rotating
+  using std::rotl;
+  using std::rotr;
+
+  // [bit.count], counting
+  using std::countl_one;
+  using std::countl_zero;
+  using std::countr_one;
+  using std::countr_zero;
+  using std::popcount;
+
+  // [bit.endian], endian
+  using std::endian;
+} // namespace std

karellen_llvm_core-22.1.0rc1.post26.data/data/share/libc++/v1/std/bitset.inc

@@ -0,0 +1,23 @@
+// -*- 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
+//
+//===----------------------------------------------------------------------===//
+
+export namespace std {
+  using std::bitset;
+
+  // [bitset.operators], bitset operators
+  using std::operator&;
+  using std::operator|;
+  using std::operator^;
+  using std::operator>>;
+  using std::operator<<;
+
+  // [bitset.hash], hash support
+  using std::hash;
+
+} // namespace std

karellen_llvm_core-22.1.0rc1.post26.data/data/share/libc++/v1/std/cassert.inc

@@ -0,0 +1,12 @@
+// -*- 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
+//
+//===----------------------------------------------------------------------===//
+
+export namespace std {
+  // This module exports nothing.
+} // namespace std

karellen_llvm_core-22.1.0rc1.post26.data/data/share/libc++/v1/std/cctype.inc

@@ -0,0 +1,25 @@
+// -*- 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
+//
+//===----------------------------------------------------------------------===//
+
+export namespace std {
+  using std::isalnum _LIBCPP_USING_IF_EXISTS;
+  using std::isalpha _LIBCPP_USING_IF_EXISTS;
+  using std::isblank _LIBCPP_USING_IF_EXISTS;
+  using std::iscntrl _LIBCPP_USING_IF_EXISTS;
+  using std::isdigit _LIBCPP_USING_IF_EXISTS;
+  using std::isgraph _LIBCPP_USING_IF_EXISTS;
+  using std::islower _LIBCPP_USING_IF_EXISTS;
+  using std::isprint _LIBCPP_USING_IF_EXISTS;
+  using std::ispunct _LIBCPP_USING_IF_EXISTS;
+  using std::isspace _LIBCPP_USING_IF_EXISTS;
+  using std::isupper _LIBCPP_USING_IF_EXISTS;
+  using std::isxdigit _LIBCPP_USING_IF_EXISTS;
+  using std::tolower _LIBCPP_USING_IF_EXISTS;
+  using std::toupper _LIBCPP_USING_IF_EXISTS;
+} // namespace std

karellen_llvm_core-22.1.0rc1.post26.data/data/share/libc++/v1/std/cerrno.inc

@@ -0,0 +1,12 @@
+// -*- 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
+//
+//===----------------------------------------------------------------------===//
+
+export namespace std {
+  // This module exports nothing.
+} // namespace std

karellen_llvm_core-22.1.0rc1.post26.data/data/share/libc++/v1/std/cfenv.inc

@@ -0,0 +1,30 @@
+// -*- 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
+//
+//===----------------------------------------------------------------------===//
+
+export namespace std {
+  // types
+  using std::fenv_t _LIBCPP_USING_IF_EXISTS;
+  using std::fexcept_t _LIBCPP_USING_IF_EXISTS;
+
+  // functions
+  using std::feclearexcept _LIBCPP_USING_IF_EXISTS;
+  using std::fegetexceptflag _LIBCPP_USING_IF_EXISTS;
+  using std::feraiseexcept _LIBCPP_USING_IF_EXISTS;
+  using std::fesetexceptflag _LIBCPP_USING_IF_EXISTS;
+  using std::fetestexcept _LIBCPP_USING_IF_EXISTS;
+
+  using std::fegetround _LIBCPP_USING_IF_EXISTS;
+  using std::fesetround _LIBCPP_USING_IF_EXISTS;
+
+  using std::fegetenv _LIBCPP_USING_IF_EXISTS;
+  using std::feholdexcept _LIBCPP_USING_IF_EXISTS;
+  using std::fesetenv _LIBCPP_USING_IF_EXISTS;
+  using std::feupdateenv _LIBCPP_USING_IF_EXISTS;
+
+} // namespace std

karellen_llvm_core-22.1.0rc1.post26.data/data/share/libc++/v1/std/cfloat.inc

@@ -0,0 +1,12 @@
+// -*- 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
+//
+//===----------------------------------------------------------------------===//
+
+export namespace std {
+  // This module exports nothing.
+} // namespace std

karellen_llvm_core-22.1.0rc1.post26.data/data/share/libc++/v1/std/charconv.inc

@@ -0,0 +1,34 @@
+// -*- 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
+//
+//===----------------------------------------------------------------------===//
+
+export namespace std {
+
+  // floating-point format for primitive numerical conversion
+  using std::chars_format;
+
+  // chars_format is a bitmask type.
+  // [bitmask.types] specified operators
+  using std::operator&;
+  using std::operator&=;
+  using std::operator^;
+  using std::operator^=;
+  using std::operator|;
+  using std::operator|=;
+  using std::operator~;
+
+  // [charconv.to.chars], primitive numerical output conversion
+  using std::to_chars_result;
+
+  using std::to_chars;
+
+  // [charconv.from.chars], primitive numerical input conversion
+  using std::from_chars_result;
+
+  using std::from_chars;
+} // namespace std

karellen_llvm_core-22.1.0rc1.post26.data/data/share/libc++/v1/std/chrono.inc

@@ -0,0 +1,306 @@
+// -*- 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
+//
+//===----------------------------------------------------------------------===//
+
+export namespace std {
+
+  namespace chrono {
+    using std::chrono::duration;
+    using std::chrono::time_point;
+
+  } // namespace chrono
+
+  using std::common_type;
+
+  namespace chrono {
+
+    // [time.traits], customization traits
+    using std::chrono::treat_as_floating_point;
+    using std::chrono::treat_as_floating_point_v;
+
+    using std::chrono::duration_values;
+
+    using std::chrono::is_clock;
+    using std::chrono::is_clock_v;
+
+    // [time.duration.nonmember], duration arithmetic
+    using std::chrono::operator+;
+    using std::chrono::operator-;
+    using std::chrono::operator*;
+    using std::chrono::operator/;
+    using std::chrono::operator%;
+
+    // [time.duration.comparisons], duration comparisons
+    using std::chrono::operator==;
+    using std::chrono::operator<;
+    using std::chrono::operator>;
+    using std::chrono::operator<=;
+    using std::chrono::operator>=;
+    using std::chrono::operator<=>;
+
+    // [time.duration.cast], conversions
+    using std::chrono::ceil;
+    using std::chrono::duration_cast;
+    using std::chrono::floor;
+    using std::chrono::round;
+
+    // [time.duration.io], duration I/O
+#if _LIBCPP_HAS_LOCALIZATION
+    using std::chrono::operator<<;
+#endif
+    // using std::chrono::from_stream;
+
+    // convenience typedefs
+    using std::chrono::days;
+    using std::chrono::hours;
+    using std::chrono::microseconds;
+    using std::chrono::milliseconds;
+    using std::chrono::minutes;
+    using std::chrono::months;
+    using std::chrono::nanoseconds;
+    using std::chrono::seconds;
+    using std::chrono::weeks;
+    using std::chrono::years;
+
+    // [time.point.nonmember], time_point arithmetic
+
+    // [time.point.comparisons], time_point comparisons
+
+    // [time.point.cast], conversions
+    using std::chrono::time_point_cast;
+
+    // [time.duration.alg], specialized algorithms
+    using std::chrono::abs;
+
+    // [time.clock.system], class system_clock
+    using std::chrono::system_clock;
+
+    using std::chrono::sys_days;
+    using std::chrono::sys_seconds;
+    using std::chrono::sys_time;
+
+#if _LIBCPP_HAS_TIME_ZONE_DATABASE && _LIBCPP_HAS_FILESYSTEM && _LIBCPP_HAS_LOCALIZATION
+#  ifdef _LIBCPP_ENABLE_EXPERIMENTAL
+
+    // [time.clock.utc], class utc_clock
+    using std::chrono::utc_clock;
+
+    using std::chrono::utc_seconds;
+    using std::chrono::utc_time;
+
+    using std::chrono::leap_second_info;
+
+    using std::chrono::get_leap_second_info;
+
+    // [time.clock.tai], class tai_clock
+    using std::chrono::tai_clock;
+
+    using std::chrono::tai_seconds;
+    using std::chrono::tai_time;
+
+    // [time.clock.gps], class gps_clock
+    using std::chrono::gps_clock;
+
+    using std::chrono::gps_seconds;
+    using std::chrono::gps_time;
+#  endif // _LIBCPP_ENABLE_EXPERIMENTAL
+#endif   //  _LIBCPP_HAS_TIME_ZONE_DATABASE && _LIBCPP_HAS_FILESYSTEM && _LIBCPP_HAS_LOCALIZATION
+
+    // [time.clock.file], type file_clock
+    using std::chrono::file_clock;
+
+    using std::chrono::file_time;
+
+#if _LIBCPP_HAS_MONOTONIC_CLOCK
+    // [time.clock.steady], class steady_clock
+    using std::chrono::steady_clock;
+#endif
+
+    // [time.clock.hires], class high_resolution_clock
+    using std::chrono::high_resolution_clock;
+
+    // [time.clock.local], local time
+    using std::chrono::local_days;
+    using std::chrono::local_seconds;
+    using std::chrono::local_t;
+    using std::chrono::local_time;
+
+    // [time.clock.cast], time_point conversions
+    // using std::chrono::clock_time_conversion;
+
+    // using std::chrono::clock_cast;
+
+    // [time.cal.last], class last_spec
+    using std::chrono::last_spec;
+
+    // [time.cal.day], class day
+    using std::chrono::day;
+
+    // [time.cal.month], class month
+    using std::chrono::month;
+
+    // [time.cal.year], class year
+    using std::chrono::year;
+
+    // [time.cal.wd], class weekday
+    using std::chrono::weekday;
+
+    // [time.cal.wdidx], class weekday_indexed
+    using std::chrono::weekday_indexed;
+
+    // [time.cal.wdlast], class weekday_last
+    using std::chrono::weekday_last;
+
+    // [time.cal.md], class month_day
+    using std::chrono::month_day;
+
+    // [time.cal.mdlast], class month_day_last
+    using std::chrono::month_day_last;
+
+    // [time.cal.mwd], class month_weekday
+    using std::chrono::month_weekday;
+
+    // [time.cal.mwdlast], class month_weekday_last
+    using std::chrono::month_weekday_last;
+
+    // [time.cal.ym], class year_month
+    using std::chrono::year_month;
+
+    // [time.cal.ymd], class year_month_day
+    using std::chrono::year_month_day;
+
+    // [time.cal.ymdlast], class year_month_day_last
+    using std::chrono::year_month_day_last;
+
+    // [time.cal.ymwd], class year_month_weekday
+    using std::chrono::year_month_weekday;
+
+    // [time.cal.ymwdlast], class year_month_weekday_last
+    using std::chrono::year_month_weekday_last;
+
+    // [time.cal.operators], civil calendar conventional syntax operators
+
+    // [time.hms], class template hh_mm_ss
+    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;
+
+#ifdef _LIBCPP_ENABLE_EXPERIMENTAL
+
+#  if _LIBCPP_HAS_TIME_ZONE_DATABASE && _LIBCPP_HAS_FILESYSTEM && _LIBCPP_HAS_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::get_tzdb;
+    using std::chrono::get_tzdb_list;
+    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 //  _LIBCPP_HAS_TIME_ZONE_DATABASE && _LIBCPP_HAS_FILESYSTEM && _LIBCPP_HAS_LOCALIZATION
+
+    // [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::local_info;
+    using std::chrono::sys_info;
+
+#  if _LIBCPP_HAS_TIME_ZONE_DATABASE && _LIBCPP_HAS_FILESYSTEM && _LIBCPP_HAS_LOCALIZATION
+
+    // [time.zone.timezone], class time_zone
+    using std::chrono::choose;
+    using std::chrono::time_zone;
+
+    // [time.zone.zonedtraits], class template zoned_traits
+    using std::chrono::zoned_traits;
+
+    // [time.zone.zonedtime], class template zoned_time
+    using std::chrono::zoned_time;
+
+    using std::chrono::zoned_seconds;
+
+    // [time.zone.leap], leap second support
+    using std::chrono::leap_second;
+
+    // [time.zone.link], class time_zone_link
+    using std::chrono::time_zone_link;
+
+#    if 0
+    // [time.format], formatting
+    using std::chrono::local_time_format;
+#    endif
+#  endif //  _LIBCPP_HAS_TIME_ZONE_DATABASE && _LIBCPP_HAS_FILESYSTEM && _LIBCPP_HAS_LOCALIZATION
+#endif   // _LIBCPP_ENABLE_EXPERIMENTAL
+
+  } // namespace chrono
+
+#if _LIBCPP_HAS_LOCALIZATION
+  using std::formatter;
+#endif
+
+  namespace chrono {
+    // using std::chrono::parse;
+
+    // calendrical constants
+    using std::chrono::last;
+
+    using std::chrono::Friday;
+    using std::chrono::Monday;
+    using std::chrono::Saturday;
+    using std::chrono::Sunday;
+    using std::chrono::Thursday;
+    using std::chrono::Tuesday;
+    using std::chrono::Wednesday;
+
+    using std::chrono::April;
+    using std::chrono::August;
+    using std::chrono::December;
+    using std::chrono::February;
+    using std::chrono::January;
+    using std::chrono::July;
+    using std::chrono::June;
+    using std::chrono::March;
+    using std::chrono::May;
+    using std::chrono::November;
+    using std::chrono::October;
+    using std::chrono::September;
+
+  } // namespace chrono
+
+#if _LIBCPP_STD_VER >= 26
+  using std::hash;
+#endif
+
+} // namespace std
+export namespace std::inline literals::inline chrono_literals {
+  // [time.duration.literals], suffixes for duration literals
+  using std::literals::chrono_literals::operator""h;
+  using std::literals::chrono_literals::operator""min;
+  using std::literals::chrono_literals::operator""s;
+  using std::literals::chrono_literals::operator""ms;
+  using std::literals::chrono_literals::operator""us;
+  using std::literals::chrono_literals::operator""ns;
+
+  // [using std::literals::chrono_literals::.cal.day.nonmembers], non-member functions
+  using std::literals::chrono_literals::operator""d;
+
+  // [using std::literals::chrono_literals::.cal.year.nonmembers], non-member functions
+  using std::literals::chrono_literals::operator""y;
+} // namespace std::inline literals::inline chrono_literals

karellen_llvm_core-22.1.0rc1.post26.data/data/share/libc++/v1/std/cinttypes.inc

@@ -0,0 +1,25 @@
+// -*- 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
+//
+//===----------------------------------------------------------------------===//
+
+export namespace std {
+  using std::imaxdiv_t _LIBCPP_USING_IF_EXISTS;
+
+  using std::imaxabs _LIBCPP_USING_IF_EXISTS;
+  using std::imaxdiv _LIBCPP_USING_IF_EXISTS;
+  using std::strtoimax _LIBCPP_USING_IF_EXISTS;
+  using std::strtoumax _LIBCPP_USING_IF_EXISTS;
+  using std::wcstoimax _LIBCPP_USING_IF_EXISTS;
+  using std::wcstoumax _LIBCPP_USING_IF_EXISTS;
+
+  // abs is conditionally here, but always present in cmath.cppm. To avoid
+  // conflicing declarations omit the using here.
+
+  // div is conditionally here, but always present in cstdlib.cppm. To avoid
+  // conflicing declarations omit the using here.
+} // namespace std