react-native-windows 0.83.2 → 0.83.3

package/external/folly/folly/memory/ReentrantAllocator.cpp

@@ -0,0 +1,162 @@
+/*
+ * 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.
+ */
+
+#include <folly/memory/ReentrantAllocator.h>
+
+#include <new>
+#include <utility>
+
+#include <folly/lang/Bits.h>
+#include <folly/lang/SafeAssert.h>
+#include <folly/portability/SysMman.h>
+
+namespace folly {
+
+namespace {
+
+max_align_t dummy; // return value for zero-sized allocations
+
+void* reentrant_allocate(std::size_t const n) noexcept {
+  FOLLY_SAFE_CHECK(n, "zero-sized");
+  auto const prot = PROT_READ | PROT_WRITE;
+  auto const flags = MAP_ANONYMOUS | MAP_PRIVATE;
+  auto const addr = ::mmap(nullptr, n, prot, flags, -1, 0);
+  FOLLY_SAFE_PCHECK(addr != MAP_FAILED, "mmap failed");
+  return addr;
+}
+
+void reentrant_deallocate(void* const p, std::size_t const n) noexcept {
+  FOLLY_SAFE_CHECK(p, "null-pointer");
+  FOLLY_SAFE_CHECK(n, "zero-sized");
+  auto const err = ::munmap(p, n);
+  FOLLY_SAFE_PCHECK(!err, "munmap failed");
+}
+
+} // namespace
+
+namespace detail {
+
+reentrant_allocator_base::reentrant_allocator_base(
+    reentrant_allocator_options const& options) noexcept {
+  meta_ = static_cast<meta_t*>(reentrant_allocate(sizeof(meta_t)));
+  ::new (meta_) meta_t(options);
+}
+
+reentrant_allocator_base::reentrant_allocator_base(
+    reentrant_allocator_base const& that) noexcept {
+  meta_ = that.meta_;
+  meta_->refs.fetch_add(1, std::memory_order_relaxed);
+}
+
+reentrant_allocator_base& reentrant_allocator_base::operator=(
+    reentrant_allocator_base const& that) noexcept {
+  if (this != &that) {
+    if (meta_->refs.fetch_sub(1, std::memory_order_acq_rel) - 1 == 0) {
+      obliterate();
+    }
+    meta_ = that.meta_;
+    meta_->refs.fetch_add(1, std::memory_order_relaxed);
+  }
+  return *this;
+}
+
+reentrant_allocator_base::~reentrant_allocator_base() {
+  if (meta_->refs.fetch_sub(1, std::memory_order_acq_rel) - 1 == 0) {
+    obliterate();
+  }
+}
+
+void* reentrant_allocator_base::allocate(
+    std::size_t const n, std::size_t const a) noexcept {
+  if (!n) {
+    return &dummy;
+  }
+  //  large requests are handled directly
+  if (n >= meta_->large_size) {
+    return reentrant_allocate(n);
+  }
+  //  small requests are handled from the shared arena list:
+  //  * if the list is empty or the list head has insufficient space, c/x a new
+  //    list head, starting over
+  //  * then c/x the list head size to the new size, starting over on failure
+  auto const block_size = meta_->block_size;
+  //  load head - non-const because used in c/x below
+  auto head = meta_->head.load(std::memory_order_acquire);
+  while (true) {
+    //  load size - non-const because used in c/x below
+    //  size is where the prev allocation ends, if any
+    auto size = head //
+        ? head->size.load(std::memory_order_acquire)
+        : block_size;
+    //  offset is where the next allocation starts, and is aligned as a
+    auto const offset = (size + a - 1) & ~(a - 1);
+    //  if insufficient space in current segment or no current segment at all
+    if (offset + n > block_size || !head) {
+      //  mmap a new segment and try to c/x it in to be the segment list head
+      auto const newhead = static_cast<node_t*>(reentrant_allocate(block_size));
+      ::new (newhead) node_t(head);
+      auto const exchanged = meta_->head.compare_exchange_weak(
+          head, newhead, std::memory_order_release, std::memory_order_relaxed);
+      if (!exchanged) {
+        //  lost the race - munmap the new segment
+        reentrant_deallocate(newhead, block_size);
+      }
+      //  start over, but optimistically with a suitable head
+      head = exchanged ? newhead : meta_->head.load(std::memory_order_acquire);
+      continue;
+    }
+    //  compute the new size and try to c/x it in to be the head segment size
+    auto const newsize = offset + n;
+    auto const exchanged = head->size.compare_exchange_weak(
+        size, newsize, std::memory_order_release, std::memory_order_relaxed);
+    if (!exchanged) {
+      //  lost the race - start over
+      continue;
+    }
+    return reinterpret_cast<char*>(head) + offset;
+  }
+}
+
+void reentrant_allocator_base::deallocate(
+    void* const p, std::size_t const n) noexcept {
+  if (p == &dummy) {
+    FOLLY_SAFE_CHECK(n == 0, "unexpected non-zero size");
+    return;
+  }
+  if (!n || !p) {
+    return;
+  }
+  //  large requests are handled directly
+  if (n >= meta_->large_size) {
+    reentrant_deallocate(p, n);
+    return;
+  }
+  //  small requests are deferred to allocator destruction, so no-op here
+}
+
+void reentrant_allocator_base::obliterate() noexcept {
+  auto head = meta_->head.load(std::memory_order_acquire);
+  while (head != nullptr) {
+    auto const prev = std::exchange(head, head->next);
+    reentrant_deallocate(prev, meta_->block_size);
+  }
+  reentrant_deallocate(meta_, sizeof(meta_));
+  meta_ = nullptr;
+}
+
+} // namespace detail
+
+} // namespace folly

package/external/folly/folly/memory/ReentrantAllocator.h

@@ -0,0 +1,261 @@
+/*
+ * 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 <atomic>
+#include <cstddef>
+#include <limits>
+#include <memory>
+#include <type_traits>
+
+#include <folly/Portability.h>
+
+namespace folly {
+
+class reentrant_allocator_options {
+ public:
+  //  block_size_lg
+  //
+  //  The log2 of the block size, which is the size of the blocks from which
+  //  small allocations are returned.
+  std::size_t block_size_lg() const noexcept { return block_size_lg_; }
+  reentrant_allocator_options& block_size_lg(std::size_t const value) noexcept {
+    block_size_lg_ = value;
+    return *this;
+  }
+
+  //  large_size_lg
+  //
+  //  The log2 of the large size, which is the size starting at which
+  //  allocations are considered large and are returned directly from mmap.
+  std::size_t large_size_lg() const noexcept { return large_size_lg_; }
+  reentrant_allocator_options& large_size_lg(std::size_t const value) noexcept {
+    large_size_lg_ = value;
+    return *this;
+  }
+
+ private:
+  std::size_t block_size_lg_ = 16;
+  std::size_t large_size_lg_ = 12;
+};
+
+namespace detail {
+
+class reentrant_allocator_base {
+ public:
+  explicit reentrant_allocator_base(
+      reentrant_allocator_options const& options) noexcept;
+  reentrant_allocator_base(reentrant_allocator_base const& that) noexcept;
+  reentrant_allocator_base& operator=(
+      reentrant_allocator_base const& that) noexcept;
+  ~reentrant_allocator_base();
+
+  void* allocate(std::size_t n, std::size_t a) noexcept;
+  void deallocate(void* p, std::size_t n) noexcept;
+
+  std::size_t max_size() const noexcept {
+    return std::numeric_limits<std::size_t>::max();
+  }
+
+  friend bool operator==(
+      reentrant_allocator_base const& a,
+      reentrant_allocator_base const& b) noexcept {
+    return a.meta_ == b.meta_;
+  }
+  friend bool operator!=(
+      reentrant_allocator_base const& a,
+      reentrant_allocator_base const& b) noexcept {
+    return a.meta_ != b.meta_;
+  }
+
+ private:
+  //  For small sizes, maintain a shared list of segments. Segments are each
+  //  allocated via mmap, chained together into a list, and collectively
+  //  refcounted. When the last copy of the allocator is destroyed, segments
+  //  are deallocated all at once via munmap. Node is the header data
+  //  structure prefixing each segment while Meta is the data structure
+  //  representing shared ownership of the segment list. Serve allocations
+  //  from the head segment if it exists and has space, otherwise mmap and
+  //  chain a new segment and serve allocations from it. Serve deallocations
+  //  by doing nothing at all.
+  struct node_t {
+    node_t* next = nullptr;
+    std::atomic<std::size_t> size{sizeof(node_t)};
+    explicit node_t(node_t* next_) noexcept : next{next_} {}
+  };
+
+  //  The shared state which all copies of the allocator share.
+  struct meta_t {
+    //  Small allocations are served from block-sized segments.
+    std::size_t const block_size = 0;
+    //  Large allocations are served directly.
+    std::size_t const large_size = 0;
+    //  The refcount is atomic to permit some copies of the allocator to be
+    //  destroyed concurrently with uses of other copies of the allocator.
+    //  This lets an allocator be copied in a signal handler and the copy
+    //  be destroyed outside the signal handler.
+    std::atomic<std::size_t> refs{1};
+    //  The segment list head. All small allocations happen via the head node
+    //  if possible, or via a new head node otherwise.
+    std::atomic<node_t*> head{nullptr};
+
+    explicit meta_t(reentrant_allocator_options const& options) noexcept
+        : block_size{std::size_t(1) << options.block_size_lg()},
+          large_size{std::size_t(1) << options.large_size_lg()} {}
+  };
+
+  //  Deduplicates code between dtor and copy-assignment.
+  void obliterate() noexcept;
+
+  //  The allocator has all state in the shared state, keeping only a pointer.
+  meta_t* meta_{nullptr};
+};
+
+} // namespace detail
+
+//  reentrant_allocator
+//
+//  A reentrant mmap-based allocator.
+//
+//  Safety:
+//  * multi-thread-safe
+//  * async-signal-safe
+//
+//  The basic approach is in two parts:
+//  * For large sizes, serve allocations and deallocations directly via mmap and
+//    munmap and without any extra tracking.
+//  * For small sizes, serve allocations from a refcounted shared list of
+//    segments and defer deallocations to amortize calls to mmap and munmap - in
+//    other words, a shared arena list.
+//
+//  Large allocations are aligned to page boundaries, even if the type's natural
+//  alignment is larger.
+//
+//  Assumptions:
+//  * The mmap and munmap libc functions are async-signal-safe in practice even
+//    though POSIX does not require them to be.
+//  * The instances of std::atomic over size_t and pointer types are lock-free
+//    and operations on them are async-signal-safe.
+template <typename T>
+class reentrant_allocator : private detail::reentrant_allocator_base {
+ private:
+  template <typename>
+  friend class reentrant_allocator;
+
+  using base = detail::reentrant_allocator_base;
+
+  template <typename S>
+  using if_is_not_void = std::enable_if_t<!std::is_void<S>::value, int>;
+
+  template <typename S>
+  using undeducible = std::enable_if_t<true, S>;
+
+ public:
+  using value_type = T;
+  using pointer = T*;
+  using const_pointer = T const*;
+  using reference = std::add_lvalue_reference_t<T>;
+  using const_reference = std::add_lvalue_reference_t<T const>;
+  using size_type = std::size_t;
+  using difference_type = std::ptrdiff_t;
+
+  template <typename U>
+  struct rebind {
+    using other = reentrant_allocator<U>;
+  };
+
+  using base::base;
+
+  template <typename U, std::enable_if_t<!std::is_same<U, T>::value, int> = 0>
+  FOLLY_ERASE /* implicit */ reentrant_allocator(
+      reentrant_allocator<U> const& that) noexcept
+      : base{that} {}
+
+  //  The following members make use of a few clever tricks in order to match
+  //  the availabilities of the corresponding members of std::allocator:
+  //  * allocate
+  //  * deallocate
+  //  * max_size
+  //  * address
+  //
+  //  The clever tricks include:
+  //  * typename... to make it impossible for call-sites to override the
+  //    defaults for the following template params.
+  //  * typename S = T to enable member SFINAE over S since T is not a member
+  //    template param and therefore SFINAE over T is not possible.
+  //  * if_is_not_void<S> = 0 to enable members only for non-void instances.
+  //    A method being enabled when C is shorthand for the method participating
+  //    in overload resolution when C.
+  //  * undeducible<S>& to enforce that S, a member template param defaulted to
+  //    T, is not deducible from the template arg and therefore must only be T.
+
+  //  allocate
+  template <typename..., typename S = T, if_is_not_void<S> = 0>
+  FOLLY_NODISCARD FOLLY_ERASE T* allocate(std::size_t n) {
+    return static_cast<T*>(base::allocate(n * sizeof(T), alignof(T)));
+  }
+
+  //  deallocate
+  template <typename..., typename S = T, if_is_not_void<S> = 0>
+  FOLLY_ERASE void deallocate(T* p, std::size_t n) {
+    base::deallocate(p, n * sizeof(T));
+  }
+
+  //  max_size
+  //
+  //  Deprecated in C++17. Removed in C++20.
+  template <typename..., typename S = T, if_is_not_void<S> = 0>
+  FOLLY_ERASE std::size_t max_size() const noexcept {
+    return base::max_size() / sizeof(T);
+  }
+
+  //  address
+  //
+  //  Deprecated in C++17. Removed in C++20.
+  template <typename..., typename S = T>
+  FOLLY_ERASE T* address(undeducible<S>& v) const noexcept {
+    return std::addressof(v);
+  }
+  template <typename..., typename S = T>
+  FOLLY_ERASE T const* address(undeducible<S> const& v) const noexcept {
+    return std::addressof(v);
+  }
+
+  template <typename A, typename B>
+  friend bool operator==(
+      reentrant_allocator<A> const& a,
+      reentrant_allocator<B> const& b) noexcept;
+  template <typename A, typename B>
+  friend bool operator!=(
+      reentrant_allocator<A> const& a,
+      reentrant_allocator<B> const& b) noexcept;
+};
+
+template <typename A, typename B>
+FOLLY_ERASE bool operator==(
+    reentrant_allocator<A> const& a, reentrant_allocator<B> const& b) noexcept {
+  using base = detail::reentrant_allocator_base;
+  return static_cast<base const&>(a) == static_cast<base const&>(b);
+}
+template <typename A, typename B>
+FOLLY_ERASE bool operator!=(
+    reentrant_allocator<A> const& a, reentrant_allocator<B> const& b) noexcept {
+  using base = detail::reentrant_allocator_base;
+  return static_cast<base const&>(a) != static_cast<base const&>(b);
+}
+
+} // namespace folly

package/external/folly/folly/memory/SanitizeAddress.cpp

@@ -0,0 +1,75 @@
+/*
+ * 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.
+ */
+
+#include <folly/memory/SanitizeAddress.h>
+
+#include <folly/lang/Extern.h>
+
+//  Address Sanitizer interface may be found at:
+//    https://github.com/llvm/llvm-project/blob/main/compiler-rt/include/sanitizer/asan_interface.h
+//    https://github.com/llvm/llvm-project/blob/main/compiler-rt/include/sanitizer/common_interface_defs.h
+extern "C" void __asan_poison_memory_region(void const volatile*, std::size_t);
+extern "C" void __asan_unpoison_memory_region(
+    void const volatile*, std::size_t);
+extern "C" void* __asan_region_is_poisoned(void*, std::size_t);
+extern "C" int __asan_address_is_poisoned(void const volatile*);
+extern "C" void __sanitizer_start_switch_fiber(
+    void**, void const*, std::size_t);
+extern "C" void __sanitizer_finish_switch_fiber(
+    void*, void const**, std::size_t*);
+
+namespace {
+
+FOLLY_CREATE_EXTERN_ACCESSOR(
+    asan_poison_memory_region_access_v, __asan_poison_memory_region);
+FOLLY_CREATE_EXTERN_ACCESSOR(
+    asan_unpoison_memory_region_access_v, __asan_unpoison_memory_region);
+FOLLY_CREATE_EXTERN_ACCESSOR(
+    asan_region_is_poisoned_access_v, __asan_region_is_poisoned);
+FOLLY_CREATE_EXTERN_ACCESSOR(
+    asan_address_is_poisoned_access_v, __asan_address_is_poisoned);
+FOLLY_CREATE_EXTERN_ACCESSOR(
+    sanitizer_start_switch_fiber_access_v, __sanitizer_start_switch_fiber);
+FOLLY_CREATE_EXTERN_ACCESSOR(
+    sanitizer_finish_switch_fiber_access_v, __sanitizer_finish_switch_fiber);
+
+constexpr bool E = folly::kIsLibrarySanitizeAddress;
+
+} // namespace
+
+namespace folly {
+namespace detail {
+
+FOLLY_STORAGE_CONSTEXPR asan_mark_memory_region_t* const
+    asan_poison_memory_region_v = asan_poison_memory_region_access_v<E>;
+
+FOLLY_STORAGE_CONSTEXPR asan_mark_memory_region_t* const
+    asan_unpoison_memory_region_v = asan_unpoison_memory_region_access_v<E>;
+
+FOLLY_STORAGE_CONSTEXPR asan_region_is_poisoned_t* const
+    asan_region_is_poisoned_v = asan_region_is_poisoned_access_v<E>;
+
+FOLLY_STORAGE_CONSTEXPR asan_address_is_poisoned_t* const
+    asan_address_is_poisoned_v = asan_address_is_poisoned_access_v<E>;
+
+FOLLY_STORAGE_CONSTEXPR sanitizer_start_switch_fiber_t* const
+    sanitizer_start_switch_fiber_v = sanitizer_start_switch_fiber_access_v<E>;
+
+FOLLY_STORAGE_CONSTEXPR sanitizer_finish_switch_fiber_t* const
+    sanitizer_finish_switch_fiber_v = sanitizer_finish_switch_fiber_access_v<E>;
+
+} // namespace detail
+} // namespace folly

package/external/folly/folly/memory/SanitizeAddress.h

@@ -0,0 +1,117 @@
+/*
+ * 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>
+
+namespace folly {
+
+namespace detail {
+
+using asan_mark_memory_region_t = void(void const volatile*, std::size_t);
+using asan_region_is_poisoned_t = void*(void* ptr, std::size_t len);
+using asan_address_is_poisoned_t = int(void const volatile*);
+using sanitizer_start_switch_fiber_t = void(void**, void const*, std::size_t);
+using sanitizer_finish_switch_fiber_t = void(void*, void const**, std::size_t*);
+
+extern asan_mark_memory_region_t* const asan_poison_memory_region_v;
+extern asan_mark_memory_region_t* const asan_unpoison_memory_region_v;
+extern asan_region_is_poisoned_t* const asan_region_is_poisoned_v;
+extern asan_address_is_poisoned_t* const asan_address_is_poisoned_v;
+extern sanitizer_start_switch_fiber_t* const sanitizer_start_switch_fiber_v;
+extern sanitizer_finish_switch_fiber_t* const sanitizer_finish_switch_fiber_v;
+
+} // namespace detail
+
+//  asan_poison_memory_region
+//
+//  Marks the memory region as poisoned.
+//
+//  When Address Sanitizer is in force and a memory region is marked poisoned,
+//  accesses to any part of the memory region will trap.
+//
+//  mimic: __asan_poison_memory_region, llvm compiler-rt
+FOLLY_ALWAYS_INLINE static void asan_poison_memory_region(
+    void const volatile* const addr, std::size_t const size) {
+  auto fun = detail::asan_poison_memory_region_v;
+  return kIsSanitizeAddress && fun ? fun(addr, size) : void();
+}
+
+//  asan_unpoison_memory_region
+//
+//  Marks the memory region as not poisoned anymore.
+//
+//  When Address Sanitizer is in force and a memory region is marked poisoned,
+//  accesses to any part of the memory region will trap.
+//
+//  mimic: __asan_poison_memory_region, llvm compiler-rt
+FOLLY_ALWAYS_INLINE static void asan_unpoison_memory_region(
+    void const volatile* const addr, std::size_t const size) {
+  auto fun = detail::asan_unpoison_memory_region_v;
+  return kIsSanitizeAddress && fun ? fun(addr, size) : void();
+}
+
+//  asan_region_is_poisoned
+//
+//  Returns the address of the first byte in the region known to be poisoned,
+//  or nullptr if there is no such byte. If Address Sanitizer is unavailable,
+//  always returns nullptr.
+//
+//  mimic: __asan_region_is_poisoned, llvm compiler-rt
+FOLLY_ALWAYS_INLINE static void* asan_region_is_poisoned(
+    void* const addr, std::size_t const size) {
+  auto fun = detail::asan_region_is_poisoned_v;
+  return kIsSanitizeAddress && fun ? fun(addr, size) : nullptr;
+}
+
+//  asan_address_is_poisoned
+//
+//  Returns whether the address is known to be poisoned. If Address Sanitizer is
+//  unavailable, always returns 0.
+//
+//  mimic: __asan_address_is_poisoned, llvm compiler-rt
+FOLLY_ALWAYS_INLINE static int asan_address_is_poisoned(
+    void const volatile* const addr) {
+  auto fun = detail::asan_address_is_poisoned_v;
+  return kIsSanitizeAddress && fun ? fun(addr) : 0;
+}
+
+//  sanitizer_start_switch_fiber
+//
+//  Notifies Address Sanitizer, if available, that a switch to a different stack
+//  is imminent.
+//
+//  mimic: __sanitizer_start_switch_fiber, llvm compiler-rt
+FOLLY_ALWAYS_INLINE static void sanitizer_start_switch_fiber(
+    void** const save, void const* const bottom, std::size_t const size) {
+  auto fun = detail::sanitizer_start_switch_fiber_v;
+  return kIsSanitizeAddress && fun ? fun(save, bottom, size) : void();
+}
+
+//  sanitizer_finish_switch_fiber
+//
+//  Notifies Address Sanitizer, if available, that a switch to a different stack
+//  is complete.
+//
+//  mimic: __sanitizer_finish_switch_fiber, llvm compiler-rt
+FOLLY_ALWAYS_INLINE static void sanitizer_finish_switch_fiber(
+    void* const save, void const** const bottom, std::size_t* const size) {
+  auto fun = detail::sanitizer_finish_switch_fiber_v;
+  return kIsSanitizeAddress && fun ? fun(save, bottom, size) : void();
+}
+
+} // namespace folly