react-native-windows 0.85.0-preview.1 → 0.85.0

package/external/folly/folly/defs.bzl

@@ -0,0 +1,238 @@
+"""Provides helper functions for the folly library
+
+[folly]
+    have_libgflags_override = {True|[False]}
+"""
+
+load("@fbsource//tools/build_defs:buckconfig.bzl", "read_bool")
+load(
+    "@fbsource//tools/build_defs:default_platform_defs.bzl",
+    "ANDROID",
+    "APPLE",
+    "CXX",
+    "FBCODE",
+    "IOS",
+    "MACOSX",
+    "WINDOWS",
+    "get_available_platforms",
+)
+load("@fbsource//tools/build_defs:fb_xplat_cxx_binary.bzl", "fb_xplat_cxx_binary")
+load("@fbsource//tools/build_defs:fb_xplat_cxx_library.bzl", "fb_xplat_cxx_library")
+load("@fbsource//tools/build_defs:fb_xplat_cxx_test.bzl", "fb_xplat_cxx_test")
+load("@fbsource//tools/build_defs:fbsource_utils.bzl", "is_arvr_mode")
+
+def should_enable_gflags():
+    return read_bool("folly", "have_libgflags_override", False)
+
+def is_folly_mobile_flag():
+    return native.read_config("cpp_flags", "preprocessing", "") == "DFOLLY_MOBILE"
+
+def cpp_flags():
+    flags = [
+        "-DFOLLY_HAVE_LIBJEMALLOC=0",
+        "-DFOLLY_HAVE_PREADV=0",
+        "-DFOLLY_HAVE_PWRITEV=0",
+        "-DFOLLY_HAVE_TFO=0",
+    ]
+
+    if is_folly_mobile_flag():
+        flags += select({
+            "DEFAULT": [],
+            "ovr_config//os:linux": ["-DFOLLY_MOBILE=1"],
+        })
+
+    elif is_arvr_mode():
+        flags += select({
+            "DEFAULT": ["-DFOLLY_MOBILE=1"],
+            "ovr_config//os:linux": [],
+            "ovr_config//os:macos": [],
+        })
+
+    else:
+        flags += ["-DFOLLY_MOBILE=1"]
+
+    return flags
+
+FBANDROID_CPPFLAGS = [
+    "-DFOLLY_HAVE_IFUNC=0",
+    "-DFOLLY_HAVE_INT128_T=0",
+    "-DSSLCONTEXT_NO_REFCOUNT",
+    "-D__STDC_FORMAT_MACROS",
+    "-D__STDC_LIMIT_MACROS",
+    "-D__STDC_CONSTANT_MACROS",
+]
+
+CLANG_CXX_FLAGS = [
+    "-frtti",
+    "-fexceptions",
+    "-Wall",
+    "-Werror",
+    "-Wno-unused-local-typedefs",
+    "-Wno-unused-variable",
+    "-Wno-sign-compare",
+    "-Wno-comment",
+    "-Wno-return-type",
+    "-Wno-global-constructors",
+    "-Wno-missing-prototypes",
+    "-Wno-nullability-completeness",
+    "-Wno-c++17-extensions",
+    "-Wno-undef",
+    "-Wno-unreachable-code",
+    "-Wno-deprecated-declarations",
+]
+CXXFLAGS = select({
+    "DEFAULT": [],
+    "ovr_config//compiler:clang": CLANG_CXX_FLAGS,
+})
+
+FBOBJC_CXXFLAGS = ["-Os"]
+
+FBANDROID_CXXFLAGS = [
+    "-ffunction-sections",
+    "-Wno-uninitialized",
+]
+
+WINDOWS_MSVC_CXXFLAGS = [
+    "/EHs",
+    "/D_ENABLE_EXTENDED_ALIGNED_STORAGE",
+]
+
+WINDOWS_CLANG_CXX_FLAGS = [
+    "-Wno-deprecated-declarations",
+    "-Wno-microsoft-cast",
+    "-Wno-missing-braces",
+    "-Wno-unused-function",
+    "-Wno-undef",
+    "-DBOOST_HAS_THREADS",
+    "-D_ENABLE_EXTENDED_ALIGNED_STORAGE",
+]
+
+DEFAULT_APPLE_SDKS = (IOS, MACOSX)
+DEFAULT_PLATFORMS = (CXX, ANDROID, APPLE, FBCODE, WINDOWS)
+
+def _compute_include_directories():
+    base_path = native.package_name()
+    if base_path == "xplat/folly":
+        return [".."]
+    thrift_path = base_path[6:]
+    return ["/".join(len(thrift_path.split("/")) * [".."])]
+
+def folly_library(
+        name,
+        srcs = (),
+        exported_headers = (),
+        raw_headers = (),
+        deps = (),
+        exported_deps = (),
+        force_static = True,
+        apple_sdks = None,
+        platforms = None,
+        enable_static_variant = True,
+        labels = (),
+        **kwargs):
+    """Translate a simpler declartion into the more complete library target"""
+
+    # Set default platform settings. `()` means empty, whereas None
+    # means default
+    if apple_sdks == None:
+        apple_sdks = DEFAULT_APPLE_SDKS
+    if platforms == None:
+        platforms = DEFAULT_PLATFORMS
+
+    # We use gflags on fbcode platforms, which don't mix well when mixing static
+    # and dynamic linking.
+    if not is_arvr_mode():
+        force_static = select({
+            "DEFAULT": force_static,
+            "ovr_config//runtime:fbcode": False,
+        })
+
+    fb_xplat_cxx_library(
+        name = name,
+        srcs = srcs,
+        header_namespace = "",
+        exported_headers = exported_headers,
+        raw_headers = raw_headers,
+        public_include_directories = _compute_include_directories(),
+        deps = deps,
+        exported_deps = exported_deps,
+        force_static = force_static,
+        apple_sdks = apple_sdks,
+        platforms = platforms,
+        enable_static_variant = enable_static_variant,
+        labels = list(labels),
+        compiler_flags = CXXFLAGS + kwargs.pop("compiler_flags", []) + select({
+            "DEFAULT": [],
+            "ovr_config//os:android": FBANDROID_CXXFLAGS,
+            "ovr_config//os:iphoneos": CLANG_CXX_FLAGS,
+            # TODO: Why iphoneos and macos are not marked as clang compilers?
+            "ovr_config//os:macos": CLANG_CXX_FLAGS,
+        }) + select({
+            "DEFAULT": [],
+            "ovr_config//os:windows-cl": WINDOWS_MSVC_CXXFLAGS,
+            "ovr_config//os:windows-gcc-or-clang": WINDOWS_CLANG_CXX_FLAGS,
+        }),
+        fbobjc_compiler_flags = kwargs.pop("fbobjc_compiler_flags", []) +
+                                FBOBJC_CXXFLAGS,
+        fbcode_compiler_flags_override = kwargs.pop("fbcode_compiler_flags", []),
+        windows_preferred_linkage = "static",
+        visibility = kwargs.pop("visibility", ["PUBLIC"]),
+        **kwargs
+    )
+
+def folly_cxx_library(name, **kwargs):
+    folly_library(
+        name = name,
+        **kwargs
+    )
+
+def folly_cxx_test(
+        name,
+        srcs,
+        raw_headers = [],
+        deps = [],
+        contacts = [],
+        **kwargs):
+    # resources is cherry picked because some of the other kwargs
+    # have issues that need to be investigated.
+    # e.g., Some args are duplicated. Some args cause TSAN errors.
+    # TODO(T188948036): Fix xplat/folly:folly-futures-test and folly_cxx_test
+    resources = kwargs.get("resources", [])
+
+    fb_xplat_cxx_test(
+        name = name,
+        srcs = srcs,
+        raw_headers = raw_headers,
+        resources = resources,
+        include_directories = _compute_include_directories(),
+        deps = deps + [
+            "//xplat/folly/test/common:test_main",
+        ],
+        contacts = contacts,
+        platforms = (CXX,),
+    )
+
+def folly_cxx_binary(
+        name,
+        srcs,
+        raw_headers = [],
+        deps = [],
+        contacts = [],
+        **kwargs):
+    fb_xplat_cxx_binary(
+        name = name,
+        srcs = srcs,
+        raw_headers = raw_headers,
+        include_directories = _compute_include_directories(),
+        deps = deps,
+        contacts = contacts,
+        platforms = (CXX,),
+    )
+
+def override_soname_if_needed(name):
+    # This is a hack to unblock rollout of platform suffix removal to xplat/folly.
+    # See T89357426. This only applies when using arvr build modes and can be removed when Hermes
+    # is built from source (or prebuilt using arvr build modes).
+    if is_arvr_mode() and ANDROID in get_available_platforms():
+        return "libxplat_folly_{}Android.so".format(name)
+    return None

package/external/folly/folly/detail/AsyncTrace.cpp

@@ -0,0 +1,36 @@
+/*
+ * 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/detail/AsyncTrace.h>
+
+#include <folly/Portability.h>
+
+namespace folly {
+namespace async_tracing {
+FOLLY_ATTR_WEAK void logSetGlobalCPUExecutor(Executor*) noexcept {}
+FOLLY_ATTR_WEAK void logSetGlobalCPUExecutorToImmutable() noexcept {}
+FOLLY_ATTR_WEAK void logGetGlobalCPUExecutor(Executor*) noexcept {}
+FOLLY_ATTR_WEAK void logGetImmutableCPUExecutor(Executor*) noexcept {}
+FOLLY_ATTR_WEAK void logSetGlobalIOExecutor(IOExecutor*) noexcept {}
+FOLLY_ATTR_WEAK void logGetGlobalIOExecutor(IOExecutor*) noexcept {}
+FOLLY_ATTR_WEAK void logGetImmutableIOExecutor(IOExecutor*) noexcept {}
+FOLLY_ATTR_WEAK void logSemiFutureVia(Executor*, Executor*) noexcept {}
+FOLLY_ATTR_WEAK void logFutureVia(Executor*, Executor*) noexcept {}
+FOLLY_ATTR_WEAK void logBlockingOperation(std::chrono::milliseconds) noexcept {}
+FOLLY_ATTR_WEAK void logSemiFutureDiscard(
+    DiscardHasDeferred /* hasDeferredExecutor */) noexcept {}
+} // namespace async_tracing
+} // namespace folly

package/external/folly/folly/detail/AsyncTrace.h

@@ -0,0 +1,44 @@
+/*
+ * 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 <chrono>
+
+#include <folly/Optional.h>
+
+namespace folly {
+class Executor;
+class IOExecutor;
+namespace async_tracing {
+enum class DiscardHasDeferred {
+  NO_EXECUTOR,
+  DEFERRED_EXECUTOR,
+};
+void logSetGlobalCPUExecutor(Executor*) noexcept;
+void logSetGlobalCPUExecutorToImmutable() noexcept;
+void logGetGlobalCPUExecutor(Executor*) noexcept;
+void logGetImmutableCPUExecutor(Executor*) noexcept;
+void logSetGlobalIOExecutor(IOExecutor*) noexcept;
+void logGetGlobalIOExecutor(IOExecutor*) noexcept;
+void logGetImmutableIOExecutor(IOExecutor*) noexcept;
+void logSemiFutureVia(Executor*, Executor*) noexcept;
+void logFutureVia(Executor*, Executor*) noexcept;
+void logBlockingOperation(std::chrono::milliseconds) noexcept;
+void logSemiFutureDiscard(
+    DiscardHasDeferred /* hasDeferredExecutor */) noexcept;
+} // namespace async_tracing
+} // namespace folly

package/external/folly/folly/detail/AtomicHashUtils.h

@@ -0,0 +1,42 @@
+/*
+ * 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 <thread>
+
+#include <folly/portability/Asm.h>
+
+// Some utilities used by AtomicHashArray and AtomicHashMap
+//
+
+namespace folly {
+namespace detail {
+
+template <typename Cond>
+void atomic_hash_spin_wait(Cond condition) {
+  constexpr size_t kPauseLimit = 10000;
+  for (size_t i = 0; condition(); ++i) {
+    if (i < kPauseLimit) {
+      folly::asm_volatile_pause();
+    } else {
+      std::this_thread::yield();
+    }
+  }
+}
+
+} // namespace detail
+} // namespace folly

package/external/folly/folly/detail/AtomicUnorderedMapUtils.h

@@ -0,0 +1,80 @@
+/*
+ * 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 <cassert>
+#include <cstdint>
+#include <system_error>
+
+#include <folly/Exception.h>
+#include <folly/portability/SysMman.h>
+#include <folly/portability/Unistd.h>
+namespace folly {
+namespace detail {
+
+class MMapAlloc {
+ private:
+  size_t computeSize(size_t size) {
+    long pagesize = sysconf(_SC_PAGESIZE);
+    size_t mmapLength = ((size - 1) & ~(pagesize - 1)) + pagesize;
+    assert(size <= mmapLength && mmapLength < size + pagesize);
+    assert((mmapLength % pagesize) == 0);
+    return mmapLength;
+  }
+
+ public:
+  void* allocate(size_t size) {
+    auto len = computeSize(size);
+
+    int extraflags = 0;
+#if defined(MAP_POPULATE)
+    extraflags |= MAP_POPULATE;
+#endif
+    // MAP_HUGETLB is a perf win, but requires cooperation from the
+    // deployment environment (and a change to computeSize()).
+    void* mem = static_cast<void*>(mmap(
+        nullptr,
+        len,
+        PROT_READ | PROT_WRITE,
+        MAP_PRIVATE | MAP_ANONYMOUS | extraflags,
+        -1,
+        0));
+    if (mem == reinterpret_cast<void*>(-1)) {
+      throw std::system_error(errno, errorCategoryForErrnoDomain());
+    }
+#if !defined(MAP_POPULATE) && defined(MADV_WILLNEED)
+    madvise(mem, size, MADV_WILLNEED);
+#endif
+
+    return mem;
+  }
+
+  void deallocate(void* p, size_t size) {
+    auto len = computeSize(size);
+    munmap(p, len);
+  }
+};
+
+template <typename Allocator>
+struct GivesZeroFilledMemory : public std::false_type {};
+
+template <>
+struct GivesZeroFilledMemory<MMapAlloc> : public std::true_type {};
+
+} // namespace detail
+} // namespace folly