react-native-windows 0.81.34 → 0.81.35

package/external/folly/folly/BenchmarkUtil.h

@@ -0,0 +1,47 @@
+/*
+ * 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 {
+
+/**
+ * Call doNotOptimizeAway(var) to ensure that var will be computed even
+ * post-optimization.  Use it for variables that are computed during
+ * benchmarking but otherwise are useless. The compiler tends to do a
+ * good job at eliminating unused variables, and this function fools it
+ * into thinking var is in fact needed.
+ *
+ * Call makeUnpredictable(var) when you don't want the optimizer to use
+ * its knowledge of var to shape the following code.  This is useful
+ * when constant propagation or power reduction is possible during your
+ * benchmark but not in real use cases.
+ */
+
+template <class T>
+FOLLY_ALWAYS_INLINE void doNotOptimizeAway(const T& datum) {
+  compiler_must_not_elide(datum);
+}
+
+template <typename T>
+FOLLY_ALWAYS_INLINE void makeUnpredictable(T& datum) {
+  compiler_must_not_predict(datum);
+}
+
+} // namespace folly

package/external/folly/folly/Bits.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/lang/Bits.h> // @shim

package/external/folly/folly/CMakeLists.txt

@@ -0,0 +1,110 @@
+# 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.
+
+add_library(
+    follybenchmark
+    Benchmark.cpp
+)
+set_property(TARGET follybenchmark PROPERTY VERSION ${PACKAGE_VERSION})
+target_compile_definitions(follybenchmark PRIVATE BOOST_NO_AUTO_PTR)
+target_link_libraries(follybenchmark PUBLIC folly)
+apply_folly_compile_options_to_target(follybenchmark)
+install(
+  TARGETS follybenchmark
+  EXPORT folly
+  RUNTIME DESTINATION ${BIN_INSTALL_DIR}
+  LIBRARY DESTINATION ${LIB_INSTALL_DIR}
+  ARCHIVE DESTINATION ${LIB_INSTALL_DIR}
+)
+
+add_subdirectory(debugging/exception_tracer)
+add_subdirectory(logging/example)
+
+if (PYTHON_EXTENSIONS)
+  # Create tree of symbolic links in structure required for successful
+  # compliation by Cython.
+  #   - must be in path named same as extension
+
+  set(_cybld "${CMAKE_CURRENT_BINARY_DIR}/cybld")
+
+  add_custom_target(create_binding_symlink ALL)
+  file(GLOB BindingFiles
+    "${CMAKE_CURRENT_SOURCE_DIR}/python/*.pyx"
+    "${CMAKE_CURRENT_SOURCE_DIR}/python/*.pxd"
+    "${CMAKE_CURRENT_SOURCE_DIR}/python/*.h"
+    "${CMAKE_CURRENT_SOURCE_DIR}/python/*.cpp"
+  )
+  file(MAKE_DIRECTORY "${_cybld}/folly/")
+
+  foreach(_src ${BindingFiles})
+    get_filename_component(_target_file "${_src}" NAME)
+
+  message(
+    STATUS
+    "Linking ${_src} "
+    "to ${_cybld}/folly/${_target_file}"
+  )
+  add_custom_command(TARGET create_binding_symlink PRE_BUILD
+    COMMAND
+      ${CMAKE_COMMAND} -E create_symlink
+      "${_src}"
+      "${_cybld}/folly/${_target_file}"
+  )
+  endforeach()
+
+  # Tell setup.py where to find includes and libfolly.so
+  set(prop "$<TARGET_PROPERTY:folly_base,INCLUDE_DIRECTORIES>")
+  set(incs "$<$<BOOL:${prop}>:-I$<JOIN:${prop},:>>")
+  set(libs "-L${CMAKE_BINARY_DIR}")
+
+  add_custom_target(folly_python_bindings ALL
+    DEPENDS folly create_binding_symlink
+    WORKING_DIRECTORY ${_cybld})
+
+  add_custom_command(TARGET folly_python_bindings POST_BUILD
+    COMMAND
+      python3 ${CMAKE_CURRENT_SOURCE_DIR}/python/setup.py
+      build_ext -f ${incs} ${libs}
+    BYPRODUCTS ${_cybld}/folly/executor_api.h
+    WORKING_DIRECTORY ${_cybld}
+  )
+
+  add_custom_command(TARGET folly_python_bindings POST_BUILD
+    COMMAND
+      python3 ${CMAKE_CURRENT_SOURCE_DIR}/python/setup.py
+      bdist_wheel
+    WORKING_DIRECTORY ${_cybld}
+  )
+
+  install(
+    FILES ${_cybld}/folly/executor_api.h
+    DESTINATION ${INCLUDE_INSTALL_DIR}/folly/python
+    COMPONENT dev
+  )
+
+  # Install Folly Python Bindings
+  if (UNIX)
+    set(ROOT_ARG "--root \$DESTDIR/")
+  endif ()
+
+  install(CODE "
+    execute_process(
+      COMMAND
+        python3 ${CMAKE_CURRENT_SOURCE_DIR}/python/setup.py install
+        --prefix ${CMAKE_INSTALL_PREFIX} ${ROOT_ARG}
+      COMMAND_ECHO STDOUT
+      WORKING_DIRECTORY ${_cybld}
+    )"
+  )
+endif ()

package/external/folly/folly/CPortability.h

@@ -0,0 +1,338 @@
+/*
+ * 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
+
+/* These definitions are in a separate file so that they
+ * may be included from C- as well as C++-based projects. */
+
+#include <folly/portability/Config.h>
+
+/**
+ * Portable version check.
+ */
+#ifndef __GNUC_PREREQ
+#if defined __GNUC__ && defined __GNUC_MINOR__
+/* nolint */
+#define __GNUC_PREREQ(maj, min) \
+  ((__GNUC__ << 16) + __GNUC_MINOR__ >= ((maj) << 16) + (min))
+#else
+/* nolint */
+#define __GNUC_PREREQ(maj, min) 0
+#endif
+#endif
+
+// portable version check for clang
+#ifndef __CLANG_PREREQ
+#if defined __clang__ && defined __clang_major__ && defined __clang_minor__
+/* nolint */
+#define __CLANG_PREREQ(maj, min) \
+  ((__clang_major__ << 16) + __clang_minor__ >= ((maj) << 16) + (min))
+#else
+/* nolint */
+#define __CLANG_PREREQ(maj, min) 0
+#endif
+#endif
+
+#if defined(__has_builtin)
+#define FOLLY_HAS_BUILTIN(...) __has_builtin(__VA_ARGS__)
+#else
+#define FOLLY_HAS_BUILTIN(...) 0
+#endif
+
+#if defined(__has_feature)
+#define FOLLY_HAS_FEATURE(...) __has_feature(__VA_ARGS__)
+#else
+#define FOLLY_HAS_FEATURE(...) 0
+#endif
+
+/* FOLLY_SANITIZE_ADDRESS is defined to 1 if the current compilation unit
+ * is being compiled with ASAN or HWASAN enabled.
+ *
+ * Beware when using this macro in a header file: this macro may change values
+ * across compilation units if some libraries are built with ASAN/HWASAN enabled
+ * and some built with ASAN/HWSAN disabled. For instance, this may occur, if
+ * folly itself was compiled without ASAN/HWSAN but a downstream project that
+ * uses folly is compiling with ASAN/HWSAN enabled.
+ *
+ * Use FOLLY_LIBRARY_SANITIZE_ADDRESS (defined in folly-config.h) to check if
+ * folly itself was compiled with ASAN enabled.
+ */
+#ifndef FOLLY_SANITIZE_ADDRESS
+#if FOLLY_HAS_FEATURE(address_sanitizer) || defined(__SANITIZE_ADDRESS__) || \
+    FOLLY_HAS_FEATURE(hwaddress_sanitizer)
+#define FOLLY_SANITIZE_ADDRESS 1
+#endif
+#endif
+
+/* Define attribute wrapper for function attribute used to disable
+ * address sanitizer instrumentation. Unfortunately, this attribute
+ * has issues when inlining is used, so disable that as well. */
+#ifdef FOLLY_SANITIZE_ADDRESS
+#if defined(__clang__)
+#if __has_attribute(__no_sanitize__)
+#define FOLLY_DISABLE_ADDRESS_SANITIZER                     \
+  __attribute__((__no_sanitize__("address"), __noinline__)) \
+  __attribute__((__no_sanitize__("hwaddress"), __noinline__))
+#elif __has_attribute(__no_address_safety_analysis__)
+#define FOLLY_DISABLE_ADDRESS_SANITIZER \
+  __attribute__((__no_address_safety_analysis__, __noinline__))
+#elif __has_attribute(__no_sanitize_address__)
+#define FOLLY_DISABLE_ADDRESS_SANITIZER \
+  __attribute__((__no_sanitize_address__, __noinline__))
+#endif
+#elif defined(__GNUC__)
+#define FOLLY_DISABLE_ADDRESS_SANITIZER \
+  __attribute__((__no_address_safety_analysis__, __noinline__))
+#elif defined(_MSC_VER)
+#define FOLLY_DISABLE_ADDRESS_SANITIZER __declspec(no_sanitize_address)
+#endif
+#endif
+#ifndef FOLLY_DISABLE_ADDRESS_SANITIZER
+#define FOLLY_DISABLE_ADDRESS_SANITIZER
+#endif
+
+/* Define a convenience macro to test when thread sanitizer is being used
+ * across the different compilers (e.g. clang, gcc) */
+#ifndef FOLLY_SANITIZE_THREAD
+#if FOLLY_HAS_FEATURE(thread_sanitizer) || defined(__SANITIZE_THREAD__)
+#define FOLLY_SANITIZE_THREAD 1
+#endif
+#endif
+
+#ifdef FOLLY_SANITIZE_THREAD
+#define FOLLY_DISABLE_THREAD_SANITIZER \
+  __attribute__((no_sanitize_thread, noinline))
+#else
+#define FOLLY_DISABLE_THREAD_SANITIZER
+#endif
+
+/**
+ * Define a convenience macro to test when memory sanitizer is being used
+ * across the different compilers (e.g. clang, gcc)
+ */
+#ifndef FOLLY_SANITIZE_MEMORY
+#if FOLLY_HAS_FEATURE(memory_sanitizer) || defined(__SANITIZE_MEMORY__)
+#define FOLLY_SANITIZE_MEMORY 1
+#endif
+#endif
+
+#ifdef FOLLY_SANITIZE_MEMORY
+#define FOLLY_DISABLE_MEMORY_SANITIZER \
+  __attribute__((no_sanitize_memory, noinline))
+#else
+#define FOLLY_DISABLE_MEMORY_SANITIZER
+#endif
+
+/**
+ * Define a convenience macro to test when dataflow sanitizer is being used
+ * across the different compilers (e.g. clang, gcc)
+ */
+#ifndef FOLLY_SANITIZE_DATAFLOW
+#if FOLLY_HAS_FEATURE(dataflow_sanitizer) || defined(__SANITIZE_DATAFLOW__)
+#define FOLLY_SANITIZE_DATAFLOW 1
+#endif
+#endif
+
+#ifdef FOLLY_SANITIZE_DATAFLOW
+#define FOLLY_DISABLE_DATAFLOW_SANITIZER \
+  __attribute__((no_sanitize_dataflow, noinline))
+#else
+#define FOLLY_DISABLE_DATAFLOW_SANITIZER
+#endif
+
+/**
+ * Define a convenience macro to test when undefined-behavior sanitizer is being
+ * used across the different compilers (e.g. clang, gcc)
+ */
+#ifndef FOLLY_SANITIZE_UNDEFINED_BEHAVIOR
+#if FOLLY_HAS_FEATURE(undefined_behavior_sanitizer) || \
+    defined(__SANITIZER_UNDEFINED__)
+#define FOLLY_SANITIZE_UNDEFINED_BEHAVIOR(...) 1
+#endif
+#endif
+
+#ifdef FOLLY_SANITIZE_UNDEFINED_BEHAVIOR
+#define FOLLY_DISABLE_UNDEFINED_BEHAVIOR_SANITIZER(...) \
+  __attribute__((no_sanitize(__VA_ARGS__)))
+#else
+#define FOLLY_DISABLE_UNDEFINED_BEHAVIOR_SANITIZER(...)
+#endif
+
+/**
+ * Define a convenience macro to test when ASAN, UBSAN, TSAN or MSAN sanitizer
+ * are being used
+ */
+#ifndef FOLLY_SANITIZE
+#if defined(FOLLY_SANITIZE_ADDRESS) || defined(FOLLY_SANITIZE_THREAD) ||  \
+    defined(FOLLY_SANITIZE_MEMORY) || defined(FOLLY_SANITIZE_DATAFLOW) || \
+    defined(FOLLY_SANITIZE_UNDEFINED_BEHAVIOR)
+#define FOLLY_SANITIZE 1
+#endif
+#endif
+
+#define FOLLY_DISABLE_SANITIZERS  \
+  FOLLY_DISABLE_ADDRESS_SANITIZER \
+  FOLLY_DISABLE_THREAD_SANITIZER  \
+  FOLLY_DISABLE_MEMORY_SANITIZER  \
+  FOLLY_DISABLE_UNDEFINED_BEHAVIOR_SANITIZER("undefined")
+
+/**
+ * Macro for marking functions as having public visibility.
+ */
+#if defined(__GNUC__)
+#define FOLLY_EXPORT __attribute__((__visibility__("default")))
+#else
+#define FOLLY_EXPORT
+#endif
+
+// noinline
+#ifdef _MSC_VER
+#define FOLLY_NOINLINE __declspec(noinline)
+#elif defined(__HIP_PLATFORM_HCC__)
+// HIP software stack defines its own __noinline__ macro.
+#define FOLLY_NOINLINE __attribute__((noinline))
+#elif defined(__GNUC__)
+#define FOLLY_NOINLINE __attribute__((__noinline__))
+#else
+#define FOLLY_NOINLINE
+#endif
+
+// always inline
+#ifdef _MSC_VER
+#define FOLLY_ALWAYS_INLINE __forceinline
+#elif defined(__GNUC__)
+#define FOLLY_ALWAYS_INLINE inline __attribute__((__always_inline__))
+#else
+#define FOLLY_ALWAYS_INLINE inline
+#endif
+
+// attribute hidden
+#if defined(_MSC_VER)
+#define FOLLY_ATTR_VISIBILITY_HIDDEN
+#elif defined(__GNUC__)
+#define FOLLY_ATTR_VISIBILITY_HIDDEN __attribute__((__visibility__("hidden")))
+#else
+#define FOLLY_ATTR_VISIBILITY_HIDDEN
+#endif
+
+// An attribute for marking symbols as weak, if supported
+#if FOLLY_HAVE_WEAK_SYMBOLS
+#define FOLLY_ATTR_WEAK __attribute__((__weak__))
+#else
+#define FOLLY_ATTR_WEAK
+#endif
+
+// Microsoft ABI version (can be overridden manually if necessary)
+#ifndef FOLLY_MICROSOFT_ABI_VER
+#ifdef _MSC_VER
+#define FOLLY_MICROSOFT_ABI_VER _MSC_VER
+#endif
+#endif
+
+//  FOLLY_ERASE
+//
+//  A conceptual attribute/syntax combo for erasing a function from the build
+//  artifacts and forcing all call-sites to inline the callee, at least as far
+//  as each compiler supports.
+//
+//  Semantically includes the inline specifier.
+#define FOLLY_ERASE FOLLY_ALWAYS_INLINE FOLLY_ATTR_VISIBILITY_HIDDEN
+
+//  FOLLY_ERASE_NOINLINE
+//
+//  Like FOLLY_ERASE, but also noinline. The naming similarity with FOLLY_ERASE
+//  is specifically desirable.
+#define FOLLY_ERASE_NOINLINE FOLLY_NOINLINE FOLLY_ATTR_VISIBILITY_HIDDEN
+
+//  FOLLY_ERASE_HACK_GCC
+//
+//  Equivalent to FOLLY_ERASE, but without hiding under gcc. Useful when applied
+//  to a function which may sometimes be hidden separately, for example by being
+//  declared in an anonymous namespace, since in such cases with -Wattributes
+//  enabled, gcc would emit: 'visibility' attribute ignored.
+//
+//  Semantically includes the inline specifier.
+#if defined(__GNUC__) && !defined(__clang__)
+#define FOLLY_ERASE_HACK_GCC FOLLY_ALWAYS_INLINE
+#else
+#define FOLLY_ERASE_HACK_GCC FOLLY_ERASE
+#endif
+
+//  FOLLY_ERASE_TRYCATCH
+//
+//  Equivalent to FOLLY_ERASE, but for code which might contain explicit
+//  exception handling. Has the effect of FOLLY_ERASE, except under MSVC which
+//  warns about __forceinline when functions contain exception handling.
+//
+//  Semantically includes the inline specifier.
+#ifdef _MSC_VER
+#define FOLLY_ERASE_TRYCATCH inline
+#else
+#define FOLLY_ERASE_TRYCATCH FOLLY_ERASE
+#endif
+
+// Generalize warning push/pop.
+#if defined(__GNUC__) || defined(__clang__)
+// Clang & GCC
+#define FOLLY_PUSH_WARNING _Pragma("GCC diagnostic push")
+#define FOLLY_POP_WARNING _Pragma("GCC diagnostic pop")
+#define FOLLY_GNU_DISABLE_WARNING_INTERNAL2(warningName) #warningName
+#define FOLLY_GNU_DISABLE_WARNING(warningName) \
+  _Pragma(                                     \
+      FOLLY_GNU_DISABLE_WARNING_INTERNAL2(GCC diagnostic ignored warningName))
+#ifdef __clang__
+#define FOLLY_CLANG_DISABLE_WARNING(warningName) \
+  FOLLY_GNU_DISABLE_WARNING(warningName)
+#define FOLLY_GCC_DISABLE_WARNING(warningName)
+#else
+#define FOLLY_CLANG_DISABLE_WARNING(warningName)
+#define FOLLY_GCC_DISABLE_WARNING(warningName) \
+  FOLLY_GNU_DISABLE_WARNING(warningName)
+#endif
+#define FOLLY_MSVC_DISABLE_WARNING(warningNumber)
+#elif defined(_MSC_VER)
+#define FOLLY_PUSH_WARNING __pragma(warning(push))
+#define FOLLY_POP_WARNING __pragma(warning(pop))
+// Disable the GCC warnings.
+#define FOLLY_GNU_DISABLE_WARNING(warningName)
+#define FOLLY_GCC_DISABLE_WARNING(warningName)
+#define FOLLY_CLANG_DISABLE_WARNING(warningName)
+#define FOLLY_MSVC_DISABLE_WARNING(warningNumber) \
+  __pragma(warning(disable : warningNumber))
+#else
+#define FOLLY_PUSH_WARNING
+#define FOLLY_POP_WARNING
+#define FOLLY_GNU_DISABLE_WARNING(warningName)
+#define FOLLY_GCC_DISABLE_WARNING(warningName)
+#define FOLLY_CLANG_DISABLE_WARNING(warningName)
+#define FOLLY_MSVC_DISABLE_WARNING(warningNumber)
+#endif
+
+#ifdef FOLLY_HAVE_SHADOW_LOCAL_WARNINGS
+#define FOLLY_GCC_DISABLE_NEW_SHADOW_WARNINGS            \
+  FOLLY_GNU_DISABLE_WARNING("-Wshadow-compatible-local") \
+  FOLLY_GNU_DISABLE_WARNING("-Wshadow-local")            \
+  FOLLY_GNU_DISABLE_WARNING("-Wshadow")
+#else
+#define FOLLY_GCC_DISABLE_NEW_SHADOW_WARNINGS /* empty */
+#endif
+
+#if defined(_MSC_VER)
+#define FOLLY_MSVC_DECLSPEC(...) __declspec(__VA_ARGS__)
+#else
+#define FOLLY_MSVC_DECLSPEC(...)
+#endif