react-native-windows 0.81.32 → 0.81.35

package/external/folly/folly/Demangle.cpp

@@ -0,0 +1,255 @@
+/*
+ * 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/Demangle.h>
+
+#include <algorithm>
+#include <cstring>
+
+#include <folly/CPortability.h>
+#include <folly/CppAttributes.h>
+#include <folly/Utility.h>
+#include <folly/functional/Invoke.h>
+#include <folly/lang/CString.h>
+
+#if __has_include(<cxxabi.h>)
+#include <cxxabi.h>
+#endif
+
+//  The headers <libiberty.h> (binutils) and <string.h> (glibc) both declare the
+//  symbol basename. Unfortunately, the declarations are different. So including
+//  both headers in the same translation unit fails due to the two conflicting
+//  declarations. Since <demangle.h> includes <libiberty.h> we must be careful.
+#if __has_include(<demangle.h>)
+#pragma push_macro("HAVE_DECL_BASENAME")
+#define HAVE_DECL_BASENAME 1
+#include <demangle.h> // @manual
+#pragma pop_macro("HAVE_DECL_BASENAME")
+#endif
+
+//  try to find cxxabi demangle
+//
+//  prefer using a weakref
+
+#if __has_include(<cxxabi.h>)
+
+[[gnu::weakref("__cxa_demangle")]] static char* cxxabi_demangle(
+    char const*, char*, size_t*, int*);
+
+#else // __has_include(<cxxabi.h>)
+
+static constexpr auto cxxabi_demangle = static_cast<char* (*)(...)>(nullptr);
+
+#endif // __has_include(<cxxabi.h>)
+
+//  try to find liberty demangle
+//
+//  cannot use a weak symbol since it may be the only referenced symbol in
+//  liberty
+//
+//  in contrast with cxxabi, where there are certainly other referenced symbols
+//
+//  for rust_demangle_callback, detect its declaration in the header
+
+#if __has_include(<demangle.h>)
+
+namespace {
+struct poison {};
+
+[[maybe_unused]] FOLLY_ERASE void rust_demangle_callback(poison);
+
+[[maybe_unused]] FOLLY_ERASE int rust_demangle_callback_fallback(
+    const char*, int, demangle_callbackref, void*) {
+  return 0;
+}
+
+FOLLY_CREATE_QUAL_INVOKER(
+    invoke_rust_demangle_primary, ::rust_demangle_callback);
+FOLLY_CREATE_QUAL_INVOKER(
+    invoke_rust_demangle_fallback, rust_demangle_callback_fallback);
+
+using invoke_rust_demangle_fn = folly::invoke_first_match<
+    invoke_rust_demangle_primary,
+    invoke_rust_demangle_fallback>;
+constexpr invoke_rust_demangle_fn invoke_rust_demangle;
+
+int call_rust_demangle_callback(
+    const char* mangled, int options, demangle_callbackref cb, void* opaque) {
+  return invoke_rust_demangle(mangled, options, cb, opaque);
+}
+
+} // namespace
+
+using liberty_demangle_t = int(const char*, int, demangle_callbackref, void*);
+
+static constexpr liberty_demangle_t* liberty_cplus_demangle =
+    cplus_demangle_v3_callback;
+static constexpr liberty_demangle_t* liberty_rust_demangle =
+    call_rust_demangle_callback;
+
+#if defined(DMGL_NO_RECURSE_LIMIT)
+static constexpr auto liberty_demangle_options_no_recurse_limit =
+    DMGL_NO_RECURSE_LIMIT;
+#else
+static constexpr auto liberty_demangle_options_no_recurse_limit = 0;
+#endif
+
+static constexpr auto liberty_demangle_options = //
+    DMGL_PARAMS | DMGL_ANSI | DMGL_TYPES | //
+    liberty_demangle_options_no_recurse_limit;
+
+#else // __has_include(<demangle.h>)
+
+using liberty_demangle_t = int(...);
+
+static constexpr liberty_demangle_t* liberty_cplus_demangle = nullptr;
+static constexpr liberty_demangle_t* liberty_rust_demangle = nullptr;
+static constexpr auto liberty_demangle_options = 0;
+
+#endif // __has_include(<demangle.h>)
+
+//  implementations
+
+namespace folly {
+
+bool const demangle_build_has_cxxabi = cxxabi_demangle;
+bool const demangle_build_has_liberty = //
+    to_bool(liberty_cplus_demangle) && //
+    to_bool(liberty_rust_demangle);
+
+namespace {
+void demangleStringCallback(const char* str, size_t size, void* p) {
+  fbstring* demangle = static_cast<fbstring*>(p);
+
+  demangle->append(str, size);
+}
+} // namespace
+
+fbstring demangle(const char* name) {
+  if (!name) {
+    return fbstring();
+  }
+
+  if (demangle_max_symbol_size) {
+    // GCC's __cxa_demangle() uses on-stack data structures for the
+    // parser state which are linear in the number of components of the
+    // symbol. For extremely long symbols, this can cause a stack
+    // overflow. We set an arbitrary symbol length limit above which we
+    // just return the mangled name.
+    size_t mangledLen = strlen(name);
+    if (mangledLen > demangle_max_symbol_size) {
+      return fbstring(name, mangledLen);
+    }
+  }
+
+  if (folly::demangle_build_has_liberty) {
+    liberty_demangle_t* funcs[] = {
+        liberty_rust_demangle,
+        liberty_cplus_demangle,
+    };
+
+    for (auto func : funcs) {
+      fbstring demangled;
+
+      // Unlike most library functions, this returns 1 on success and 0 on
+      // failure
+      int success = func(
+          name, liberty_demangle_options, demangleStringCallback, &demangled);
+      if (success && !demangled.empty()) {
+        return demangled;
+      }
+    }
+  }
+
+  if (cxxabi_demangle) {
+    int status;
+    size_t len = 0;
+    // malloc() memory for the demangled type name
+    char* demangled = cxxabi_demangle(name, nullptr, &len, &status);
+    if (status != 0) {
+      return name;
+    }
+    // len is the length of the buffer (including NUL terminator and maybe
+    // other junk)
+    return fbstring(
+        demangled, strlen(demangled), len, AcquireMallocatedString());
+  } else {
+    return fbstring(name);
+  }
+}
+
+namespace {
+
+struct DemangleBuf {
+  char* dest;
+  size_t remaining;
+  size_t total;
+};
+
+void demangleBufCallback(const char* str, size_t size, void* p) {
+  DemangleBuf* buf = static_cast<DemangleBuf*>(p);
+  size_t n = std::min(buf->remaining, size);
+  memcpy(buf->dest, str, n);
+  buf->dest += n;
+  buf->remaining -= n;
+  buf->total += size;
+}
+
+} // namespace
+
+size_t demangle(const char* name, char* out, size_t outSize) {
+  if (demangle_max_symbol_size) {
+    size_t mangledLen = strlen(name);
+    if (mangledLen > demangle_max_symbol_size) {
+      if (outSize) {
+        size_t n = std::min(mangledLen, outSize - 1);
+        memcpy(out, name, n);
+        out[n] = '\0';
+      }
+      return mangledLen;
+    }
+  }
+
+  if (folly::demangle_build_has_liberty) {
+    liberty_demangle_t* funcs[] = {
+        liberty_rust_demangle,
+        liberty_cplus_demangle,
+    };
+
+    for (auto func : funcs) {
+      DemangleBuf dbuf;
+      dbuf.dest = out;
+      dbuf.remaining = outSize ? outSize - 1 : 0; // leave room for null term
+      dbuf.total = 0;
+
+      // Unlike most library functions, this returns 1 on success and 0 on
+      // failure
+      int success =
+          func(name, liberty_demangle_options, demangleBufCallback, &dbuf);
+      if (success) {
+        if (outSize != 0) {
+          *dbuf.dest = '\0';
+        }
+        return dbuf.total;
+      }
+    }
+  }
+
+  // fallback - just return original
+  return folly::strlcpy(out, name, outSize);
+}
+
+} // namespace folly

package/external/folly/folly/Demangle.h

@@ -0,0 +1,73 @@
+/*
+ * 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/FBString.h>
+#include <folly/portability/Config.h>
+
+namespace folly {
+
+inline constexpr size_t demangle_max_symbol_size =
+#if defined(FOLLY_DEMANGLE_MAX_SYMBOL_SIZE)
+    FOLLY_DEMANGLE_MAX_SYMBOL_SIZE;
+#else
+    0;
+#endif
+
+extern bool const demangle_build_has_cxxabi;
+extern bool const demangle_build_has_liberty;
+
+/**
+ * Return the demangled (prettified) version of a C++ type.
+ *
+ * This function tries to produce a human-readable type, but the type name will
+ * be returned unchanged in case of error or if demangling isn't supported on
+ * your system.
+ *
+ * Use for debugging -- do not rely on demangle() returning anything useful.
+ *
+ * This function may allocate memory (and therefore throw std::bad_alloc).
+ */
+fbstring demangle(const char* name);
+inline fbstring demangle(const std::type_info& type) {
+  return demangle(type.name());
+}
+
+/**
+ * Return the demangled (prettified) version of a C++ type in a user-provided
+ * buffer.
+ *
+ * The semantics are the same as for snprintf or strlcpy: bufSize is the size
+ * of the buffer, the string is always null-terminated, and the return value is
+ * the number of characters (not including the null terminator) that would have
+ * been written if the buffer was big enough. (So a return value >= bufSize
+ * indicates that the output was truncated)
+ *
+ * This function does not allocate memory and is async-signal-safe.
+ *
+ * Note that the underlying function for the fbstring-returning demangle is
+ * somewhat standard (abi::__cxa_demangle, which uses malloc), the underlying
+ * function for this version is less so (cplus_demangle_v3_callback from
+ * libiberty), so it is possible for the fbstring version to work, while this
+ * version returns the original, mangled name.
+ */
+size_t demangle(const char* name, char* out, size_t outSize);
+inline size_t demangle(const std::type_info& type, char* buf, size_t bufSize) {
+  return demangle(type.name(), buf, bufSize);
+}
+
+} // namespace folly

package/external/folly/folly/DiscriminatedPtr.h

@@ -0,0 +1,236 @@
+/*
+ * 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.
+ */
+
+/**
+ * Discriminated pointer: Type-safe pointer to one of several types.
+ *
+ * Similar to std::variant, but has no space overhead over a raw pointer, as
+ * it relies on the fact that (on x86_64) there are 16 unused bits in a
+ * pointer.
+ */
+
+#pragma once
+
+#include <limits>
+#include <stdexcept>
+
+#include <glog/logging.h>
+
+#include <folly/Likely.h>
+#include <folly/Portability.h>
+#include <folly/detail/DiscriminatedPtrDetail.h>
+
+#if !FOLLY_X64 && !FOLLY_AARCH64 && !FOLLY_PPC64 && !FOLLY_RISCV64
+#error "DiscriminatedPtr is x64, arm64, ppc64 and riscv64 specific code."
+#endif
+
+namespace folly {
+
+/**
+ * Discriminated pointer.
+ *
+ * Given a list of types, a DiscriminatedPtr<Types...> may point to an object
+ * of one of the given types, or may be empty.  DiscriminatedPtr is type-safe:
+ * you may only get a pointer to the type that you put in, otherwise get
+ * throws an exception (and get_nothrow returns nullptr)
+ *
+ * This pointer does not do any kind of lifetime management -- it's not a
+ * "smart" pointer.  You are responsible for deallocating any memory used
+ * to hold pointees, if necessary.
+ */
+template <typename... Types>
+class DiscriminatedPtr {
+  // <, not <=, as our indexes are 1-based (0 means "empty")
+  static_assert(
+      sizeof...(Types) < std::numeric_limits<uint16_t>::max(),
+      "too many types");
+
+ public:
+  /**
+   * Create an empty DiscriminatedPtr.
+   */
+  DiscriminatedPtr() : data_(0) {}
+
+  /**
+   * Create a DiscriminatedPtr that points to an object of type T.
+   * Fails at compile time if T is not a valid type (listed in Types)
+   */
+  template <typename T>
+  explicit DiscriminatedPtr(T* ptr) {
+    set(ptr, typeIndex<T>());
+  }
+
+  /**
+   * Set this DiscriminatedPtr to point to an object of type T.
+   * Fails at compile time if T is not a valid type (listed in Types)
+   */
+  template <typename T>
+  void set(T* ptr) {
+    set(ptr, typeIndex<T>());
+  }
+
+  /**
+   * Get a pointer to the object that this DiscriminatedPtr points to, if it is
+   * of type T.  Fails at compile time if T is not a valid type (listed in
+   * Types), and returns nullptr if this DiscriminatedPtr is empty or points to
+   * an object of a different type.
+   */
+  template <typename T>
+  T* get_nothrow() noexcept {
+    void* p = FOLLY_LIKELY(hasType<T>()) ? ptr() : nullptr;
+    return static_cast<T*>(p);
+  }
+
+  template <typename T>
+  const T* get_nothrow() const noexcept {
+    const void* p = FOLLY_LIKELY(hasType<T>()) ? ptr() : nullptr;
+    return static_cast<const T*>(p);
+  }
+
+  /**
+   * Get a pointer to the object that this DiscriminatedPtr points to, if it is
+   * of type T.  Fails at compile time if T is not a valid type (listed in
+   * Types), and throws std::invalid_argument if this DiscriminatedPtr is empty
+   * or points to an object of a different type.
+   */
+  template <typename T>
+  T* get() {
+    if (FOLLY_UNLIKELY(!hasType<T>())) {
+      throw std::invalid_argument("Invalid type");
+    }
+    return static_cast<T*>(ptr());
+  }
+
+  template <typename T>
+  const T* get() const {
+    if (FOLLY_UNLIKELY(!hasType<T>())) {
+      throw std::invalid_argument("Invalid type");
+    }
+    return static_cast<const T*>(ptr());
+  }
+
+  /**
+   * Return true iff this DiscriminatedPtr is empty.
+   */
+  bool empty() const { return index() == 0; }
+
+  /**
+   * Return true iff the object pointed by this DiscriminatedPtr has type T,
+   * false otherwise.  Fails at compile time if T is not a valid type (listed
+   * in Types...)
+   */
+  template <typename T>
+  bool hasType() const {
+    return index() == typeIndex<T>();
+  }
+
+  /**
+   * Clear this DiscriminatedPtr, making it empty.
+   */
+  void clear() { data_ = 0; }
+
+  /**
+   * Assignment operator from a pointer of type T.
+   */
+  template <typename T>
+  DiscriminatedPtr& operator=(T* ptr) {
+    set(ptr);
+    return *this;
+  }
+
+  /**
+   * Apply a visitor to this object, calling the appropriate overload for
+   * the type currently stored in DiscriminatedPtr.  Throws invalid_argument
+   * if the DiscriminatedPtr is empty.
+   *
+   * The visitor must meet the following requirements:
+   *
+   * - The visitor must allow invocation as a function by overloading
+   *   operator(), unambiguously accepting all values of type T* (or const T*)
+   *   for all T in Types...
+   * - All operations of the function object on T* (or const T*) must
+   *   return the same type (or a static_assert will fire).
+   */
+  template <typename V>
+  typename dptr_detail::VisitorResult<V, Types...>::type apply(V&& visitor) {
+    size_t n = index();
+    if (n == 0) {
+      throw std::invalid_argument("Empty DiscriminatedPtr");
+    }
+    return dptr_detail::ApplyVisitor<V, Types...>()(
+        n, std::forward<V>(visitor), ptr());
+  }
+
+  template <typename V>
+  typename dptr_detail::ConstVisitorResult<V, Types...>::type apply(
+      V&& visitor) const {
+    size_t n = index();
+    if (n == 0) {
+      throw std::invalid_argument("Empty DiscriminatedPtr");
+    }
+    return dptr_detail::ApplyConstVisitor<V, Types...>()(
+        n, std::forward<V>(visitor), ptr());
+  }
+
+ private:
+  /**
+   * Get the 1-based type index of T in Types.
+   */
+  template <typename T>
+  uint16_t typeIndex() const {
+    return uint16_t(dptr_detail::GetTypeIndex<T, Types...>::value);
+  }
+
+  uint16_t index() const { return data_ >> 48; }
+  void* ptr() const {
+    return reinterpret_cast<void*>(data_ & ((1ULL << 48) - 1));
+  }
+
+  void set(void* p, uint16_t v) {
+    uintptr_t ip = reinterpret_cast<uintptr_t>(p);
+    CHECK(!(ip >> 48));
+    ip |= static_cast<uintptr_t>(v) << 48;
+    data_ = ip;
+  }
+
+  /**
+   * We store a pointer in the least significant 48 bits of data_, and a type
+   * index (0 = empty, or 1-based index in Types) in the most significant 16
+   * bits.  We rely on the fact that pointers have their most significant 16
+   * bits clear on x86_64.
+   */
+  uintptr_t data_;
+};
+
+template <typename Visitor, typename... Args>
+decltype(auto) apply_visitor(
+    Visitor&& visitor, const DiscriminatedPtr<Args...>& variant) {
+  return variant.apply(std::forward<Visitor>(visitor));
+}
+
+template <typename Visitor, typename... Args>
+decltype(auto) apply_visitor(
+    Visitor&& visitor, DiscriminatedPtr<Args...>& variant) {
+  return variant.apply(std::forward<Visitor>(visitor));
+}
+
+template <typename Visitor, typename... Args>
+decltype(auto) apply_visitor(
+    Visitor&& visitor, DiscriminatedPtr<Args...>&& variant) {
+  return variant.apply(std::forward<Visitor>(visitor));
+}
+
+} // namespace folly

package/external/folly/folly/DynamicConverter.h

@@ -0,0 +1,17 @@
+/*
+ * 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/json/DynamicConverter.h>