react-native-windows 0.81.32 → 0.81.35

package/external/folly/folly/memory/SanitizeLeak.cpp

@@ -0,0 +1,119 @@
+/*
+ * 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/SanitizeLeak.h>
+
+#include <mutex>
+#include <numeric>
+#include <shared_mutex>
+#include <unordered_map>
+
+#include <folly/lang/Extern.h>
+
+//  Leak Sanitizer interface may be found at:
+//    https://github.com/llvm/llvm-project/blob/main/compiler-rt/include/sanitizer/lsan_interface.h
+extern "C" void __lsan_ignore_object(void const*);
+extern "C" void __lsan_register_root_region(void const*, std::size_t);
+extern "C" void __lsan_unregister_root_region(void const*, std::size_t);
+
+namespace {
+
+FOLLY_CREATE_EXTERN_ACCESSOR( //
+    lsan_ignore_object_access_v,
+    __lsan_ignore_object);
+FOLLY_CREATE_EXTERN_ACCESSOR( //
+    lsan_register_root_region_access_v,
+    __lsan_register_root_region);
+FOLLY_CREATE_EXTERN_ACCESSOR( //
+    lsan_unregister_root_region_access_v,
+    __lsan_unregister_root_region);
+
+constexpr bool E = folly::kIsLibrarySanitizeAddress;
+
+// the Windows runtime libraries do not have lsan functions
+constexpr bool EnW = E && !folly::kIsWindows;
+
+} // namespace
+
+namespace folly {
+
+namespace detail {
+
+FOLLY_STORAGE_CONSTEXPR lsan_ignore_object_t* const //
+    lsan_ignore_object_v = lsan_ignore_object_access_v<EnW>;
+FOLLY_STORAGE_CONSTEXPR lsan_register_root_region_t* const //
+    lsan_register_root_region_v = lsan_register_root_region_access_v<EnW>;
+FOLLY_STORAGE_CONSTEXPR lsan_unregister_root_region_t* const //
+    lsan_unregister_root_region_v = lsan_unregister_root_region_access_v<EnW>;
+
+namespace {
+
+struct fake_mutex {
+  [[maybe_unused]] void lock() {}
+  [[maybe_unused]] void unlock() {}
+};
+
+// some hardware targets may not have mutexes
+#if __cpp_lib_shared_mutex >= 201505L
+using mutex_type = std::mutex;
+#else
+using mutex_type = fake_mutex;
+#endif
+
+struct LeakedPtrs {
+  mutex_type mutex;
+  std::unordered_map<void const*, size_t> map;
+
+  static LeakedPtrs& instance() {
+    static auto& ptrs = *new LeakedPtrs();
+    return ptrs;
+  }
+};
+
+} // namespace
+
+void annotate_object_leaked_impl(void const* ptr) {
+  if (ptr == nullptr) {
+    return;
+  }
+  auto& ptrs = LeakedPtrs::instance();
+  std::lock_guard lg(ptrs.mutex);
+  ++ptrs.map[ptr];
+}
+
+void annotate_object_collected_impl(void const* ptr) {
+  if (ptr == nullptr) {
+    return;
+  }
+  auto& ptrs = LeakedPtrs::instance();
+  std::lock_guard lg(ptrs.mutex);
+  if (!--ptrs.map[ptr]) {
+    ptrs.map.erase(ptr);
+  }
+}
+
+size_t annotate_object_count_leaked_uncollected_impl() {
+  auto& ptrs = LeakedPtrs::instance();
+  std::lock_guard lg(ptrs.mutex);
+  return std::accumulate(
+      ptrs.map.begin(),
+      ptrs.map.end(),
+      size_t(0),
+      [](size_t accum, auto const& item) { return accum + item.second; });
+}
+
+} // namespace detail
+} // namespace folly

package/external/folly/folly/memory/SanitizeLeak.h

@@ -0,0 +1,108 @@
+/*
+ * 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 lsan_ignore_object_t = void(void const*);
+using lsan_register_root_region_t = void(void const*, std::size_t);
+using lsan_unregister_root_region_t = void(void const*, std::size_t);
+
+extern lsan_ignore_object_t* const lsan_ignore_object_v;
+extern lsan_register_root_region_t* const lsan_register_root_region_v;
+extern lsan_unregister_root_region_t* const lsan_unregister_root_region_v;
+
+void annotate_object_leaked_impl(void const* ptr);
+void annotate_object_collected_impl(void const* ptr);
+size_t annotate_object_count_leaked_uncollected_impl();
+
+} // namespace detail
+
+//  lsan_ignore_object
+//
+//  Marks an allocation to be treated as a root when Leak Sanitizer scans for
+//  leaked allocations.
+[[maybe_unused]] FOLLY_ALWAYS_INLINE static void lsan_ignore_object(
+    void const* const ptr) {
+  auto fun = detail::lsan_ignore_object_v;
+  return kIsSanitizeAddress && fun ? fun(ptr) : void();
+}
+
+//  lsan_register_root_region
+//
+//  Marks a region as a root for Leak Sanitizer scans.
+[[maybe_unused]] FOLLY_ALWAYS_INLINE static void lsan_register_root_region(
+    void const* const ptr, std::size_t const size) {
+  auto fun = detail::lsan_register_root_region_v;
+  return kIsSanitizeAddress && fun ? fun(ptr, size) : void();
+}
+
+//  lsan_unregister_root_region
+//
+//  Marks a region as a root for Leak Sanitizer scans.
+[[maybe_unused]] FOLLY_ALWAYS_INLINE static void lsan_unregister_root_region(
+    void const* const ptr, std::size_t const size) {
+  auto fun = detail::lsan_unregister_root_region_v;
+  return kIsSanitizeAddress && fun ? fun(ptr, size) : void();
+}
+
+/**
+ * When the current compilation unit is being compiled with ASAN enabled this
+ * function will suppress an intentionally leaked pointer from the LSAN report.
+ * Otherwise, this function is an inlinable no-op.
+ *
+ * NOTE: This function will suppress LSAN leak reporting when the current
+ * compilation unit is being compiled with ASAN, independent of whether folly
+ * itself was compiled with ASAN enabled.
+ */
+[[maybe_unused]] FOLLY_ALWAYS_INLINE static void annotate_object_leaked(
+    void const* ptr) {
+  if (kIsSanitizeAddress) {
+    detail::annotate_object_leaked_impl(ptr);
+  }
+}
+
+/**
+ * Annotate that an object previously passed to annotate_object_leaked() has
+ * been collected, so we should no longer suppress it from the LSAN report.
+ * This function is an inlinable no-op when ASAN is not enabled for the current
+ * compilation unit.
+ */
+[[maybe_unused]] FOLLY_ALWAYS_INLINE static void annotate_object_collected(
+    void const* ptr) {
+  if (kIsSanitizeAddress) {
+    detail::annotate_object_collected_impl(ptr);
+  }
+}
+
+/**
+ * Count how many times objects have been passed to annotate_object_leaked() but
+ * not yet passed to annotate_object_collected().
+ */
+[[maybe_unused]] FOLLY_ALWAYS_INLINE static size_t
+annotate_object_count_leaked_uncollected() {
+  if (kIsSanitizeAddress) {
+    return detail::annotate_object_count_leaked_uncollected_impl();
+  }
+  return 0;
+}
+
+} // namespace folly

package/external/folly/folly/memory/ThreadCachedArena.cpp

@@ -0,0 +1,53 @@
+/*
+ * 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/ThreadCachedArena.h>
+
+#include <memory>
+
+namespace folly {
+
+ThreadCachedArena::ThreadCachedArena(size_t minBlockSize, size_t maxAlign)
+    : minBlockSize_(minBlockSize),
+      maxAlign_(maxAlign),
+      zombies_(std::in_place, minBlockSize) {}
+
+SysArena* ThreadCachedArena::allocateThreadLocalArena() {
+  auto arena = new SysArena(minBlockSize_, SysArena::kNoSizeLimit, maxAlign_);
+  auto disposer = [this](SysArena* t, TLPDestructionMode mode) {
+    std::unique_ptr<SysArena> tp(t); // ensure it gets deleted
+    if (mode == TLPDestructionMode::THIS_THREAD) {
+      zombify(std::move(*t));
+    }
+  };
+  arena_.reset(arena, disposer);
+  return arena;
+}
+
+void ThreadCachedArena::zombify(SysArena&& arena) {
+  zombies_.wlock()->merge(std::move(arena));
+}
+
+size_t ThreadCachedArena::totalSize() const {
+  size_t result = sizeof(ThreadCachedArena);
+  for (const auto& arena : arena_.accessAllThreads()) {
+    result += arena.totalSize();
+  }
+  result += zombies_.rlock()->totalSize() - sizeof(SysArena);
+  return result;
+}
+
+} // namespace folly

package/external/folly/folly/memory/ThreadCachedArena.h

@@ -0,0 +1,90 @@
+/*
+ * 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 <type_traits>
+
+#include <folly/Likely.h>
+#include <folly/Synchronized.h>
+#include <folly/ThreadLocal.h>
+#include <folly/memory/Arena.h>
+
+namespace folly {
+
+/**
+ * Thread-caching arena: allocate memory which gets freed when the arena gets
+ * destroyed.
+ *
+ * The arena itself allocates memory using malloc() in blocks of
+ * at least minBlockSize bytes.
+ *
+ * For speed, each thread gets its own Arena (see Arena.h); when threads
+ * exit, the Arena gets merged into a "zombie" Arena, which will be deallocated
+ * when the ThreadCachedArena object is destroyed.
+ */
+class ThreadCachedArena {
+ public:
+  explicit ThreadCachedArena(
+      size_t minBlockSize = SysArena::kDefaultMinBlockSize,
+      size_t maxAlign = SysArena::kDefaultMaxAlign);
+
+  void* allocate(size_t size) {
+    SysArena* arena = arena_.get();
+    if (FOLLY_UNLIKELY(!arena)) {
+      arena = allocateThreadLocalArena();
+    }
+
+    return arena->allocate(size);
+  }
+
+  void deallocate(void* /* p */, size_t = 0) {
+    // Deallocate? Never!
+  }
+
+  // Gets the total memory used by the arena
+  size_t totalSize() const;
+
+ private:
+  struct ThreadLocalPtrTag {};
+
+  ThreadCachedArena(const ThreadCachedArena&) = delete;
+  ThreadCachedArena(ThreadCachedArena&&) = delete;
+  ThreadCachedArena& operator=(const ThreadCachedArena&) = delete;
+  ThreadCachedArena& operator=(ThreadCachedArena&&) = delete;
+
+  SysArena* allocateThreadLocalArena();
+
+  // Zombify the blocks in arena, saving them for deallocation until
+  // the ThreadCachedArena is destroyed.
+  void zombify(SysArena&& arena);
+
+  const size_t minBlockSize_;
+  const size_t maxAlign_;
+
+  ThreadLocalPtr<SysArena, ThreadLocalPtrTag> arena_; // Per-thread arena.
+
+  // Allocations from threads that are now dead.
+  Synchronized<SysArena> zombies_;
+};
+
+template <>
+struct AllocatorHasTrivialDeallocate<ThreadCachedArena> : std::true_type {};
+
+template <typename T>
+using ThreadCachedArenaAllocator = CxxAllocatorAdaptor<T, ThreadCachedArena>;
+
+} // namespace folly