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

package/external/folly/folly/detail/SocketFastOpen.cpp

@@ -0,0 +1,175 @@
+/*
+ * 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/SocketFastOpen.h>
+
+#include <cerrno>
+#include <cstdio>
+#include <fstream>
+
+#include <folly/portability/Sockets.h>
+
+namespace folly {
+namespace detail {
+
+#if FOLLY_ALLOW_TFO && defined(__linux__)
+
+// Sometimes these flags are not present in the headers,
+// so define them if not present.
+#if !defined(MSG_FASTOPEN)
+#define MSG_FASTOPEN 0x20000000
+#endif
+
+#if !defined(TCP_FASTOPEN)
+#define TCP_FASTOPEN 23
+#endif
+
+#if !defined(TCPI_OPT_SYN_DATA)
+#define TCPI_OPT_SYN_DATA 32
+#endif
+
+ssize_t tfo_sendmsg(NetworkSocket sockfd, const struct msghdr* msg, int flags) {
+  flags |= MSG_FASTOPEN;
+  return netops::sendmsg(sockfd, msg, flags);
+}
+
+int tfo_enable(NetworkSocket sockfd, size_t max_queue_size) {
+  return netops::setsockopt(
+      sockfd, SOL_TCP, TCP_FASTOPEN, &max_queue_size, sizeof(max_queue_size));
+}
+
+bool tfo_succeeded(NetworkSocket sockfd) {
+  // Call getsockopt to check if TFO was used.
+  struct tcp_info info;
+  socklen_t info_len = sizeof(info);
+  errno = 0;
+  if (netops::getsockopt(sockfd, IPPROTO_TCP, TCP_INFO, &info, &info_len) !=
+      0) {
+    // errno is set from getsockopt
+    return false;
+  }
+  return info.tcpi_options & TCPI_OPT_SYN_DATA;
+}
+
+PlatformTFOSettings tfo_platform_availability() {
+  static PlatformTFOSettings TFOSettings = [] {
+    size_t fastOpen = 0;
+    try {
+      std::ifstream ifs("/proc/sys/net/ipv4/tcp_fastopen");
+      if (ifs.is_open()) {
+        ifs >> fastOpen;
+      }
+    } catch (std::exception&) {
+    }
+
+    PlatformTFOSettings settings{};
+    if ((fastOpen & 1) == 0) {
+      settings.client = TFOAvailability::None;
+    } else if ((fastOpen & 4) == 0) {
+      settings.client = TFOAvailability::WithCookies;
+    } else {
+      settings.client = TFOAvailability::Unconditional;
+    }
+
+    if ((fastOpen & 2) == 0) {
+      settings.server = TFOAvailability::None;
+    } else if ((fastOpen & 0x200) == 0) {
+      settings.server = TFOAvailability::WithCookies;
+    } else {
+      settings.server = TFOAvailability::Unconditional;
+    }
+
+    return settings;
+  }();
+
+  return TFOSettings;
+}
+
+#elif FOLLY_ALLOW_TFO && defined(__APPLE__)
+
+ssize_t tfo_sendmsg(NetworkSocket sockfd, const struct msghdr* msg, int flags) {
+  sa_endpoints_t endpoints;
+  endpoints.sae_srcif = 0;
+  endpoints.sae_srcaddr = nullptr;
+  endpoints.sae_srcaddrlen = 0;
+  endpoints.sae_dstaddr = (struct sockaddr*)msg->msg_name;
+  endpoints.sae_dstaddrlen = msg->msg_namelen;
+  int ret = connectx(
+      sockfd.toFd(),
+      &endpoints,
+      SAE_ASSOCID_ANY,
+      CONNECT_RESUME_ON_READ_WRITE | CONNECT_DATA_IDEMPOTENT,
+      nullptr,
+      0,
+      nullptr,
+      nullptr);
+
+  if (ret != 0) {
+    return ret;
+  }
+  ret = netops::sendmsg(sockfd, msg, flags);
+  return ret;
+}
+
+int tfo_enable(NetworkSocket sockfd, size_t max_queue_size) {
+  return netops::setsockopt(
+      sockfd,
+      IPPROTO_TCP,
+      TCP_FASTOPEN,
+      &max_queue_size,
+      sizeof(max_queue_size));
+}
+
+bool tfo_succeeded(NetworkSocket /* sockfd */) {
+  errno = EOPNOTSUPP;
+  return false;
+}
+
+PlatformTFOSettings tfo_platform_availability() {
+  static PlatformTFOSettings TFOSettings{
+      TFOAvailability::None, TFOAvailability::None};
+  return TFOSettings;
+}
+
+#else
+
+ssize_t tfo_sendmsg(
+    NetworkSocket /* sockfd */,
+    const struct msghdr* /* msg */,
+    int /* flags */) {
+  errno = EOPNOTSUPP;
+  return -1;
+}
+
+int tfo_enable(NetworkSocket /* sockfd */, size_t /* max_queue_size */) {
+  errno = ENOPROTOOPT;
+  return -1;
+}
+
+bool tfo_succeeded(NetworkSocket /* sockfd */) {
+  errno = EOPNOTSUPP;
+  return false;
+}
+
+PlatformTFOSettings tfo_platform_availability() {
+  static PlatformTFOSettings TFOSettings{
+      TFOAvailability::None, TFOAvailability::None};
+  return TFOSettings;
+}
+
+#endif
+} // namespace detail
+} // namespace folly

package/external/folly/folly/detail/SocketFastOpen.h

@@ -0,0 +1,89 @@
+/*
+ * 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 <sys/types.h>
+
+#include <folly/net/NetworkSocket.h>
+#include <folly/portability/Sockets.h>
+
+#if !defined(FOLLY_ALLOW_TFO)
+#if defined(__linux__) || defined(__APPLE__)
+// only allow for linux right now
+#define FOLLY_ALLOW_TFO 1
+#endif
+#endif
+
+namespace folly {
+namespace detail {
+
+/**
+ * TFOAvailability describes support for TCP Fast Open (TFO).
+ */
+enum class TFOAvailability {
+  /**
+   * TFOAvailability::None indicates that the current environment
+   * does not support TFO (or we could not detect support via probing).
+   */
+  None,
+  /**
+   * TFOAvailability::WithCookies indicates that TFO is supported by the
+   * platform. However, in order for TFO data to be used or for TFO to
+   * be attempted, a prior connection to the same peer must have successfully
+   * taken place so that the peer could issue a cookie.
+   */
+  WithCookies,
+  /**
+   * TFOAvailability::Unconditional indicates that TFO will always be
+   * unconditionally sent or accepted, regardless of whether or not prior
+   * connections have taken place.
+   */
+  Unconditional
+};
+
+/**
+ * PlatformTFOSettings describes TFO support for client connections and
+ * server connections.
+ */
+struct PlatformTFOSettings {
+  TFOAvailability client{TFOAvailability::None};
+  TFOAvailability server{TFOAvailability::None};
+};
+
+/**
+ * tfo_sendto has the same semantics as sendmsg, but is used to
+ * send with TFO data.
+ */
+ssize_t tfo_sendmsg(NetworkSocket sockfd, const struct msghdr* msg, int flags);
+
+/**
+ * Enable TFO on a listening socket.
+ */
+int tfo_enable(NetworkSocket sockfd, size_t max_queue_size);
+
+/**
+ * Check if TFO succeeded in being used.
+ */
+bool tfo_succeeded(NetworkSocket sockfd);
+
+/**
+ * Check if TFO is supported by the kernel.
+ */
+PlatformTFOSettings tfo_platform_availability();
+
+} // namespace detail
+} // namespace folly

package/external/folly/folly/detail/SplitStringSimd.cpp

@@ -0,0 +1,84 @@
+/*
+ * 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/SplitStringSimd.h>
+#include <folly/detail/SplitStringSimdImpl.h>
+
+#include <folly/FBString.h>
+#include <folly/FBVector.h>
+#include <folly/small_vector.h>
+
+namespace folly {
+namespace detail {
+
+template <typename Container>
+void SimdSplitByCharImpl<Container>::keepEmpty(
+    char sep, folly::StringPiece what, Container& res) {
+  PlatformSimdSplitByChar<
+      simd::detail::SimdPlatform<std::uint8_t>,
+      /*ignoreEmpty*/ false>{}(sep, what, res);
+}
+
+template <typename Container>
+void SimdSplitByCharImpl<Container>::dropEmpty(
+    char sep, folly::StringPiece what, Container& res) {
+  PlatformSimdSplitByChar<
+      simd::detail::SimdPlatform<std::uint8_t>,
+      /*ignoreEmpty*/ true>{}(sep, what, res);
+}
+
+template <typename Container>
+void SimdSplitByCharImplToStrings<Container>::keepEmpty(
+    char sep, folly::StringPiece what, Container& res) {
+  PlatformSimdSplitByChar<
+      simd::detail::SimdPlatform<std::uint8_t>,
+      /*ignoreEmpty*/ false>{}(sep, what, res);
+}
+
+template <typename Container>
+void SimdSplitByCharImplToStrings<Container>::dropEmpty(
+    char sep, folly::StringPiece what, Container& res) {
+  PlatformSimdSplitByChar<
+      simd::detail::SimdPlatform<std::uint8_t>,
+      /*ignoreEmpty*/ true>{}(sep, what, res);
+}
+
+// clang-format off
+#define FOLLY_DETAIL_DEFINE_ALL_SIMD_SPLIT_OVERLOADS(...) \
+  template struct SimdSplitByCharImpl<std::vector<__VA_ARGS__>>; \
+  template struct SimdSplitByCharImpl<folly::fbvector<__VA_ARGS__, std::allocator<__VA_ARGS__>>>; \
+  template struct SimdSplitByCharImpl<folly::small_vector<__VA_ARGS__, 1, void>>; \
+  template struct SimdSplitByCharImpl<folly::small_vector<__VA_ARGS__, 2, void>>; \
+  template struct SimdSplitByCharImpl<folly::small_vector<__VA_ARGS__, 3, void>>; \
+  template struct SimdSplitByCharImpl<folly::small_vector<__VA_ARGS__, 4, void>>; \
+  template struct SimdSplitByCharImpl<folly::small_vector<__VA_ARGS__, 5, void>>; \
+  template struct SimdSplitByCharImpl<folly::small_vector<__VA_ARGS__, 6, void>>; \
+  template struct SimdSplitByCharImpl<folly::small_vector<__VA_ARGS__, 7, void>>; \
+  template struct SimdSplitByCharImpl<folly::small_vector<__VA_ARGS__, 8, void>>;
+// clang-format on
+
+FOLLY_DETAIL_DEFINE_ALL_SIMD_SPLIT_OVERLOADS(folly::StringPiece)
+
+FOLLY_DETAIL_DEFINE_ALL_SIMD_SPLIT_OVERLOADS(std::string_view)
+
+#undef FOLLY_DETAIL_DEFINE_ALL_SIMD_SPLIT_OVERLOADS
+
+template struct SimdSplitByCharImplToStrings<std::vector<std::string>>;
+template struct SimdSplitByCharImplToStrings<std::vector<fbstring>>;
+template struct SimdSplitByCharImplToStrings<fbvector<std::string>>;
+template struct SimdSplitByCharImplToStrings<fbvector<fbstring>>;
+} // namespace detail
+} // namespace folly

package/external/folly/folly/detail/SplitStringSimd.h

@@ -0,0 +1,151 @@
+/*
+ * 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 <string>
+#include <vector>
+#include <folly/Range.h>
+
+namespace folly {
+
+template <typename T, std::size_t M, typename P>
+class small_vector;
+
+template <typename T, typename Allocator>
+class fbvector;
+
+template <class Char>
+class fbstring_core;
+
+template <typename E, typename T, typename A, typename Storage>
+class basic_fbstring;
+
+namespace detail {
+
+using PredeclareFbString = basic_fbstring<
+    char,
+    std::char_traits<char>,
+    std::allocator<char>,
+    fbstring_core<char>>;
+
+template <typename Container>
+struct SimdSplitByCharImpl {
+  static void keepEmpty(char sep, folly::StringPiece what, Container& res);
+  static void dropEmpty(char sep, folly::StringPiece what, Container& res);
+};
+
+// Different name to easier identify in the stack potential performance issues
+template <typename Container>
+struct SimdSplitByCharImplToStrings {
+  static void keepEmpty(char sep, folly::StringPiece what, Container& res);
+  static void dropEmpty(char sep, folly::StringPiece what, Container& res);
+};
+
+template <typename T>
+constexpr bool isSimdSplitSupportedStringViewType =
+    std::is_same<T, folly::StringPiece>::value ||
+    std::is_same<T, std::string_view>::value;
+
+template <typename T>
+constexpr bool isSimdSplitSupportedStringType =
+    std::is_same<T, PredeclareFbString>::value ||
+    std::is_same<T, std::string>::value;
+
+template <typename>
+struct SimdSplitByCharIsDefinedFor {
+  static constexpr bool value = false;
+};
+
+template <typename T>
+struct SimdSplitByCharIsDefinedFor<std::vector<T>> {
+  static constexpr bool value = isSimdSplitSupportedStringViewType<T> ||
+      isSimdSplitSupportedStringType<T>;
+};
+
+template <typename T, typename A>
+struct SimdSplitByCharIsDefinedFor<folly::fbvector<T, A>>
+    : SimdSplitByCharIsDefinedFor<std::vector<T, A>> {};
+
+template <typename T, std::size_t M>
+struct SimdSplitByCharIsDefinedFor<folly::small_vector<T, M, void>> {
+  static constexpr bool value =
+      isSimdSplitSupportedStringViewType<T> && 0 < M && M <= 8;
+};
+
+template <typename Container>
+std::enable_if_t<
+    isSimdSplitSupportedStringViewType<typename Container::value_type>>
+simdSplitByChar(
+    char sep, folly::StringPiece what, Container& res, bool ignoreEmpty) {
+  static_assert(
+      SimdSplitByCharIsDefinedFor<Container>::value,
+      "simd split by char is supported only for vector/fbvector/small_vector, with small size <= 8."
+      " The resulting string type has to string_view or StringPiece."
+      " There is also a special case of (fb)vector<(fb)string> for legacy compatibility");
+  if (ignoreEmpty) {
+    SimdSplitByCharImpl<Container>::dropEmpty(sep, what, res);
+  } else {
+    SimdSplitByCharImpl<Container>::keepEmpty(sep, what, res);
+  }
+}
+
+template <typename Container>
+std::enable_if_t<isSimdSplitSupportedStringType<typename Container::value_type>>
+simdSplitByChar(
+    char sep, folly::StringPiece what, Container& res, bool ignoreEmpty) {
+  static_assert(
+      SimdSplitByCharIsDefinedFor<Container>::value,
+      "simd split by char is supported only for vector/fbvector/small_vector, with small size <= 8."
+      " The resulting string type has to string_view or StringPiece."
+      " There is also a special case of (fb)vector<(fb)string> for legacy compatibility");
+  if (ignoreEmpty) {
+    SimdSplitByCharImplToStrings<Container>::dropEmpty(sep, what, res);
+  } else {
+    SimdSplitByCharImplToStrings<Container>::keepEmpty(sep, what, res);
+  }
+}
+
+// clang-format off
+#define FOLLY_DETAIL_DECLARE_ALL_SIMD_SPLIT_OVERLOADS(...) \
+  extern template struct SimdSplitByCharImpl<std::vector<__VA_ARGS__>>; \
+  extern template struct SimdSplitByCharImpl<folly::fbvector<__VA_ARGS__, std::allocator<__VA_ARGS__>>>; \
+  extern template struct SimdSplitByCharImpl<folly::small_vector<__VA_ARGS__, 1, void>>; \
+  extern template struct SimdSplitByCharImpl<folly::small_vector<__VA_ARGS__, 2, void>>; \
+  extern template struct SimdSplitByCharImpl<folly::small_vector<__VA_ARGS__, 3, void>>; \
+  extern template struct SimdSplitByCharImpl<folly::small_vector<__VA_ARGS__, 4, void>>; \
+  extern template struct SimdSplitByCharImpl<folly::small_vector<__VA_ARGS__, 5, void>>; \
+  extern template struct SimdSplitByCharImpl<folly::small_vector<__VA_ARGS__, 6, void>>; \
+  extern template struct SimdSplitByCharImpl<folly::small_vector<__VA_ARGS__, 7, void>>; \
+  extern template struct SimdSplitByCharImpl<folly::small_vector<__VA_ARGS__, 8, void>>;
+// clang-format on
+
+FOLLY_DETAIL_DECLARE_ALL_SIMD_SPLIT_OVERLOADS(folly::StringPiece)
+
+FOLLY_DETAIL_DECLARE_ALL_SIMD_SPLIT_OVERLOADS(std::string_view)
+
+extern template struct SimdSplitByCharImplToStrings<std::vector<std::string>>;
+extern template struct SimdSplitByCharImplToStrings<
+    std::vector<PredeclareFbString>>;
+extern template struct SimdSplitByCharImplToStrings<
+    fbvector<std::string, std::allocator<std::string>>>;
+extern template struct SimdSplitByCharImplToStrings<
+    fbvector<PredeclareFbString, std::allocator<PredeclareFbString>>>;
+
+#undef FOLLY_DETAIL_DECLARE_ALL_SIMD_SPLIT_OVERLOADS
+
+} // namespace detail
+} // namespace folly

package/external/folly/folly/detail/SplitStringSimdImpl.h

@@ -0,0 +1,149 @@
+/*
+ * 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/Range.h>
+#include <folly/algorithm/simd/Ignore.h>
+#include <folly/algorithm/simd/Movemask.h>
+#include <folly/algorithm/simd/detail/SimdForEach.h>
+#include <folly/algorithm/simd/detail/SimdPlatform.h>
+#include <folly/lang/Bits.h>
+
+#if FOLLY_X64
+#include <immintrin.h>
+#endif
+
+#if FOLLY_AARCH64
+#include <arm_neon.h>
+#endif
+
+// This file is not supposed to be included by users.
+// It should be included in CPP file which exposes apis.
+// It is a header file to test different platforms.
+
+// All funcitons are force inline because they are merged into big hiddend
+// noinline functions
+namespace folly {
+namespace detail {
+
+template <bool ignoreEmpty, typename Container>
+void splitByCharScalar(char sep, folly::StringPiece what, Container& res) {
+  const char* prev = what.data();
+  const char* f = prev;
+  const char* l = what.data() + what.size();
+
+  auto emplaceBack = [&](const char* sf, const char* sl) mutable {
+    if (ignoreEmpty && sf == sl) {
+      return;
+    }
+    res.emplace_back(sf, sl - sf);
+  };
+
+  while (f != l) {
+    const char* next = f + 1;
+    if (*f == sep) {
+      if (!ignoreEmpty || (prev != f)) {
+        emplaceBack(prev, f);
+      }
+      prev = next;
+    }
+    f = next;
+  }
+  emplaceBack(prev, f);
+}
+
+template <typename Platform, bool ignoreEmpty>
+struct PlatformSimdSplitByChar {
+  using reg_t = typename Platform::reg_t;
+
+  template <typename Container>
+  FOLLY_ALWAYS_INLINE void emplaceBack(
+      Container& res, const std::uint8_t* f, const std::uint8_t* l) const {
+    if (ignoreEmpty && f == l) {
+      return;
+    }
+    res.emplace_back(reinterpret_cast<const char*>(f), l - f);
+  }
+
+  template <typename Uint, typename BitsPerElement, typename Container>
+  FOLLY_ALWAYS_INLINE void outputStringsFoMmask(
+      std::pair<Uint, BitsPerElement> mmask,
+      const std::uint8_t* pos,
+      const std::uint8_t*& prev,
+      Container& res) const { // reserve was not beneficial on benchmarks.
+
+    Uint mmaskBits = mmask.first;
+    while (mmaskBits) {
+      auto counted = folly::findFirstSet(mmaskBits) - 1;
+      mmaskBits >>= counted;
+      mmaskBits >>= BitsPerElement{};
+      auto firstSet = counted / BitsPerElement{};
+
+      const std::uint8_t* split = pos + firstSet;
+      pos = split + 1;
+      emplaceBack(res, prev, split);
+      prev = pos;
+    }
+  }
+
+  template <typename Container>
+  struct ForEachDelegate {
+    const PlatformSimdSplitByChar& self;
+    std::uint8_t sep;
+    const std::uint8_t*& prev;
+    Container& res;
+
+    template <typename Ignore, typename UnrollIndex>
+    FOLLY_ALWAYS_INLINE bool step(
+        const std::uint8_t* ptr, Ignore ignore, UnrollIndex) const {
+      reg_t loaded = Platform::loada(ptr, ignore);
+      auto mmask =
+          simd::movemask<std::uint8_t>(Platform::equal(loaded, sep), ignore);
+      self.outputStringsFoMmask(mmask, ptr, prev, res);
+      return false;
+    }
+  };
+
+  template <typename Container>
+  FOLLY_ALWAYS_INLINE void operator()(
+      char sep, folly::StringPiece what, Container& res) const {
+    const std::uint8_t* what_f =
+        reinterpret_cast<const std::uint8_t*>(what.data());
+    const std::uint8_t* what_l = what_f + what.size();
+
+    const std::uint8_t* prev = what_f;
+
+    ForEachDelegate<Container> delegate{
+        *this, static_cast<std::uint8_t>(sep), prev, res};
+    simd::detail::simdForEachAligning</*unrolling*/ 1>(
+        Platform::kCardinal, what_f, what_l, delegate);
+    emplaceBack(res, prev, what_l);
+  }
+};
+
+template <bool ignoreEmpty>
+struct PlatformSimdSplitByChar<void, ignoreEmpty> {
+  template <typename Container>
+  FOLLY_ALWAYS_INLINE void operator()(
+      char sep, folly::StringPiece what, Container& res) const {
+    return splitByCharScalar<ignoreEmpty>(sep, what, res);
+  }
+};
+
+} // namespace detail
+} // namespace folly

package/external/folly/folly/detail/Sse.cpp

@@ -0,0 +1,35 @@
+/*
+ * 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/Sse.h>
+
+namespace folly {
+namespace detail {
+
+#if FOLLY_SSE_PREREQ(2, 0)
+
+FOLLY_DISABLE_SANITIZERS __m128i _mm_loadu_si128_nosan(__m128i const* const p) {
+  return _mm_loadu_si128(p);
+}
+
+FOLLY_DISABLE_SANITIZERS __m128i _mm_load_si128_nosan(__m128i const* const p) {
+  return _mm_load_si128(p);
+}
+
+#endif
+
+} // namespace detail
+} // namespace folly