react-native-windows 0.81.34 → 0.81.36

package/external/folly/folly/lang/Align.h

@@ -0,0 +1,240 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <cassert>
+#include <cstddef>
+#include <cstdint>
+
+#include <folly/Portability.h>
+#include <folly/Traits.h>
+
+namespace folly {
+
+//  register_pass_max_size
+//
+//  The platform-specific maximum size of a value which may be passed by-value
+//  in registers.
+//
+//  According to each platform ABI, trivially-copyable types up to this maximum
+//  size may, if the stars align, be passed by-value in registers rather than
+//  implicitly by-reference to stack copies.
+//
+//  Approximate. Accuracy is not promised.
+constexpr std::size_t register_pass_max_size =
+    (kMscVer ? 1u : 2u) * sizeof(void*);
+
+//  is_register_pass_v
+//
+//  Whether a value may be passed in a register.
+//
+//  Trivially-copyable values up to register_pass_max_size in width may be
+//  passed by-value in registers rather than implicitly by-reference to stack
+//  copies.
+//
+//  Approximate. Accuracy is not promised.
+template <typename T>
+constexpr bool is_register_pass_v =
+    (sizeof(T) <= register_pass_max_size) && std::is_trivially_copyable_v<T>;
+template <typename T>
+constexpr bool is_register_pass_v<T&> = true;
+template <typename T>
+constexpr bool is_register_pass_v<T&&> = true;
+
+/// register_pass_t
+///
+/// Chooses an optimal argument type for passing values of type T based on
+/// whehter such values may be passed in registers.
+template <typename T>
+using register_pass_t = conditional_t<is_register_pass_v<T>, T const, T const&>;
+
+//  has_extended_alignment
+//
+//  True if it may be presumed that the platform has static extended alignment;
+//  false if it may not be so presumed, even when the platform might actually
+//  have it. Static extended alignment refers to extended alignment of objects
+//  with automatic, static, or thread storage. Whether the there is support for
+//  dynamic extended alignment is a property of the allocator which is used for
+//  each given dynamic allocation.
+//
+//  Currently, very heuristical - only non-mobile 64-bit linux gets the extended
+//  alignment treatment. Theoretically, this could be tuned better.
+constexpr bool has_extended_alignment =
+    kIsLinux && sizeof(void*) >= sizeof(std::uint64_t);
+
+namespace detail {
+
+// Implemented this way because of a bug in Clang for ARMv7, which gives the
+// wrong result for `alignof` a `union` with a field of each scalar type.
+template <typename... Ts>
+struct max_align_t_ {
+  static constexpr std::size_t value() {
+    std::size_t const values[] = {0u, alignof(Ts)...};
+    std::size_t r = 0u;
+    for (auto const v : values) {
+      r = r < v ? v : r;
+    }
+    return r;
+  }
+};
+using max_align_v_ = max_align_t_<
+    long double,
+    double,
+    float,
+    long long int,
+    long int,
+    int,
+    short int,
+    bool,
+    char,
+    char16_t,
+    char32_t,
+    wchar_t,
+    void*,
+    std::max_align_t>;
+
+} // namespace detail
+
+// max_align_v is the alignment of max_align_t.
+//
+// max_align_t is a type which is aligned at least as strictly as the
+// most-aligned basic type (see the specification of std::max_align_t). This
+// implementation exists because 32-bit iOS platforms have a broken
+// std::max_align_t (see below).
+//
+// You should refer to this as `::folly::max_align_t` in portable code, even if
+// you have `using namespace folly;` because C11 defines a global namespace
+// `max_align_t` type.
+//
+// To be certain, we consider every non-void fundamental type specified by the
+// standard. On most platforms `long double` would be enough, but iOS 32-bit
+// has an 8-byte aligned `double` and `long long int` and a 4-byte aligned
+// `long double`.
+//
+// So far we've covered locals and other non-allocated storage, but we also need
+// confidence that allocated storage from `malloc`, `new`, etc will also be
+// suitable for objects with this alignment requirement.
+//
+// Apple document that their implementation of malloc will issue 16-byte
+// granularity chunks for small allocations (large allocations are page-size
+// granularity and page-aligned). We think that allocated storage will be
+// suitable for these objects based on the following assumptions:
+//
+// 1. 16-byte granularity also means 16-byte aligned.
+// 2. `new` and other allocators follow the `malloc` rules.
+//
+// We also have some anecdotal evidence: we don't see lots of misaligned-storage
+// crashes on 32-bit iOS apps that use `double`.
+//
+// Apple's allocation reference: http://bit.ly/malloc-small
+constexpr std::size_t max_align_v = detail::max_align_v_::value();
+struct alignas(max_align_v) max_align_t {};
+
+//  Memory locations within the same cache line are subject to destructive
+//  interference, also known as false sharing, which is when concurrent
+//  accesses to these different memory locations from different cores, where at
+//  least one of the concurrent accesses is or involves a store operation,
+//  induce contention and harm performance.
+//
+//  Microbenchmarks indicate that pairs of cache lines also see destructive
+//  interference under heavy use of atomic operations, as observed for atomic
+//  increment on Sandy Bridge.
+//
+//  We assume a cache line size of 64, so we use a cache line pair size of 128
+//  to avoid destructive interference.
+//
+//  mimic: std::hardware_destructive_interference_size, C++17
+constexpr std::size_t hardware_destructive_interference_size =
+    (kIsArchArm || kIsArchS390X) ? 64 : 128;
+static_assert(hardware_destructive_interference_size >= max_align_v, "math?");
+
+//  Memory locations within the same cache line are subject to constructive
+//  interference, also known as true sharing, which is when accesses to some
+//  memory locations induce all memory locations within the same cache line to
+//  be cached, benefiting subsequent accesses to different memory locations
+//  within the same cache line and heping performance.
+//
+//  mimic: std::hardware_constructive_interference_size, C++17
+constexpr std::size_t hardware_constructive_interference_size = 64;
+static_assert(hardware_constructive_interference_size >= max_align_v, "math?");
+
+//  A value corresponding to hardware_constructive_interference_size but which
+//  may be used with alignas, since hardware_constructive_interference_size may
+//  be too large on some platforms to be used with alignas.
+constexpr std::size_t cacheline_align_v = has_extended_alignment
+    ? hardware_constructive_interference_size
+    : max_align_v;
+struct alignas(cacheline_align_v) cacheline_align_t {};
+
+/// valid_align_value
+///
+/// Returns whether an alignment value is valid. Valid alignment values are
+/// powers of two representable as std::uintptr_t, with possibly additional
+/// context-specific restrictions that are not checked here.
+struct valid_align_value_fn {
+  static_assert(sizeof(std::size_t) <= sizeof(std::uintptr_t));
+  constexpr bool operator()(std::size_t align) const noexcept {
+    return align && !(align & (align - 1));
+  }
+  constexpr bool operator()(std::align_val_t align) const noexcept {
+    return operator()(static_cast<std::size_t>(align));
+  }
+};
+inline constexpr valid_align_value_fn valid_align_value;
+
+/// align_floor
+/// align_floor_fn
+///
+/// Returns pointer rounded down to the given alignment.
+struct align_floor_fn {
+  constexpr std::uintptr_t operator()(
+      std::uintptr_t x, std::size_t alignment) const {
+    assert(valid_align_value(alignment));
+    return x & ~(alignment - 1);
+  }
+
+  template <typename T>
+  T* operator()(T* x, std::size_t alignment) const {
+    auto asUint = reinterpret_cast<std::uintptr_t>(x);
+    asUint = (*this)(asUint, alignment);
+    return reinterpret_cast<T*>(asUint);
+  }
+};
+inline constexpr align_floor_fn align_floor;
+
+/// align_ceil
+/// align_ceil_fn
+///
+/// Returns pointer rounded up to the given alignment.
+struct align_ceil_fn {
+  constexpr std::uintptr_t operator()(
+      std::uintptr_t x, std::size_t alignment) const {
+    assert(valid_align_value(alignment));
+    auto alignmentAsInt = static_cast<std::intptr_t>(alignment);
+    return (x + alignmentAsInt - 1) & (-alignmentAsInt);
+  }
+
+  template <typename T>
+  T* operator()(T* x, std::size_t alignment) const {
+    auto asUint = reinterpret_cast<std::uintptr_t>(x);
+    asUint = (*this)(asUint, alignment);
+    return reinterpret_cast<T*>(asUint);
+  }
+};
+inline constexpr align_ceil_fn align_ceil;
+
+} // namespace folly

package/external/folly/folly/lang/Aligned.h

@@ -0,0 +1,92 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <cstddef>
+#include <type_traits>
+#include <utility>
+
+#include <folly/Utility.h>
+#include <folly/lang/Align.h>
+
+namespace folly {
+
+template <typename T, std::size_t Align>
+class aligned {
+  static_assert(!(Align & (Align - 1)), "alignment not a power of two");
+  static_assert(alignof(T) <= Align, "alignment too small");
+
+ public:
+  using alignment = index_constant<Align>;
+  using value_type = T;
+
+  aligned() = default;
+  aligned(aligned const&) = default;
+  aligned(aligned&&) = default;
+  template <
+      typename S = T,
+      std::enable_if_t<std::is_copy_constructible<S>::value, int> = 0>
+  aligned(T const& value) noexcept(std::is_nothrow_copy_constructible<T>::value)
+      : value_(value) {}
+  template <
+      typename S = T,
+      std::enable_if_t<std::is_move_constructible<S>::value, int> = 0>
+  aligned(T&& value) noexcept(std::is_nothrow_move_constructible<T>::value)
+      : value_(static_cast<T&&>(value)) {}
+  template <
+      typename... A,
+      std::enable_if_t<std::is_constructible<T, A...>::value, int> = 0>
+  explicit aligned(std::in_place_t, A&&... a) noexcept(
+      std::is_nothrow_constructible<T, A...>::value)
+      : value_(static_cast<A&&>(a)...) {}
+
+  aligned& operator=(aligned const&) = default;
+  aligned& operator=(aligned&&) = default;
+  template <
+      typename S = T,
+      std::enable_if_t<std::is_copy_assignable<S>::value, int> = 0>
+  aligned& operator=(T const& value) noexcept(
+      std::is_nothrow_copy_assignable<T>::value) {
+    value_ = value;
+    return *this;
+  }
+  template <
+      typename S = T,
+      std::enable_if_t<std::is_move_assignable<S>::value, int> = 0>
+  aligned& operator=(T&& value) noexcept(
+      std::is_nothrow_move_assignable<T>::value) {
+    value_ = std::move(value);
+    return *this;
+  }
+
+  T* get() noexcept { return &value_; }
+  T const* get() const noexcept { return &value_; }
+  T* operator->() noexcept { return &value_; }
+  T const* operator->() const noexcept { return &value_; }
+  T& operator*() noexcept { return value_; }
+  T const& operator*() const noexcept { return value_; }
+
+ private:
+  alignas(Align) T value_;
+};
+
+template <typename T>
+using cacheline_aligned = aligned<
+    T,
+    (cacheline_align_v < alignof(T) ? alignof(T) : cacheline_align_v)>;
+
+} // namespace folly

package/external/folly/folly/lang/Assume.h

@@ -0,0 +1,82 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <folly/Portability.h>
+#include <folly/lang/Hint.h>
+
+namespace folly {
+
+/**
+ * assume*() functions can be used to fine-tune optimizations or suppress
+ * warnings when certain conditions are provably true, but the compiler is not
+ * able to prove them.
+ *
+ * This is different from assertions: an assertion will place an explicit check
+ * that the condition is true, and abort the program if the condition is not
+ * verified. Calling assume*() with a condition that is not true at runtime
+ * is undefined behavior: for example, it may or may not result in a crash,
+ * silently corrupt memory, or jump to a random code path.
+ *
+ * These functions should only be used on conditions that are provable internal
+ * logic invariants; they cannot be used safely if the condition depends on
+ * external inputs or data. To detect unexpected conditions that *can* happen,
+ * an assertion or exception should be used.
+ */
+
+/**
+ * assume(cond) informs the compiler that cond can be assumed true. If cond is
+ * not true at runtime the behavior is undefined.
+ *
+ * The typical use case is to allow the compiler exploit data structure
+ * invariants that can trigger better optimizations, for example to eliminate
+ * unnecessary bounds checks in a called function. It is recommended to check
+ * the generated code or run microbenchmarks to assess whether it is actually
+ * effective.
+ *
+ * The semantics are similar to clang's __builtin_assume(), but intentionally
+ * implemented as a function to force the evaluation of its argument, contrary
+ * to the builtin, which cannot used with expressions that have side-effects.
+ */
+FOLLY_ALWAYS_INLINE void assume(bool cond) {
+  compiler_may_unsafely_assume(cond);
+}
+
+/**
+ * assume_unreachable() informs the compiler that the statement is not reachable
+ * at runtime. It is undefined behavior if the statement is actually reached.
+ *
+ * Common use cases are to suppress a warning when the compiler cannot prove
+ * that the end of a non-void function is not reachable, or to optimize the
+ * evaluation of switch/case statements when all the possible values are
+ * provably enumerated.
+ */
+[[noreturn]] FOLLY_ALWAYS_INLINE void assume_unreachable() {
+  compiler_may_unsafely_assume_unreachable();
+}
+
+} // namespace folly
+
+/**
+ * Inform the compiler that the statement is not reachable at runtime, and
+ * disable compiler warnings.
+ */
+#define FOLLY_ASSUME_UNREACHABLE()                  \
+  FOLLY_PUSH_WARNING                                \
+  FOLLY_CLANG_DISABLE_WARNING("-Wunreachable-code") \
+  ::folly::assume_unreachable();                    \
+  FOLLY_POP_WARNING

package/external/folly/folly/lang/BUCK

@@ -0,0 +1,287 @@
+load("@fbcode_macros//build_defs:cpp_library.bzl", "cpp_library")
+
+oncall("fbcode_entropy_wardens_folly")
+
+cpp_library(
+    name = "access",
+    headers = ["Access.h"],
+    exported_deps = [
+        "//folly/functional:invoke",
+    ],
+)
+
+cpp_library(
+    name = "align",
+    headers = ["Align.h"],
+    exported_deps = [
+        "//folly:portability",
+        "//folly:traits",
+    ],
+)
+
+cpp_library(
+    name = "aligned",
+    headers = ["Aligned.h"],
+    exported_deps = [
+        ":align",
+        "//folly:utility",
+    ],
+)
+
+cpp_library(
+    name = "assume",
+    headers = ["Assume.h"],
+    exported_deps = [
+        ":hint",
+        "//folly:portability",
+    ],
+)
+
+cpp_library(
+    name = "badge",
+    headers = ["Badge.h"],
+    exported_deps = [
+        "//folly:traits",
+    ],
+)
+
+cpp_library(
+    name = "bits",
+    headers = ["Bits.h"],
+    exported_deps = [
+        ":assume",
+        ":c_string",
+        "//folly:constexpr_math",
+        "//folly:portability",
+        "//folly:traits",
+        "//folly:utility",
+        "//folly/portability:builtins",
+    ],
+)
+
+cpp_library(
+    name = "bits_class",
+    headers = ["BitsClass.h"],
+    exported_deps = [
+        "//folly:portability",
+        "//folly:range",
+        "//folly/lang:bits",
+    ],
+    exported_external_deps = [
+        "glog",
+    ],
+)
+
+cpp_library(
+    name = "builtin",
+    headers = ["Builtin.h"],
+    exported_deps = [
+        "//folly:portability",
+    ],
+)
+
+cpp_library(
+    name = "c_array",
+    headers = ["CArray.h"],
+)
+
+cpp_library(
+    name = "c_string",
+    srcs = ["CString.cpp"],
+    headers = ["CString.h"],
+    deps = [
+        "//folly:cpp_attributes",
+        "//folly/functional:invoke",
+    ],
+    exported_deps = [
+        "//folly:c_portability",
+    ],
+)
+
+cpp_library(
+    name = "cast",
+    headers = ["Cast.h"],
+    exported_deps = [
+        ":safe_assert",
+        "//folly:portability",
+        "//folly:traits",
+    ],
+)
+
+cpp_library(
+    name = "checked_math",
+    headers = ["CheckedMath.h"],
+    exported_deps = [
+        "//folly:c_portability",
+        "//folly:likely",
+    ],
+)
+
+cpp_library(
+    name = "customization_point",
+    headers = ["CustomizationPoint.h"],
+    exported_deps = [
+        ":static_const",
+        "//folly:portability",
+    ],
+)
+
+cpp_library(
+    name = "exception",
+    srcs = ["Exception.cpp"],
+    headers = ["Exception.h"],
+    linker_flags = select({
+        "DEFAULT": [],
+        "ovr_config//os:macos": ["-lc++abi"],
+    }),
+    deps = [
+        ":new",
+    ],
+    exported_deps = [
+        ":assume",
+        ":safe_assert",
+        ":thunk",
+        ":type_info",
+        "//folly:c_portability",
+        "//folly:cpp_attributes",
+        "//folly:likely",
+        "//folly:portability",
+        "//folly:traits",
+        "//folly:utility",
+    ],
+)
+
+cpp_library(
+    name = "extern",
+    headers = ["Extern.h"],
+)
+
+cpp_library(
+    name = "keep",
+    headers = ["Keep.h"],
+    exported_deps = [
+        "//folly:c_portability",
+    ],
+)
+
+cpp_library(
+    name = "hint",
+    headers = [
+        "Hint.h",
+        "Hint-inl.h",
+    ],
+    exported_deps = [
+        ":safe_assert",
+        "//folly:portability",
+        "//folly:traits",
+    ],
+)
+
+cpp_library(
+    name = "new",
+    headers = ["New.h"],
+    exported_deps = [
+        "//folly:cpp_attributes",
+        "//folly:portability",
+        "//folly/functional:invoke",
+    ],
+)
+
+cpp_library(
+    name = "ordering",
+    headers = ["Ordering.h"],
+    exported_deps = [
+        ":exception",
+    ],
+)
+
+cpp_library(
+    name = "propagate_const",
+    headers = ["PropagateConst.h"],
+    exported_deps = [
+        "//folly:traits",
+        "//folly:utility",
+    ],
+)
+
+cpp_library(
+    name = "rvalue_reference_wrapper",
+    headers = ["RValueReferenceWrapper.h"],
+)
+
+cpp_library(
+    name = "safe_assert",
+    srcs = ["SafeAssert.cpp"],
+    headers = ["SafeAssert.h"],
+    deps = [
+        ":to_ascii",
+        "//folly/detail:file_util_detail",
+        "//folly/portability:sys_types",
+        "//folly/portability:windows",
+    ],
+    exported_deps = [
+        ":c_array",
+        "//folly:cpp_attributes",
+        "//folly:portability",
+        "//folly:preprocessor",
+    ],
+)
+
+cpp_library(
+    name = "static_const",
+    headers = ["StaticConst.h"],
+    exported_deps = [
+        "//folly:portability",
+    ],
+)
+
+cpp_library(
+    name = "thunk",
+    headers = ["Thunk.h"],
+    exported_deps = [
+        ":new",
+        "//folly:utility",
+    ],
+)
+
+cpp_library(
+    name = "to_ascii",
+    srcs = ["ToAscii.cpp"],
+    headers = ["ToAscii.h"],
+    exported_deps = [
+        ":align",
+        ":c_array",
+        "//folly:constexpr_math",
+        "//folly:likely",
+        "//folly:portability",
+        "//folly:utility",
+        "//folly/portability:builtins",
+    ],
+)
+
+cpp_library(
+    name = "type_info",
+    headers = ["TypeInfo.h"],
+    exported_deps = [
+        "//folly:cpp_attributes",
+        "//folly:portability",
+    ],
+)
+
+cpp_library(
+    name = "pretty",
+    headers = ["Pretty.h"],
+    exported_deps = [
+        ":c_array",
+        "//folly:portability",
+    ],
+)
+
+cpp_library(
+    name = "uncaught_exceptions",
+    srcs = ["UncaughtExceptions.cpp"],
+    headers = ["UncaughtExceptions.h"],
+    exported_deps = [
+        ":exception",
+    ],
+)