diff options
Diffstat (limited to 'lib/ktl/include')
43 files changed, 1568 insertions, 0 deletions
diff --git a/lib/ktl/include/__chrono/system_clock.h b/lib/ktl/include/__chrono/system_clock.h new file mode 100644 index 0000000..5d39243 --- /dev/null +++ b/lib/ktl/include/__chrono/system_clock.h @@ -0,0 +1,15 @@ +// Copyright 2023 The Fuchsia Authors +// +// Use of this source code is governed by a MIT-style +// license that can be found in the LICENSE file or at +// https://opensource.org/licenses/MIT + +#ifndef ZIRCON_KERNEL_LIB_KTL_INCLUDE___CHRONO_SYSTEM_CLOCK_H_ +#define ZIRCON_KERNEL_LIB_KTL_INCLUDE___CHRONO_SYSTEM_CLOCK_H_ + +// libc++'s <atomic> includes this file via various internal headers. +// The declarations it provides aren't needed for the kernel and rely +// on other things stubbed out by the kernel. So this placeholder file +// just prevents compiling the libc++ code that doesn't work. + +#endif // ZIRCON_KERNEL_LIB_KTL_INCLUDE___CHRONO_SYSTEM_CLOCK_H_ diff --git a/lib/ktl/include/__config b/lib/ktl/include/__config new file mode 100644 index 0000000..e04573e --- /dev/null +++ b/lib/ktl/include/__config @@ -0,0 +1,53 @@ +// Copyright 2022 The Fuchsia Authors +// +// Use of this source code is governed by a MIT-style +// license that can be found in the LICENSE file or at +// https://opensource.org/licenses/MIT + +#ifndef ZIRCON_KERNEL_LIB_KTL_INCLUDE___CONFIG_ +#define ZIRCON_KERNEL_LIB_KTL_INCLUDE___CONFIG_ + +// The libc++ internal header <__config> unconditionally responds to some +// predefines set in the EFI environment. So this header wraps it and then +// undoes the damage that our __config_site header can't prevent. + +#include_next <__config> + +#undef _LIBCPP_WIN32API +#undef _LIBCPP_MSVCRT_LIKE +#undef _LIBCPP_MSVCRT +#undef _LIBCPP_HAS_OPEN_WITH_WCHAR + +// This prevents libc++ from doing fallback to spin locks and the like for +// cases where is_always_lock_free is not true. In the kernel, we don't want +// any behind-the-scenes help like that, we want to get link errors from +// libcalls if atomics can't be lowered to real hardware instructions. +#undef _LIBCPP_ATOMIC_ONLY_USE_BUILTINS + +// These are used by <__configuration/availability.h> to decide when headers +// should expect things to be defined in the library. For the kernel, there is +// no library and so everything must be defined in headers. +#undef _LIBCPP_INTRODUCED_IN_LLVM_21 +#define _LIBCPP_INTRODUCED_IN_LLVM_21 0 +#undef _LIBCPP_INTRODUCED_IN_LLVM_20 +#define _LIBCPP_INTRODUCED_IN_LLVM_20 0 +#undef _LIBCPP_INTRODUCED_IN_LLVM_19 +#define _LIBCPP_INTRODUCED_IN_LLVM_19 0 +#undef _LIBCPP_INTRODUCED_IN_LLVM_18 +#define _LIBCPP_INTRODUCED_IN_LLVM_18 0 +#undef _LIBCPP_INTRODUCED_IN_LLVM_16 +#define _LIBCPP_INTRODUCED_IN_LLVM_16 0 +#undef _LIBCPP_INTRODUCED_IN_LLVM_15 +#define _LIBCPP_INTRODUCED_IN_LLVM_15 0 +#undef _LIBCPP_INTRODUCED_IN_LLVM_14 +#define _LIBCPP_INTRODUCED_IN_LLVM_14 0 +#undef _LIBCPP_INTRODUCED_IN_LLVM_12 +#define _LIBCPP_INTRODUCED_IN_LLVM_12 0 +#undef _LIBCPP_INTRODUCED_IN_LLVM_11 +#define _LIBCPP_INTRODUCED_IN_LLVM_11 0 +#undef _LIBCPP_INTRODUCED_IN_LLVM_9 +#define _LIBCPP_INTRODUCED_IN_LLVM_9 0 +#undef _LIBCPP_INTRODUCED_IN_LLVM_4 +#define _LIBCPP_INTRODUCED_IN_LLVM_4 0 + +#endif // ZIRCON_KERNEL_LIB_KTL_INCLUDE___CONFIG_ diff --git a/lib/ktl/include/__config_site b/lib/ktl/include/__config_site new file mode 100644 index 0000000..4d2236b --- /dev/null +++ b/lib/ktl/include/__config_site @@ -0,0 +1,81 @@ +// Copyright 2021 The Fuchsia Authors +// +// Use of this source code is governed by a MIT-style +// license that can be found in the LICENSE file or at +// https://opensource.org/licenses/MIT + +#ifndef ZIRCON_KERNEL_LIB_KTL_INCLUDE___CONFIG_SITE_ +#define ZIRCON_KERNEL_LIB_KTL_INCLUDE___CONFIG_SITE_ + +// The libc++ internal header <__config> does #include <__config_site> to get +// definitions that vary by operating system, machine, or configuration. The +// toolchain's libc++ installation provides include/$triple/.../__config_site +// files for each $cpu-fuchsia appropriate for normal userland. But the ktl +// abuse of libc++ is different from public userland libc++, so provide special +// kernel-appropriate definitions here. This file will be in the include path +// ahead of any toolchain-supplied header. Also, some special bare-metal build +// environments such as phys32 or efi that reuse ktl and kernel libc code may +// use settings that cause the compiler to change the $triple it injects into +// the include path to one for which no runtimes are built and so there is no +// __config_site file to be found at all. + +// These two are what <__config_site> for Fuchsia userland defines. +#define _LIBCPP_ABI_VERSION 2 +#define _LIBCPP_HAS_NO_VENDOR_AVAILABILITY_ANNOTATIONS 1 + +// This has to be defined to some `__*` string but what doesn't really matter. +#define _LIBCPP_ABI_NAMESPACE __ktl + +// When compiling in the UEFI environment, the predefines look like Windows +// but there is no Windows runtime environment to use. +#define _LIBCPP_NO_VCRUNTIME 1 + +// This tells the headers not to use `extern template` declarations that +// expect specific instantiations/specializations to come from the libc++ +// library rather than the headers. In the kernel, only the headers are +// ever going to be available. +#define _LIBCPP_DISABLE_EXTERN_TEMPLATE 1 + +// This tells <atomic> not to use threading APIs. +#define _LIBCPP_HAS_NO_PLATFORM_WAIT 1 + +// This tells <atomic> et al to use <__external_threading> instead +// of expecting either POSIX or C11 threading APIs. +#define _LIBCPP_HAS_THREAD_API_EXTERNAL 1 +#define _LIBCPP_HAS_THREAD_LIBRARY_EXTERNAL 1 + +// <__config> requires that these be set if _LIBCPP_HAS_THREAD_API_EXTERNAL is. +#define _LIBCPP_HAS_THREADS 1 +#define _LIBCPP_HAS_MONOTONIC_CLOCK 1 + +// This tells <new> not to use `aligned_alloc` from <stdlib.h>. +#define _LIBCPP_HAS_NO_C11_ALIGNED_ALLOC 1 + +// This tells various headers to be strict about what includes what. +#define _LIBCPP_REMOVE_TRANSITIVE_INCLUDES 1 + +// This tells libc++ not to expect full locale APIs in some places. +#define _LIBCPP_HAS_NO_LOCALIZATION 1 + +// This is unfortunately required even though the kernel does not use wide +// characters. +#define _LIBCPP_HAS_WIDE_CHARACTERS 1 + +// This tells pstl headers to use serial algorithms and not try to +// do any multithreading. +#define _LIBCPP_PSTL_CPU_BACKEND_SERIAL 1 + +// This will probably never be used in code that ktl actually uses. +// But define it for completeness. +#define _LIBCPP_INSTRUMENTED_WITH_ASAN __has_feature(address_sanitizer) + +// TODO(https://fxbug.dev/42082322): make the hardening mode selectable through build +// configurations. +// This sets the default to tell libc++ to not enable assertions to prevent +// undefined behavior, but may be overridden if _LIBCPP_HARDENING_MODE is +// defined elsewhere. +#define _LIBCPP_HARDENING_MODE_DEFAULT _LIBCPP_HARDENING_MODE_NONE + +#define _LIBCPP_ASSERTION_SEMANTIC_DEFAULT _LIBCPP_ASSERTION_SEMANTIC_HARDENING_DEPENDENT + +#endif // ZIRCON_KERNEL_LIB_KTL_INCLUDE___CONFIG_SITE_ diff --git a/lib/ktl/include/__configuration/platform.h b/lib/ktl/include/__configuration/platform.h new file mode 100644 index 0000000..b15e1e0 --- /dev/null +++ b/lib/ktl/include/__configuration/platform.h @@ -0,0 +1,23 @@ +// Copyright 2025 The Fuchsia Authors +// +// Use of this source code is governed by a MIT-style +// license that can be found in the LICENSE file or at +// https://opensource.org/licenses/MIT + +#ifndef ZIRCON_KERNEL_LIB_KTL_INCLUDE___CONFIGURATION_PLATFORM_H_ +#define ZIRCON_KERNEL_LIB_KTL_INCLUDE___CONFIGURATION_PLATFORM_H_ + +// Other libc++ headers use <__configuration/platform.h> but libc++'s +// <__configuration/platform.h> does not yet recognize the `__PE_COFF__` +// predefine. Until we support this new predefine upstream, +// we must define _LIBCPP_OBJECT_FORMAT_COFF for UEFI targets here. +// TODO(https://fxbug.dev/435771251) -- Support `__PE_COFF__` predefine +// upstream. + +#if defined(__PE_COFF__) +#define _LIBCPP_OBJECT_FORMAT_COFF 2 // Tell libc++ this is PE-COFF. +#endif // __PE_COFF__ + +#include_next <__configuration/platform.h> + +#endif // ZIRCON_KERNEL_LIB_KTL_INCLUDE___CONFIGURATION_PLATFORM_H_ diff --git a/lib/ktl/include/__external_threading b/lib/ktl/include/__external_threading new file mode 100644 index 0000000..9cec903 --- /dev/null +++ b/lib/ktl/include/__external_threading @@ -0,0 +1,35 @@ +// Copyright 2020 The Fuchsia Authors +// +// Use of this source code is governed by a MIT-style +// license that can be found in the LICENSE file or at +// https://opensource.org/licenses/MIT + +#ifndef ZIRCON_KERNEL_LIB_KTL_INCLUDE___EXTERNAL_THREADING +#define ZIRCON_KERNEL_LIB_KTL_INCLUDE___EXTERNAL_THREADING + +// libc++'s <atomic> includes this file via <__threading_support>. It needs +// these types and functions declared, but only for use in interfaces that +// aren't supported in the kernel, so stub declarations are all they need. + +_LIBCPP_BEGIN_NAMESPACE_STD + +struct __libcpp_timespec_t { + long int tv_sec, tv_nsec; +}; + +using __libcpp_thread_id = int; + +bool __libcpp_thread_id_equal(__libcpp_thread_id, __libcpp_thread_id); +bool __libcpp_thread_id_less(__libcpp_thread_id, __libcpp_thread_id); +__libcpp_thread_id __libcpp_thread_get_current_id(); + +void __libcpp_thread_sleep_for(chrono::nanoseconds); +void __libcpp_thread_yield(); + +// This macro is used unconditionally in <__threading_support> but defined +// there only conditionally on when <__external_threading> is not used. +#define _LIBCPP_THREAD_ABI_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY + +_LIBCPP_END_NAMESPACE_STD + +#endif // ZIRCON_KERNEL_LIB_KTL_INCLUDE___EXTERNAL_THREADING diff --git a/lib/ktl/include/climits b/lib/ktl/include/climits new file mode 100644 index 0000000..86e537d --- /dev/null +++ b/lib/ktl/include/climits @@ -0,0 +1,15 @@ +// Copyright 2022 The Fuchsia Authors +// +// Use of this source code is governed by a MIT-style +// license that can be found in the LICENSE file or at +// https://opensource.org/licenses/MIT + +#pragma once + +// Other libc++ headers use <climits> but libc++'s <climits> complains if it +// thinks <limits.h> is not its own wrapper, which we do not need. We always +// get the kernel's <limits.h> before the libc++ with the way the include paths +// are set up, which is necessary because of other headers where preempting +// libc++'s header is unavoidable for the kernel environment. + +#include <limits.h> diff --git a/lib/ktl/include/cmath b/lib/ktl/include/cmath new file mode 100644 index 0000000..13b8e6b --- /dev/null +++ b/lib/ktl/include/cmath @@ -0,0 +1,53 @@ +// Copyright 2021 The Fuchsia Authors +// +// Use of this source code is governed by a MIT-style +// license that can be found in the LICENSE file or at +// https://opensource.org/licenses/MIT + +#ifndef ZIRCON_KERNEL_LIB_KTL_INCLUDE_CMATH_ +#define ZIRCON_KERNEL_LIB_KTL_INCLUDE_CMATH_ + +// The kernel doesn't want this file but some libc++ headers we need +// wind up including it. They don't actually most of the math +// declarations except under #if conditions that aren't true. + +#include <__config> +#include <type_traits> + +_LIBCPP_BEGIN_NAMESPACE_STD + +// These are used in templates that won't ever be instantiated in kernel code. + +template <typename T> +constexpr bool isinf(T&& x) { + static_assert(!is_same_v<T, T>, "must not be instantiated in kernel code"); + return false; +} + +template <typename T> +constexpr bool isnan(T&& x) { + static_assert(!is_same_v<T, T>, "must not be instantiated in kernel code"); + return false; +} + +template <typename T> +constexpr bool signbit(T&& x) { + static_assert(!is_same_v<T, T>, "must not be instantiated in kernel code"); + return false; +} + +template <typename T> +constexpr T frexp(T&& x, int* exponent) { + static_assert(!is_same_v<T, T>, "must not be instantiated in kernel code"); + return x; +} + +template <typename T> +constexpr auto ceil(T&& x) { + static_assert(!is_same_v<T, T>, "must not be instantiated in kernel code"); + return x; +} + +_LIBCPP_END_NAMESPACE_STD + +#endif // ZIRCON_KERNEL_LIB_KTL_INCLUDE_CMATH_ diff --git a/lib/ktl/include/cstdint b/lib/ktl/include/cstdint new file mode 100644 index 0000000..0ab922c --- /dev/null +++ b/lib/ktl/include/cstdint @@ -0,0 +1,18 @@ +// Copyright 2022 The Fuchsia Authors +// +// Use of this source code is governed by a MIT-style +// license that can be found in the LICENSE file or at +// https://opensource.org/licenses/MIT + +#pragma once + +// Other libc++ headers use <cstdint> but libc++'s <cstdint> complains if it +// thinks <stdint.h> is not its own wrapper, so we define _LIBCPP_STDINT_H. We +// always get the real <stdint.h> before the libc++ with the way the include +// paths are set up, which is necessary because of other headers where +// preempting libc++'s header is unavoidable for the kernel environment. + +#include <stdint.h> + +#define _LIBCPP_STDINT_H +#include_next <cstdint> diff --git a/lib/ktl/include/cstdio b/lib/ktl/include/cstdio new file mode 100644 index 0000000..349e736 --- /dev/null +++ b/lib/ktl/include/cstdio @@ -0,0 +1,21 @@ +// Copyright 2020 The Fuchsia Authors +// +// Use of this source code is governed by a MIT-style +// license that can be found in the LICENSE file or at +// https://opensource.org/licenses/MIT + +#ifndef ZIRCON_KERNEL_LIB_KTL_INCLUDE_CSTDIO_ +#define ZIRCON_KERNEL_LIB_KTL_INCLUDE_CSTDIO_ + +// The kernel doesn't want this file but some libc++ headers we need +// wind up including it and they need these declarations. +// +// Note this specifically avoids <stdio.h> because libc++ doesn't need that +// but <string_view> indirectly reaches <cstdio> and the kernel's <stdio.h> +// uses <ktl/string_view.h> so there would be a circularity. + +#include <wchar.h> + +#define EOF (-1) + +#endif // ZIRCON_KERNEL_LIB_KTL_INCLUDE_CSTDIO_ diff --git a/lib/ktl/include/cstdlib b/lib/ktl/include/cstdlib new file mode 100644 index 0000000..25ad762 --- /dev/null +++ b/lib/ktl/include/cstdlib @@ -0,0 +1,30 @@ +// Copyright 2018 The Fuchsia Authors +// +// Use of this source code is governed by a MIT-style +// license that can be found in the LICENSE file or at +// https://opensource.org/licenses/MIT + +#pragma once + +// This is used by libc++'s <new> just for std::abort, ::posix_memalign, and +// ::free. + +#include <stdlib.h> + +#include <__config> + +#define _LIBCPP_UNREACHABLE() __builtin_unreachable() + +// This is used by the __libcpp_aligned_alloc inline. Since it always fails +// that inline will trivially always return nullptr. +inline int posix_memalign(void** ptr, size_t align, size_t size) { return 1; } + +// This is used by the __libcpp_aligned_free inline, which won't really ever be +// called. The kernel does have a real free declared elsewhere. +void free(void* ptr); + +_LIBCPP_BEGIN_NAMESPACE_STD + +using ::abort; + +_LIBCPP_END_NAMESPACE_STD diff --git a/lib/ktl/include/cwchar b/lib/ktl/include/cwchar new file mode 100644 index 0000000..4f24c73 --- /dev/null +++ b/lib/ktl/include/cwchar @@ -0,0 +1,62 @@ +// Copyright 2020 The Fuchsia Authors +// +// Use of this source code is governed by a MIT-style +// license that can be found in the LICENSE file or at +// https://opensource.org/licenses/MIT + +#ifndef ZIRCON_KERNEL_LIB_KTL_INCLUDE_CWCHAR +#define ZIRCON_KERNEL_LIB_KTL_INCLUDE_CWCHAR + +// The kernel doesn't want this file but some libc++ headers we need +// wind up including it and they need these declarations. + +#include <wchar.h> + +#include <__config> + +_LIBCPP_BEGIN_NAMESPACE_STD + +using ::wmemcpy; +using ::wmemmove; +using ::wmemset; + +// These are called by libc++ header code. The first two should never actually +// be called by anything that really gets instantiated in kernel code since +// wchar_t is never used. However, __constexpr_wmemchr is used by places like +// std::find not just for wchar_t per se but for any trivial type of the same +// size, e.g. uint32_t. So its code must be correct. The other two are filled +// out just in case of an unexpected use. + +constexpr size_t __constexpr_wcslen(const wchar_t* str) { + size_t len = 0; + while (*str++ != L'\0') { + ++len; + } + return len; +} + +constexpr int __constexpr_wmemcmp(const wchar_t* lhs, const wchar_t* rhs, size_t count) { + while (count-- > 0) { + if (*lhs != *rhs) { + return static_cast<int>(*lhs - *rhs); + } + ++lhs; + ++rhs; + } + return 0; +} + +template <class Tp, class Up> +constexpr Tp* __constexpr_wmemchr(Tp* str, Up wc, size_t count) { + while (count-- > 0) { + if (*str == wc) { + return str; + } + ++str; + } + return nullptr; +} + +_LIBCPP_END_NAMESPACE_STD + +#endif // ZIRCON_KERNEL_LIB_KTL_INCLUDE_CWCHAR diff --git a/lib/ktl/include/ktl/algorithm.h b/lib/ktl/include/ktl/algorithm.h new file mode 100644 index 0000000..7b7baed --- /dev/null +++ b/lib/ktl/include/ktl/algorithm.h @@ -0,0 +1,116 @@ +// Copyright 2020 The Fuchsia Authors +// +// Use of this source code is governed by a MIT-style +// license that can be found in the LICENSE file or at +// https://opensource.org/licenses/MIT + +#ifndef ZIRCON_KERNEL_LIB_KTL_INCLUDE_KTL_ALGORITHM_H_ +#define ZIRCON_KERNEL_LIB_KTL_INCLUDE_KTL_ALGORITHM_H_ + +#include <algorithm> + +namespace ktl { + +// "Non-modifying sequence operations" +using std::adjacent_find; +using std::all_of; +using std::any_of; +using std::count; +using std::count_if; +using std::find; +using std::find_end; +using std::find_first_of; +using std::find_if; +using std::find_if_not; +using std::for_each; +using std::for_each_n; +using std::none_of; +using std::search; +using std::search_n; + +namespace ranges { +using std::ranges::adjacent_find; +using std::ranges::all_of; +using std::ranges::any_of; +using std::ranges::count; +using std::ranges::count_if; +using std::ranges::find; +using std::ranges::find_end; +using std::ranges::find_first_of; +using std::ranges::find_if; +using std::ranges::find_if_not; +using std::ranges::for_each; +using std::ranges::for_each_n; +using std::ranges::none_of; +using std::ranges::search; +using std::ranges::search_n; +} // namespace ranges + +// "Modifying sequence operations" (subset) +using std::copy; +using std::copy_if; +using std::fill; +using std::fill_n; +using std::reverse; +using std::shuffle; +using std::transform; + +namespace ranges { +using std::ranges::copy; +using std::ranges::copy_if; +using std::ranges::fill; +using std::ranges::fill_n; +using std::ranges::reverse; +using std::ranges::shuffle; +using std::ranges::transform; +} // namespace ranges + +// "Sorting operations" (subset) +using std::is_sorted; +using std::is_sorted_until; +using std::sort; +using std::stable_sort; + +namespace ranges { +using std::ranges::is_sorted; +using std::ranges::is_sorted_until; +using std::ranges::sort; +using std::ranges::stable_sort; +} // namespace ranges + +// "Binary search operations (on sorted ranges)" +using std::binary_search; +using std::equal_range; +using std::lower_bound; +using std::upper_bound; + +namespace ranges { +using std::ranges::binary_search; +using std::ranges::equal_range; +using std::ranges::lower_bound; +using std::ranges::upper_bound; +} // namespace ranges + +// "Minimum/maximum operations" +using std::clamp; +using std::equal; +using std::max; +using std::max_element; +using std::min; +using std::min_element; +using std::minmax; +using std::minmax_element; + +namespace ranges { +using std::ranges::clamp; +using std::ranges::max; +using std::ranges::max_element; +using std::ranges::min; +using std::ranges::min_element; +using std::ranges::minmax; +using std::ranges::minmax_element; +} // namespace ranges + +} // namespace ktl + +#endif // ZIRCON_KERNEL_LIB_KTL_INCLUDE_KTL_ALGORITHM_H_ diff --git a/lib/ktl/include/ktl/array.h b/lib/ktl/include/ktl/array.h new file mode 100644 index 0000000..90d445a --- /dev/null +++ b/lib/ktl/include/ktl/array.h @@ -0,0 +1,19 @@ +// Copyright 2019 The Fuchsia Authors +// +// Use of this source code is governed by a MIT-style +// license that can be found in the LICENSE file or at +// https://opensource.org/licenses/MIT + +#ifndef ZIRCON_KERNEL_LIB_KTL_INCLUDE_KTL_ARRAY_H_ +#define ZIRCON_KERNEL_LIB_KTL_INCLUDE_KTL_ARRAY_H_ + +#include <array> + +namespace ktl { + +using std::array; +using std::to_array; + +} // namespace ktl + +#endif // ZIRCON_KERNEL_LIB_KTL_INCLUDE_KTL_ARRAY_H_ diff --git a/lib/ktl/include/ktl/atomic.h b/lib/ktl/include/ktl/atomic.h new file mode 100644 index 0000000..017db6b --- /dev/null +++ b/lib/ktl/include/ktl/atomic.h @@ -0,0 +1,40 @@ +// Copyright 2019 The Fuchsia Authors +// +// Use of this source code is governed by a MIT-style +// license that can be found in the LICENSE file or at +// https://opensource.org/licenses/MIT + +#ifndef ZIRCON_KERNEL_LIB_KTL_INCLUDE_KTL_ATOMIC_H_ +#define ZIRCON_KERNEL_LIB_KTL_INCLUDE_KTL_ATOMIC_H_ + +#include <atomic> + +// On arm64 and x86-64, lock-free 128-bit (16-byte) atomics are available. +// But riscv64 does not support them. +#ifdef __riscv +#define HAVE_ATOMIC_128 0 +#else +#define HAVE_ATOMIC_128 1 +#endif + +namespace ktl { + +using std::atomic; +using std::atomic_init; +using std::atomic_ref; + +using std::memory_order; + +using std::memory_order_acq_rel; +using std::memory_order_acquire; +using std::memory_order_consume; +using std::memory_order_relaxed; +using std::memory_order_release; +using std::memory_order_seq_cst; + +using std::atomic_signal_fence; +using std::atomic_thread_fence; + +} // namespace ktl + +#endif // ZIRCON_KERNEL_LIB_KTL_INCLUDE_KTL_ATOMIC_H_ diff --git a/lib/ktl/include/ktl/bit.h b/lib/ktl/include/ktl/bit.h new file mode 100644 index 0000000..c3ccb7e --- /dev/null +++ b/lib/ktl/include/ktl/bit.h @@ -0,0 +1,30 @@ +// Copyright 2021 The Fuchsia Authors +// +// Use of this source code is governed by a MIT-style +// license that can be found in the LICENSE file or at +// https://opensource.org/licenses/MIT + +#ifndef ZIRCON_KERNEL_LIB_KTL_INCLUDE_KTL_BIT_H_ +#define ZIRCON_KERNEL_LIB_KTL_INCLUDE_KTL_BIT_H_ + +#include <bit> + +namespace ktl { + +using std::bit_cast; +using std::bit_ceil; +using std::bit_floor; +using std::bit_width; +using std::countl_one; +using std::countl_zero; +using std::countr_one; +using std::countr_zero; +using std::endian; +using std::has_single_bit; +using std::popcount; +using std::rotl; +using std::rotr; + +} // namespace ktl + +#endif // ZIRCON_KERNEL_LIB_KTL_INCLUDE_KTL_BIT_H_ diff --git a/lib/ktl/include/ktl/byte.h b/lib/ktl/include/ktl/byte.h new file mode 100644 index 0000000..26b1294 --- /dev/null +++ b/lib/ktl/include/ktl/byte.h @@ -0,0 +1,18 @@ +// Copyright 2020 The Fuchsia Authors +// +// Use of this source code is governed by a MIT-style +// license that can be found in the LICENSE file or at +// https://opensource.org/licenses/MIT + +#ifndef ZIRCON_KERNEL_LIB_KTL_INCLUDE_KTL_BYTE_H_ +#define ZIRCON_KERNEL_LIB_KTL_INCLUDE_KTL_BYTE_H_ + +#include <cstddef> + +namespace ktl { + +using std::byte; + +} // namespace ktl + +#endif // ZIRCON_KERNEL_LIB_KTL_INCLUDE_KTL_BYTE_H_ diff --git a/lib/ktl/include/ktl/concepts.h b/lib/ktl/include/ktl/concepts.h new file mode 100644 index 0000000..93b3f62 --- /dev/null +++ b/lib/ktl/include/ktl/concepts.h @@ -0,0 +1,46 @@ +// Copyright 2025 The Fuchsia Authors +// +// Use of this source code is governed by a MIT-style +// license that can be found in the LICENSE file or at +// https://opensource.org/licenses/MIT + +#ifndef ZIRCON_KERNEL_LIB_KTL_INCLUDE_KTL_CONCEPTS_H_ +#define ZIRCON_KERNEL_LIB_KTL_INCLUDE_KTL_CONCEPTS_H_ + +#include <concepts> + +namespace ktl { + +using std::assignable_from; +using std::common_reference_with; +using std::common_with; +using std::constructible_from; +using std::copy_constructible; +using std::copyable; +using std::default_initializable; +using std::derived_from; +using std::destructible; +using std::equality_comparable; +using std::equality_comparable_with; +using std::equivalence_relation; +using std::integral; +using std::invocable; +using std::movable; +using std::move_constructible; +using std::predicate; +using std::regular; +using std::regular_invocable; +using std::relation; +using std::same_as; +using std::semiregular; +using std::signed_integral; +using std::strict_weak_order; +using std::swappable; +using std::swappable_with; +using std::totally_ordered; +using std::totally_ordered_with; +using std::unsigned_integral; + +} // namespace ktl + +#endif // ZIRCON_KERNEL_LIB_KTL_INCLUDE_KTL_CONCEPTS_H_ diff --git a/lib/ktl/include/ktl/declval.h b/lib/ktl/include/ktl/declval.h new file mode 100644 index 0000000..925fe9c --- /dev/null +++ b/lib/ktl/include/ktl/declval.h @@ -0,0 +1,18 @@ +// Copyright 2021 The Fuchsia Authors +// +// Use of this source code is governed by a MIT-style +// license that can be found in the LICENSE file or at +// https://opensource.org/licenses/MIT + +#ifndef ZIRCON_KERNEL_LIB_KTL_INCLUDE_KTL_DECLVAL_H_ +#define ZIRCON_KERNEL_LIB_KTL_INCLUDE_KTL_DECLVAL_H_ + +#include <utility> + +namespace ktl { + +using std::declval; + +} // namespace ktl + +#endif // ZIRCON_KERNEL_LIB_KTL_INCLUDE_KTL_DECLVAL_H_ diff --git a/lib/ktl/include/ktl/enforce.h b/lib/ktl/include/ktl/enforce.h new file mode 100644 index 0000000..9c948d2 --- /dev/null +++ b/lib/ktl/include/ktl/enforce.h @@ -0,0 +1,37 @@ +// Copyright 2021 The Fuchsia Authors +// +// Use of this source code is governed by a MIT-style +// license that can be found in the LICENSE file or at +// https://opensource.org/licenses/MIT + +#ifndef ZIRCON_KERNEL_LIB_KTL_INCLUDE_KTL_ENFORCE_H_ +#define ZIRCON_KERNEL_LIB_KTL_INCLUDE_KTL_ENFORCE_H_ + +// `#include <ktl/enforce.h>` should appear last in the include list of any +// kernel .cc file that uses `ktl` headers. Since many other kernel headers +// use ktl headers and this must appear after *all* uses of any ktl headers, +// whether direct or indirect, it's a good idea to just make sure that +// `#include <ktl/enforce.h>` in each .cc file of kernel-only code (i.e. code +// that might ever use ktl directly). +// +// The //.clang-format file has a rule to ensure this file is placed last and +// separate from the other #include lines, so just adding the `#include` line +// to each source file should make sure its placement stays correct. + +// This directive tells the preprocessor that the identifier `std` cannot +// appear in any context (except the expansion of a macro already defined +// before now). This ensures that any stray use of std::name in kernel code +// can get caught at compile time so people remember to use ktl::name instead +// and ensure that what they're using is in the approved ktl subset of std. +// +// It also affects harmless use of `std` as a local variable name or whatever, +// but we can live without kernel code being able to use that one name. +#pragma GCC poison std + +// Also poison the stdcompat namespaces, as the same rules for ktl wrappers +// apply to those as std proper. +#pragma GCC poison cpp17 +#pragma GCC poison cpp20 +#pragma GCC poison cpp23 + +#endif // ZIRCON_KERNEL_LIB_KTL_INCLUDE_KTL_ENFORCE_H_ diff --git a/lib/ktl/include/ktl/forward.h b/lib/ktl/include/ktl/forward.h new file mode 100644 index 0000000..62874e6 --- /dev/null +++ b/lib/ktl/include/ktl/forward.h @@ -0,0 +1,18 @@ +// Copyright 2018 The Fuchsia Authors +// +// Use of this source code is governed by a MIT-style +// license that can be found in the LICENSE file or at +// https://opensource.org/licenses/MIT + +#ifndef ZIRCON_KERNEL_INCLUDE_KTL_FORWARD_H_ +#define ZIRCON_KERNEL_INCLUDE_KTL_FORWARD_H_ + +#include <utility> + +namespace ktl { + +using std::forward; + +} // namespace ktl + +#endif // ZIRCON_KERNEL_INCLUDE_KTL_FORWARD_H_ diff --git a/lib/ktl/include/ktl/functional.h b/lib/ktl/include/ktl/functional.h new file mode 100644 index 0000000..026f4cf --- /dev/null +++ b/lib/ktl/include/ktl/functional.h @@ -0,0 +1,19 @@ +// Copyright 2023 The Fuchsia Authors +// +// Use of this source code is governed by a MIT-style +// license that can be found in the LICENSE file or at +// https://opensource.org/licenses/MIT + +#ifndef ZIRCON_KERNEL_LIB_KTL_INCLUDE_KTL_FUNCTIONAL_H_ +#define ZIRCON_KERNEL_LIB_KTL_INCLUDE_KTL_FUNCTIONAL_H_ + +#include <functional> + +namespace ktl { + +using std::bind_front; +using std::invoke; + +} // namespace ktl + +#endif // ZIRCON_KERNEL_LIB_KTL_INCLUDE_KTL_FUNCTIONAL_H_ diff --git a/lib/ktl/include/ktl/initializer_list.h b/lib/ktl/include/ktl/initializer_list.h new file mode 100644 index 0000000..3a69abb --- /dev/null +++ b/lib/ktl/include/ktl/initializer_list.h @@ -0,0 +1,18 @@ +// Copyright 2021 The Fuchsia Authors +// +// Use of this source code is governed by a MIT-style +// license that can be found in the LICENSE file or at +// https://opensource.org/licenses/MIT + +#ifndef ZIRCON_KERNEL_LIB_KTL_INCLUDE_KTL_INITIALIZER_LIST_H_ +#define ZIRCON_KERNEL_LIB_KTL_INCLUDE_KTL_INITIALIZER_LIST_H_ + +#include <initializer_list> + +namespace ktl { + +using std::initializer_list; + +} // namespace ktl + +#endif // ZIRCON_KERNEL_LIB_KTL_INCLUDE_KTL_INITIALIZER_LIST_H_ diff --git a/lib/ktl/include/ktl/inplace_vector.h b/lib/ktl/include/ktl/inplace_vector.h new file mode 100644 index 0000000..4eaf92b --- /dev/null +++ b/lib/ktl/include/ktl/inplace_vector.h @@ -0,0 +1,18 @@ +// Copyright 2025 The Fuchsia Authors +// +// Use of this source code is governed by a MIT-style +// license that can be found in the LICENSE file or at +// https://opensource.org/licenses/MIT + +#ifndef ZIRCON_KERNEL_LIB_KTL_INCLUDE_KTL_INPLACE_VECTOR_H_ +#define ZIRCON_KERNEL_LIB_KTL_INCLUDE_KTL_INPLACE_VECTOR_H_ + +#include <lib/stdcompat/inplace_vector.h> + +namespace ktl { + +using cpp26::inplace_vector; + +} // namespace ktl + +#endif // ZIRCON_KERNEL_LIB_KTL_INCLUDE_KTL_INPLACE_VECTOR_H_ diff --git a/lib/ktl/include/ktl/iterator.h b/lib/ktl/include/ktl/iterator.h new file mode 100644 index 0000000..58d92be --- /dev/null +++ b/lib/ktl/include/ktl/iterator.h @@ -0,0 +1,38 @@ +// Copyright 2020 The Fuchsia Authors +// +// Use of this source code is governed by a MIT-style +// license that can be found in the LICENSE file or at +// https://opensource.org/licenses/MIT + +#ifndef ZIRCON_KERNEL_LIB_KTL_INCLUDE_KTL_ITERATOR_H_ +#define ZIRCON_KERNEL_LIB_KTL_INCLUDE_KTL_ITERATOR_H_ + +#include <iterator> + +namespace ktl { + +// This includes only the "iterator operations" and "range access" subsets +// of the <iterator> API. These are useful for treating all sorts of +// container types, raw arrays, pointers, and {...} literal lists uniformly. +// It leaves out iterator_traits and the "iterator adaptors" subset, which +// have not yet seemed desirable to employ in kernel code. + +using std::advance; +using std::begin; +using std::cbegin; +using std::cend; +using std::crbegin; +using std::crend; +using std::data; +using std::distance; +using std::empty; +using std::end; +using std::next; +using std::prev; +using std::rbegin; +using std::rend; +using std::size; + +} // namespace ktl + +#endif // ZIRCON_KERNEL_LIB_KTL_INCLUDE_KTL_ITERATOR_H_ diff --git a/lib/ktl/include/ktl/limits.h b/lib/ktl/include/ktl/limits.h new file mode 100644 index 0000000..8f6adf4 --- /dev/null +++ b/lib/ktl/include/ktl/limits.h @@ -0,0 +1,18 @@ +// Copyright 2019 The Fuchsia Authors +// +// Use of this source code is governed by a MIT-style +// license that can be found in the LICENSE file or at +// https://opensource.org/licenses/MIT + +#ifndef ZIRCON_KERNEL_INCLUDE_KTL_LIMITS_H_ +#define ZIRCON_KERNEL_INCLUDE_KTL_LIMITS_H_ + +#include <limits> + +namespace ktl { + +using std::numeric_limits; + +} // namespace ktl + +#endif // ZIRCON_KERNEL_INCLUDE_KTL_LIMITS_H_ diff --git a/lib/ktl/include/ktl/memory.h b/lib/ktl/include/ktl/memory.h new file mode 100644 index 0000000..caf8d47 --- /dev/null +++ b/lib/ktl/include/ktl/memory.h @@ -0,0 +1,41 @@ +// Copyright 2024 The Fuchsia Authors +// +// Use of this source code is governed by a MIT-style +// license that can be found in the LICENSE file or at +// https://opensource.org/licenses/MIT + +#ifndef ZIRCON_KERNEL_LIB_KTL_INCLUDE_KTL_MEMORY_H_ +#define ZIRCON_KERNEL_LIB_KTL_INCLUDE_KTL_MEMORY_H_ + +#include <memory> + +namespace ktl { + +using std::addressof; +using std::to_address; + +using std::align; +using std::assume_aligned; + +using std::default_delete; + +using std::pointer_traits; + +using std::construct_at; +using std::destroy; +using std::destroy_at; +using std::destroy_n; +using std::uninitialized_copy; +using std::uninitialized_copy_n; +using std::uninitialized_default_construct; +using std::uninitialized_default_construct_n; +using std::uninitialized_fill; +using std::uninitialized_fill_n; +using std::uninitialized_move; +using std::uninitialized_move_n; +using std::uninitialized_value_construct; +using std::uninitialized_value_construct_n; + +} // namespace ktl + +#endif // ZIRCON_KERNEL_LIB_KTL_INCLUDE_KTL_MEMORY_H_ diff --git a/lib/ktl/include/ktl/new.h b/lib/ktl/include/ktl/new.h new file mode 100644 index 0000000..12def96 --- /dev/null +++ b/lib/ktl/include/ktl/new.h @@ -0,0 +1,25 @@ +// Copyright 2026 The Fuchsia Authors +// +// Use of this source code is governed by a MIT-style +// license that can be found in the LICENSE file or at +// https://opensource.org/licenses/MIT + +#ifndef ZIRCON_KERNEL_LIB_KTL_INCLUDE_KTL_NEW_H_ +#define ZIRCON_KERNEL_LIB_KTL_INCLUDE_KTL_NEW_H_ + +#include <new> + +namespace ktl { + +using std::align_val_t; + +using std::destroying_delete; +using std::destroying_delete_t; +using std::nothrow; +using std::nothrow_t; + +using std::launder; + +} // namespace ktl + +#endif // ZIRCON_KERNEL_LIB_KTL_INCLUDE_KTL_NEW_H_ diff --git a/lib/ktl/include/ktl/numeric.h b/lib/ktl/include/ktl/numeric.h new file mode 100644 index 0000000..18cad1f --- /dev/null +++ b/lib/ktl/include/ktl/numeric.h @@ -0,0 +1,20 @@ +// Copyright 2023 The Fuchsia Authors +// +// Use of this source code is governed by a MIT-style +// license that can be found in the LICENSE file or at +// https://opensource.org/licenses/MIT + +#ifndef ZIRCON_KERNEL_LIB_KTL_INCLUDE_KTL_NUMERIC_H_ +#define ZIRCON_KERNEL_LIB_KTL_INCLUDE_KTL_NUMERIC_H_ + +#include <numeric> + +namespace ktl { + +// "Numeric operations" +using std::accumulate; +using std::reduce; + +} // namespace ktl + +#endif // ZIRCON_KERNEL_LIB_KTL_INCLUDE_KTL_NUMERIC_H_ diff --git a/lib/ktl/include/ktl/optional.h b/lib/ktl/include/ktl/optional.h new file mode 100644 index 0000000..e08451d --- /dev/null +++ b/lib/ktl/include/ktl/optional.h @@ -0,0 +1,23 @@ +// Copyright 2020 The Fuchsia Authors +// +// Use of this source code is governed by a MIT-style +// license that can be found in the LICENSE file or at +// https://opensource.org/licenses/MIT + +#ifndef ZIRCON_KERNEL_LIB_KTL_INCLUDE_KTL_OPTIONAL_H_ +#define ZIRCON_KERNEL_LIB_KTL_INCLUDE_KTL_OPTIONAL_H_ + +#include <optional> + +namespace ktl { + +using std::in_place; +using std::in_place_t; +using std::make_optional; +using std::nullopt; +using std::nullopt_t; +using std::optional; + +} // namespace ktl + +#endif // ZIRCON_KERNEL_LIB_KTL_INCLUDE_KTL_OPTIONAL_H_ diff --git a/lib/ktl/include/ktl/ranges.h b/lib/ktl/include/ktl/ranges.h new file mode 100644 index 0000000..8e3ee09 --- /dev/null +++ b/lib/ktl/include/ktl/ranges.h @@ -0,0 +1,25 @@ +// Copyright 2025 The Fuchsia Authors +// +// Use of this source code is governed by a MIT-style +// license that can be found in the LICENSE file or at +// https://opensource.org/licenses/MIT + +#ifndef ZIRCON_KERNEL_LIB_KTL_INCLUDE_KTL_RANGES_H_ +#define ZIRCON_KERNEL_LIB_KTL_INCLUDE_KTL_RANGES_H_ + +#include <ranges> + +namespace ktl { + +// This can't be a namespace alias like `views` because <ktl/algorithm.h> also +// adds things to ktl::ranges and redundant namespace aliases aren't allowed. +namespace ranges { +using namespace std::ranges; +} // namespace ranges + +// Only this header defines this namespace, so a simple namespace alias works. +namespace views = std::views; + +} // namespace ktl + +#endif // ZIRCON_KERNEL_LIB_KTL_INCLUDE_KTL_RANGES_H_ diff --git a/lib/ktl/include/ktl/ref.h b/lib/ktl/include/ktl/ref.h new file mode 100644 index 0000000..fdaddc4 --- /dev/null +++ b/lib/ktl/include/ktl/ref.h @@ -0,0 +1,19 @@ +// Copyright 2023 The Fuchsia Authors +// +// Use of this source code is governed by a MIT-style +// license that can be found in the LICENSE file or at +// https://opensource.org/licenses/MIT + +#ifndef ZIRCON_KERNEL_LIB_KTL_INCLUDE_KTL_REF_H_ +#define ZIRCON_KERNEL_LIB_KTL_INCLUDE_KTL_REF_H_ + +#include <functional> + +namespace ktl { + +using std::cref; +using std::ref; + +} // namespace ktl + +#endif // ZIRCON_KERNEL_LIB_KTL_INCLUDE_KTL_REF_H_ diff --git a/lib/ktl/include/ktl/source_location.h b/lib/ktl/include/ktl/source_location.h new file mode 100644 index 0000000..121668d --- /dev/null +++ b/lib/ktl/include/ktl/source_location.h @@ -0,0 +1,18 @@ +// Copyright 2025 The Fuchsia Authors +// +// Use of this source code is governed by a MIT-style +// license that can be found in the LICENSE file or at +// https://opensource.org/licenses/MIT + +#ifndef ZIRCON_KERNEL_LIB_KTL_INCLUDE_KTL_SOURCE_LOCATION_H_ +#define ZIRCON_KERNEL_LIB_KTL_INCLUDE_KTL_SOURCE_LOCATION_H_ + +#include <source_location> + +namespace ktl { + +using std::source_location; + +} + +#endif // ZIRCON_KERNEL_LIB_KTL_INCLUDE_KTL_SOURCE_LOCATION_H_ diff --git a/lib/ktl/include/ktl/span.h b/lib/ktl/include/ktl/span.h new file mode 100644 index 0000000..deb1df3 --- /dev/null +++ b/lib/ktl/include/ktl/span.h @@ -0,0 +1,26 @@ +// Copyright 2020 The Fuchsia Authors +// +// Use of this source code is governed by a MIT-style +// license that can be found in the LICENSE file or at +// https://opensource.org/licenses/MIT + +#ifndef ZIRCON_KERNEL_LIB_KTL_INCLUDE_KTL_SPAN_H_ +#define ZIRCON_KERNEL_LIB_KTL_INCLUDE_KTL_SPAN_H_ + +#include <span> + +namespace ktl { + +using std::span; + +using std::as_bytes; +using std::as_writable_bytes; + +using std::dynamic_extent; + +using std::data; +using std::size; + +} // namespace ktl + +#endif // ZIRCON_KERNEL_LIB_KTL_INCLUDE_KTL_SPAN_H_ diff --git a/lib/ktl/include/ktl/string_view.h b/lib/ktl/include/ktl/string_view.h new file mode 100644 index 0000000..9ba949f --- /dev/null +++ b/lib/ktl/include/ktl/string_view.h @@ -0,0 +1,22 @@ +// Copyright 2020 The Fuchsia Authors +// +// Use of this source code is governed by a MIT-style +// license that can be found in the LICENSE file or at +// https://opensource.org/licenses/MIT + +#ifndef ZIRCON_KERNEL_LIB_KTL_INCLUDE_KTL_STRING_VIEW_H_ +#define ZIRCON_KERNEL_LIB_KTL_INCLUDE_KTL_STRING_VIEW_H_ + +#include <string_view> + +namespace ktl { + +using std::basic_string_view; +using std::string_view; + +} // namespace ktl + +// Just including <ktl/string_view.h> enables "foo"sv literals. +using namespace std::literals::string_view_literals; + +#endif // ZIRCON_KERNEL_LIB_KTL_INCLUDE_KTL_STRING_VIEW_H_ diff --git a/lib/ktl/include/ktl/tuple.h b/lib/ktl/include/ktl/tuple.h new file mode 100644 index 0000000..b00c7e0 --- /dev/null +++ b/lib/ktl/include/ktl/tuple.h @@ -0,0 +1,30 @@ +// Copyright 2024 The Fuchsia Authors +// +// Use of this source code is governed by a MIT-style +// license that can be found in the LICENSE file or at +// https://opensource.org/licenses/MIT + +#ifndef ZIRCON_KERNEL_LIB_KTL_INCLUDE_KTL_TUPLE_H_ +#define ZIRCON_KERNEL_LIB_KTL_INCLUDE_KTL_TUPLE_H_ + +#include <tuple> + +namespace ktl { + +using std::apply; +using std::forward_as_tuple; +using std::get; +using std::ignore; +using std::make_from_tuple; +using std::make_tuple; +using std::tie; +using std::tuple; +using std::tuple_cat; +using std::tuple_element; +using std::tuple_element_t; +using std::tuple_size; +using std::tuple_size_v; + +} // namespace ktl + +#endif // ZIRCON_KERNEL_LIB_KTL_INCLUDE_KTL_TUPLE_H_ diff --git a/lib/ktl/include/ktl/type_traits.h b/lib/ktl/include/ktl/type_traits.h new file mode 100644 index 0000000..fc0a2f0 --- /dev/null +++ b/lib/ktl/include/ktl/type_traits.h @@ -0,0 +1,165 @@ +// Copyright 2019 The Fuchsia Authors +// +// Use of this source code is governed by a MIT-style +// license that can be found in the LICENSE file or at +// https://opensource.org/licenses/MIT + +#ifndef ZIRCON_KERNEL_LIB_KTL_INCLUDE_KTL_TYPE_TRAITS_H_ +#define ZIRCON_KERNEL_LIB_KTL_INCLUDE_KTL_TYPE_TRAITS_H_ + +#include <type_traits> + +namespace ktl { + +using std::add_const; +using std::add_const_t; + +using std::is_array; +using std::is_array_v; +using std::is_bounded_array; +using std::is_bounded_array_v; +using std::is_unbounded_array; +using std::is_unbounded_array_v; + +using std::false_type; +using std::true_type; + +using std::conjunction; +using std::conjunction_v; + +using std::disjunction; +using std::disjunction_v; + +using std::conditional; +using std::conditional_t; + +using std::decay; +using std::decay_t; + +using std::void_t; + +using std::enable_if; +using std::enable_if_t; + +using std::has_unique_object_representations; +using std::has_unique_object_representations_v; + +using std::is_base_of; +using std::is_base_of_v; + +using std::is_const; +using std::is_const_v; + +using std::is_constructible; +using std::is_constructible_v; + +using std::is_copy_constructible; +using std::is_copy_constructible_v; + +using std::is_copy_assignable; +using std::is_copy_assignable_v; + +using std::is_default_constructible; +using std::is_default_constructible_v; + +using std::is_class; +using std::is_class_v; + +using std::is_enum; +using std::is_enum_v; + +using std::is_floating_point; +using std::is_floating_point_v; + +using std::is_function; +using std::is_function_v; + +using std::is_integral; +using std::is_integral_v; + +using std::invoke_result_t; +using std::is_invocable; +using std::is_invocable_r; +using std::is_invocable_r_v; +using std::is_invocable_v; + +using std::is_lvalue_reference; +using std::is_lvalue_reference_v; + +using std::is_move_constructible; +using std::is_move_constructible_v; + +using std::is_move_assignable; +using std::is_move_assignable_v; + +using std::is_pod; +using std::is_pod_v; + +using std::is_same; +using std::is_same_v; + +using std::is_signed; +using std::is_signed_v; + +using std::is_standard_layout; +using std::is_standard_layout_v; + +using std::is_empty; +using std::is_empty_v; + +using std::is_trivial; +using std::is_trivial_v; + +using std::is_trivially_copy_assignable; +using std::is_trivially_copy_assignable_v; + +using std::is_trivially_copy_constructible; +using std::is_trivially_copy_constructible_v; + +using std::is_trivially_constructible; +using std::is_trivially_constructible_v; + +using std::is_trivially_destructible; +using std::is_trivially_destructible_v; + +using std::is_trivially_move_assignable; +using std::is_trivially_move_assignable_v; + +using std::is_trivially_move_constructible; +using std::is_trivially_move_constructible_v; + +using std::is_member_object_pointer; +using std::is_member_object_pointer_v; + +using std::is_unsigned; +using std::is_unsigned_v; + +using std::is_void; +using std::is_void_v; + +using std::make_signed; +using std::make_signed_t; +using std::make_unsigned; +using std::make_unsigned_t; + +using std::remove_all_extents; +using std::remove_all_extents_t; + +using std::remove_const; +using std::remove_const_t; + +using std::remove_extent; +using std::remove_extent_t; + +using std::remove_pointer; +using std::remove_pointer_t; + +using std::remove_reference; +using std::remove_reference_t; + +using std::underlying_type; +using std::underlying_type_t; + +} // namespace ktl + +#endif // ZIRCON_KERNEL_LIB_KTL_INCLUDE_KTL_TYPE_TRAITS_H_ diff --git a/lib/ktl/include/ktl/unique_ptr.h b/lib/ktl/include/ktl/unique_ptr.h new file mode 100644 index 0000000..e2d2f39 --- /dev/null +++ b/lib/ktl/include/ktl/unique_ptr.h @@ -0,0 +1,37 @@ +// Copyright 2018 The Fuchsia Authors +// +// Use of this source code is governed by a MIT-style +// license that can be found in the LICENSE file or at +// https://opensource.org/licenses/MIT + +#ifndef ZIRCON_KERNEL_INCLUDE_KTL_UNIQUE_PTR_H_ +#define ZIRCON_KERNEL_INCLUDE_KTL_UNIQUE_PTR_H_ + +#include <memory> +#include <new> + +#include <fbl/alloc_checker.h> +#include <ktl/type_traits.h> + +namespace ktl { + +using std::align_val_t; +using std::unique_ptr; + +template <typename T, typename... Args> +ktl::enable_if_t<!ktl::is_array_v<T>, unique_ptr<T>> make_unique(fbl::AllocChecker* ac, + Args&&... args) { + return unique_ptr<T>(new (ac) T(std::forward<Args>(args)...)); +} + +// For an unbounded array of given size, each element is value-initialized. +// This is different from plain `new (ac) T[n]`, which performs default-initialization. +template <typename T, typename... Args> +ktl::enable_if_t<ktl::is_unbounded_array_v<T>, unique_ptr<T>> make_unique(fbl::AllocChecker* ac, + size_t n) { + return unique_ptr<T>(new (ac) ktl::remove_extent_t<T>[n]()); +} + +} // namespace ktl + +#endif // ZIRCON_KERNEL_INCLUDE_KTL_UNIQUE_PTR_H_ diff --git a/lib/ktl/include/ktl/utility.h b/lib/ktl/include/ktl/utility.h new file mode 100644 index 0000000..1e699e2 --- /dev/null +++ b/lib/ktl/include/ktl/utility.h @@ -0,0 +1,41 @@ +// Copyright 2018 The Fuchsia Authors +// +// Use of this source code is governed by a MIT-style +// license that can be found in the LICENSE file or at +// https://opensource.org/licenses/MIT + +#ifndef ZIRCON_KERNEL_LIB_KTL_INCLUDE_KTL_UTILITY_H_ +#define ZIRCON_KERNEL_LIB_KTL_INCLUDE_KTL_UTILITY_H_ + +#include <utility> + +namespace ktl { + +using std::declval; +using std::exchange; +using std::forward; +using std::move; +using std::swap; + +using std::in_place; +using std::in_place_index; +using std::in_place_index_t; +using std::in_place_t; + +using std::index_sequence; +using std::index_sequence_for; +using std::integer_sequence; +using std::make_index_sequence; +using std::make_integer_sequence; + +using std::get; +using std::make_pair; +using std::pair; +using std::piecewise_construct; +using std::piecewise_construct_t; + +using std::ignore; + +} // namespace ktl + +#endif // ZIRCON_KERNEL_LIB_KTL_INCLUDE_KTL_UTILITY_H_ diff --git a/lib/ktl/include/ktl/variant.h b/lib/ktl/include/ktl/variant.h new file mode 100644 index 0000000..68ef362 --- /dev/null +++ b/lib/ktl/include/ktl/variant.h @@ -0,0 +1,31 @@ +// Copyright 2020 The Fuchsia Authors +// +// Use of this source code is governed by a MIT-style +// license that can be found in the LICENSE file or at +// https://opensource.org/licenses/MIT + +#ifndef ZIRCON_KERNEL_LIB_KTL_INCLUDE_KTL_VARIANT_H_ +#define ZIRCON_KERNEL_LIB_KTL_INCLUDE_KTL_VARIANT_H_ + +#include <utility> +#include <variant> + +namespace ktl { + +using std::get; +using std::get_if; +using std::holds_alternative; +using std::in_place_type; +using std::in_place_type_t; +using std::monostate; +using std::variant; +using std::variant_alternative; +using std::variant_alternative_t; +using std::variant_npos; +using std::variant_size; +using std::variant_size_v; +using std::visit; + +} // namespace ktl + +#endif // ZIRCON_KERNEL_LIB_KTL_INCLUDE_KTL_VARIANT_H_ diff --git a/lib/ktl/include/limits b/lib/ktl/include/limits new file mode 100644 index 0000000..d8ea37d --- /dev/null +++ b/lib/ktl/include/limits @@ -0,0 +1,110 @@ +// Copyright 2018 The Fuchsia Authors +// +// Use of this source code is governed by a MIT-style +// license that can be found in the LICENSE file or at +// https://opensource.org/licenses/MIT + +#pragma once + +// TODO(https://fxbug.dev/42106615): The libc++ <limits> defines specializations for +// floating-point types, which in GCC is incompatible with the command-line +// switches used for the kernel. So this header fakes out the other libc++ +// headers with a std::numeric_limits that is close enough. + +#include <limits.h> + +namespace std { + +template <class T> +class numeric_limits {}; + +#define SPECIALIZE_INT(type, sign, modulo, digits_, min_, max_) \ + template <> \ + class numeric_limits<type> { \ + public: \ + static constexpr bool is_specialized = true; \ + static constexpr bool is_signed = (sign); \ + static constexpr bool is_integer = true; \ + static constexpr bool is_exact = true; \ + static constexpr bool has_infinity = false; \ + static constexpr bool has_quiet_NaN = false; \ + static constexpr bool has_signaling_NaN = false; \ + static constexpr bool has_denorm = false; \ + static constexpr bool has_denorm_loss = false; \ + static constexpr bool round_style = false; \ + static constexpr bool is_iec559 = false; \ + static constexpr bool is_bounded = true; \ + static constexpr bool is_modulo = (modulo); \ + static constexpr int digits = (digits_); \ + static constexpr int digits10 = (digits_) * 3 / 10; \ + static constexpr int max_digits10 = 0; \ + static constexpr int radix = 2; \ + static constexpr int min_exponent = 0; \ + static constexpr int min_exponent10 = 0; \ + static constexpr int max_exponent = 0; \ + static constexpr int max_exponent10 = 0; \ + static constexpr bool traps = false; \ + static constexpr bool tinyness_before = false; \ + static constexpr type min() { \ + return (min_); \ + } \ + static constexpr type lowest() { \ + return (min_); \ + } \ + static constexpr type max() { \ + return (max_); \ + } \ + static constexpr type epsilon() { \ + return 0; \ + } \ + static constexpr type round_error() { \ + return 0; \ + } \ + static constexpr type infinity() { \ + return 0; \ + } \ + static constexpr type quiet_NaN() { \ + return 0; \ + } \ + static constexpr type signaling_NaN() { \ + return 0; \ + } \ + static constexpr type denorm_min() { \ + return 0; \ + } \ + } + +#define SPECIALIZE_SIGNED(type, min, max) \ + SPECIALIZE_INT(type, true, false, CHAR_BIT * sizeof(type) - 1, min, max) + +#define SPECIALIZE_UNSIGNED(type, min, max) \ + SPECIALIZE_INT(type, false, true, CHAR_BIT * sizeof(type), min, max) + +SPECIALIZE_INT(bool, false, true, 1, false, true); +#if CHAR_MIN == 0 +SPECIALIZE_UNSIGNED(char, CHAR_MIN, CHAR_MAX); +#else +SPECIALIZE_SIGNED(char, CHAR_MIN, CHAR_MAX); +#endif +SPECIALIZE_SIGNED(signed char, SCHAR_MIN, SCHAR_MAX); +SPECIALIZE_UNSIGNED(unsigned char, 0, UCHAR_MAX); + +SPECIALIZE_SIGNED(short, SHRT_MIN, SHRT_MAX); +SPECIALIZE_UNSIGNED(unsigned short, 0, USHRT_MAX); +SPECIALIZE_SIGNED(int, INT_MIN, INT_MAX); +SPECIALIZE_UNSIGNED(unsigned int, 0, UINT_MAX); +SPECIALIZE_SIGNED(long, LONG_MIN, LONG_MAX); +SPECIALIZE_UNSIGNED(unsigned long, 0, ULONG_MAX); +SPECIALIZE_SIGNED(long long, (-__LONG_LONG_MAX__ - 1LL), __LONG_LONG_MAX__); +SPECIALIZE_UNSIGNED(unsigned long long, 0, (__LONG_LONG_MAX__ * 2ULL + 1ULL)); + +#ifdef __SIZEOF_INT128__ +SPECIALIZE_SIGNED(__int128_t, (__int128_t{1} << 127), (~__uint128_t{0} ^ (__int128_t{1} << 127))); +SPECIALIZE_UNSIGNED(__uint128_t, 0, (~__uint128_t{0})); +#endif + +#undef SPECIALIZE_SIGNED +#undef SPECIALIZE_UNSIGNED +#undef SPECIALIZE_INT + +} // namespace std diff --git a/lib/ktl/include/time.h b/lib/ktl/include/time.h new file mode 100644 index 0000000..138801f --- /dev/null +++ b/lib/ktl/include/time.h @@ -0,0 +1,39 @@ +// Copyright 2020 The Fuchsia Authors +// +// Use of this source code is governed by a MIT-style +// license that can be found in the LICENSE file or at +// https://opensource.org/licenses/MIT + +#ifndef ZIRCON_KERNEL_LIB_KTL_INCLUDE_TIME_H_ +#define ZIRCON_KERNEL_LIB_KTL_INCLUDE_TIME_H_ + +#include <stddef.h> + +// <zircon/time.h> uses these when __has_include(<time.h>). +typedef long int time_t; +struct timespec { + time_t tv_sec; + long int tv_nsec; +}; + +// The kernel doesn't want this file but some libc++ headers we need +// wind up including it and they need these declarations. + +#ifdef __cplusplus + +using clock_t = long int; +struct tm {}; +char* asctime(tm*) noexcept; +clock_t clock() noexcept; +char* ctime(const time_t*) noexcept; +double difftime(time_t, time_t) noexcept; +tm* gmtime(const time_t*) noexcept; +tm* localtime(const time_t*) noexcept; +time_t mktime(tm*) noexcept; +size_t strftime(char*, size_t, const char*, const tm*) noexcept; +time_t time(time_t*) noexcept; +int timespec_get(timespec* ts, int) noexcept; + +#endif // __cplusplus + +#endif // ZIRCON_KERNEL_LIB_KTL_INCLUDE_TIME_H_ diff --git a/lib/ktl/include/version b/lib/ktl/include/version new file mode 100644 index 0000000..ba04749 --- /dev/null +++ b/lib/ktl/include/version @@ -0,0 +1,14 @@ +// Copyright 2024 The Fuchsia Authors +// +// Use of this source code is governed by a MIT-style +// license that can be found in the LICENSE file or at +// https://opensource.org/licenses/MIT + +#pragma once + +#include_next <version> + +// We want to be able to implement specialization for std::formatter in common libraries for kernel +// and userspace. By undefing it here, we allow those libraries to avoid exposing that code to the +// kernel where it's not supported. +#undef __cpp_lib_format diff --git a/lib/ktl/include/wchar.h b/lib/ktl/include/wchar.h new file mode 100644 index 0000000..b3f2ccb --- /dev/null +++ b/lib/ktl/include/wchar.h @@ -0,0 +1,23 @@ +// Copyright 2023 The Fuchsia Authors +// +// Use of this source code is governed by a MIT-style +// license that can be found in the LICENSE file or at +// https://opensource.org/licenses/MIT + +#ifndef ZIRCON_KERNEL_LIB_KTL_INCLUDE_WCHAR_H_ +#define ZIRCON_KERNEL_LIB_KTL_INCLUDE_WCHAR_H_ + +// This file is included by <cstdio> and the like that are used from other +// libc++ headers that are wrapped by ktl. This file exists to preempt those +// inclusions so that libc++'s <wchar.h> wrapper header won't be used, since +// it's not compatible with the kernel environment. However, other libc++ +// headers also use `#include_next <wchar.h>` to get to "the system libc" +// version of the header. To satisfy those, include-after/wchar.h provides the +// actual declarations needed from the standard C <wchar.h> API. So this +// header just defers to that one, but must exist separately in this directory +// so that it preempt's libc++'s wrapper. This can't itself use #include_next +// because that would reach libc++'s wrapper before the include-after file. + +#include "../include-after/wchar.h" + +#endif // ZIRCON_KERNEL_LIB_KTL_INCLUDE_WCHAR_H_ |