react-native-windows 0.84.0 → 0.84.1

package/external/folly/folly/detail/RangeCommon.cpp

@@ -0,0 +1,55 @@
+/*
+ * 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/RangeCommon.h>
+
+#include <bitset>
+
+#include <folly/container/SparseByteSet.h>
+
+namespace folly {
+
+namespace detail {
+
+size_t qfind_first_byte_of_bitset(
+    const StringPieceLite haystack, const StringPieceLite needles) {
+  std::bitset<256> s;
+  for (auto needle : needles) {
+    s[(uint8_t)needle] = true;
+  }
+  for (size_t index = 0; index < haystack.size(); ++index) {
+    if (s[(uint8_t)haystack[index]]) {
+      return index;
+    }
+  }
+  return std::string::npos;
+}
+
+size_t qfind_first_byte_of_byteset(
+    const StringPieceLite haystack, const StringPieceLite needles) {
+  SparseByteSet s;
+  for (auto needle : needles) {
+    s.add(uint8_t(needle));
+  }
+  for (size_t index = 0; index < haystack.size(); ++index) {
+    if (s.contains(uint8_t(haystack[index]))) {
+      return index;
+    }
+  }
+  return std::string::npos;
+}
+} // namespace detail
+} // namespace folly

package/external/folly/folly/detail/RangeCommon.h

@@ -0,0 +1,93 @@
+/*
+ * 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 <algorithm>
+#include <cassert>
+#include <string>
+
+#include <folly/Likely.h>
+
+namespace folly {
+
+namespace detail {
+
+/***
+ *  The qfind_first_byte_of_* functions are declared here, before Range.h, so
+ *  they cannot take StringPiece values. But they're there to operate on
+ *  StringPiece values. Dependency cycles: fun.
+ *
+ *  StringPieceLite is here to break that dependency cycle.
+ */
+class StringPieceLite {
+ public:
+  StringPieceLite(const char* b, const char* e) : b_(b), e_(e) {}
+  template <typename Range>
+  /* implicit */ StringPieceLite(const Range& r)
+      : StringPieceLite(r.data(), r.data() + r.size()) {}
+  const char* data() const { return b_; }
+  const char* begin() const { return b_; }
+  const char* end() const { return e_; }
+  size_t size() const { return size_t(e_ - b_); }
+  bool empty() const { return size() == 0; }
+  const char& operator[](size_t i) const {
+    assert(size() > i);
+    return b_[i];
+  }
+  template <typename Range>
+  explicit operator Range() const {
+    return Range(begin(), end());
+  }
+
+ private:
+  const char* b_;
+  const char* e_;
+};
+
+inline size_t qfind_first_byte_of_std(
+    const StringPieceLite haystack, const StringPieceLite needles) {
+  auto ret = std::find_first_of(
+      haystack.begin(),
+      haystack.end(),
+      needles.begin(),
+      needles.end(),
+      [](char a, char b) { return a == b; });
+  return ret == haystack.end() ? std::string::npos : ret - haystack.begin();
+}
+
+size_t qfind_first_byte_of_bitset(
+    const StringPieceLite haystack, const StringPieceLite needles);
+
+size_t qfind_first_byte_of_byteset(
+    const StringPieceLite haystack, const StringPieceLite needles);
+
+inline size_t qfind_first_byte_of_nosse(
+    const StringPieceLite haystack, const StringPieceLite needles) {
+  if (FOLLY_UNLIKELY(needles.empty() || haystack.empty())) {
+    return std::string::npos;
+  }
+  // The thresholds below were empirically determined by benchmarking.
+  // This is not an exact science since it depends on the CPU, the size of
+  // needles, and the size of haystack.
+  if ((needles.size() >= 4 && haystack.size() <= 10) ||
+      (needles.size() >= 16 && haystack.size() <= 64) || needles.size() >= 32) {
+    return qfind_first_byte_of_byteset(haystack, needles);
+  }
+  return qfind_first_byte_of_std(haystack, needles);
+}
+} // namespace detail
+} // namespace folly

package/external/folly/folly/detail/RangeSse42.cpp

@@ -0,0 +1,198 @@
+/*
+ * 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/RangeSse42.h>
+
+#include <cassert>
+
+#include <folly/Portability.h>
+
+//  Essentially, two versions of this file: one with an SSE42 implementation
+//  and one with a fallback implementation. We determine which version to use by
+//  testing for the presence of the required headers.
+//
+//  TODO: Maybe this should be done by the build system....
+#if !FOLLY_SSE_PREREQ(4, 2)
+namespace folly {
+namespace detail {
+size_t qfind_first_byte_of_sse42(
+    const StringPieceLite haystack, const StringPieceLite needles) {
+  return qfind_first_byte_of_nosse(haystack, needles);
+}
+} // namespace detail
+} // namespace folly
+#else
+#include <emmintrin.h>
+#include <nmmintrin.h>
+#include <smmintrin.h>
+
+#include <cstdint>
+#include <limits>
+#include <string>
+
+#include <folly/Likely.h>
+#include <folly/detail/Sse.h>
+
+namespace folly {
+namespace detail {
+
+// It's okay if pages are bigger than this (as powers of two), but they should
+// not be smaller.
+static constexpr size_t kMinPageSize = 4096;
+static_assert(
+    kMinPageSize >= 16, "kMinPageSize must be at least SSE register size");
+
+template <typename T>
+static inline uintptr_t page_for(T* addr) {
+  return reinterpret_cast<uintptr_t>(addr) / kMinPageSize;
+}
+
+static inline size_t nextAlignedIndex(const char* arr) {
+  auto firstPossible = reinterpret_cast<uintptr_t>(arr) + 1;
+  return 1 + // add 1 because the index starts at 'arr'
+      ((firstPossible + 15) & ~0xF) // round up to next multiple of 16
+      - firstPossible;
+}
+
+// helper method for case where needles.size() <= 16
+size_t qfind_first_byte_of_needles16(
+    const StringPieceLite haystack, const StringPieceLite needles) {
+  assert(haystack.size() > 0u);
+  assert(needles.size() > 0u);
+  assert(needles.size() <= 16u);
+  if ((needles.size() <= 2 && haystack.size() >= 256) ||
+      // must bail if we can't even SSE-load a single segment of haystack
+      (haystack.size() < 16 &&
+       page_for(haystack.end() - 1) != page_for(haystack.data() + 15)) ||
+      // can't load needles into SSE register if it could cross page boundary
+      page_for(needles.end() - 1) != page_for(needles.data() + 15)) {
+    return detail::qfind_first_byte_of_nosse(haystack, needles);
+  }
+
+  auto arr2 = _mm_loadu_si128_unchecked(
+      reinterpret_cast<const __m128i*>(needles.data()));
+  // do an unaligned load for first block of haystack
+  auto arr1 = _mm_loadu_si128_unchecked(
+      reinterpret_cast<const __m128i*>(haystack.data()));
+  auto index =
+      _mm_cmpestri(arr2, int(needles.size()), arr1, int(haystack.size()), 0);
+  if (index < 16) {
+    return size_t(index);
+  }
+
+  // Now, we can do aligned loads hereafter...
+  size_t i = nextAlignedIndex(haystack.data());
+  for (; i < haystack.size(); i += 16) {
+    arr1 = _mm_load_si128_unchecked(
+        reinterpret_cast<const __m128i*>(haystack.data() + i));
+    index = _mm_cmpestri(
+        arr2, int(needles.size()), arr1, int(haystack.size() - i), 0);
+    if (index < 16) {
+      return i + index;
+    }
+  }
+  return std::string::npos;
+}
+
+// Scans a 16-byte block of haystack (starting at blockStartIdx) to find first
+// needle. If HAYSTACK_ALIGNED, then haystack must be 16byte aligned.
+// If !HAYSTACK_ALIGNED, then caller must ensure that it is safe to load the
+// block.
+template <bool HAYSTACK_ALIGNED>
+size_t scanHaystackBlock(
+    const StringPieceLite haystack,
+    const StringPieceLite needles,
+    uint64_t blockStartIdx) {
+  assert(needles.size() > 16u); // should handled by *needles16() method
+  assert(
+      blockStartIdx + 16 <= haystack.size() ||
+      (page_for(haystack.data() + blockStartIdx) ==
+       page_for(haystack.data() + blockStartIdx + 15)));
+
+  __m128i arr1;
+  if (HAYSTACK_ALIGNED) {
+    arr1 = _mm_load_si128_unchecked(
+        reinterpret_cast<const __m128i*>(haystack.data() + blockStartIdx));
+  } else {
+    arr1 = _mm_loadu_si128_unchecked(
+        reinterpret_cast<const __m128i*>(haystack.data() + blockStartIdx));
+  }
+
+  // This load is safe because needles.size() >= 16
+  auto arr2 = _mm_loadu_si128(reinterpret_cast<const __m128i*>(needles.data()));
+  auto b =
+      _mm_cmpestri(arr2, 16, arr1, int(haystack.size() - blockStartIdx), 0);
+
+  size_t j = nextAlignedIndex(needles.data());
+  for (; j < needles.size(); j += 16) {
+    arr2 = _mm_load_si128_unchecked(
+        reinterpret_cast<const __m128i*>(needles.data() + j));
+
+    auto index = _mm_cmpestri(
+        arr2,
+        int(needles.size() - j),
+        arr1,
+        int(haystack.size() - blockStartIdx),
+        0);
+    b = std::min(index, b);
+  }
+
+  if (b < 16) {
+    return blockStartIdx + b;
+  }
+  return std::string::npos;
+}
+
+size_t qfind_first_byte_of_sse42(
+    const StringPieceLite haystack, const StringPieceLite needles);
+
+size_t qfind_first_byte_of_sse42(
+    const StringPieceLite haystack, const StringPieceLite needles) {
+  if (FOLLY_UNLIKELY(needles.empty() || haystack.empty())) {
+    return std::string::npos;
+  } else if (needles.size() <= 16) {
+    // we can save some unnecessary load instructions by optimizing for
+    // the common case of needles.size() <= 16
+    return qfind_first_byte_of_needles16(haystack, needles);
+  }
+
+  if (haystack.size() < 16 &&
+      page_for(haystack.end() - 1) != page_for(haystack.data() + 16)) {
+    // We can't safely SSE-load haystack. Use a different approach.
+    if (haystack.size() <= 2) {
+      return qfind_first_byte_of_std(haystack, needles);
+    }
+    return qfind_first_byte_of_byteset(haystack, needles);
+  }
+
+  auto ret = scanHaystackBlock<false>(haystack, needles, 0);
+  if (ret != std::string::npos) {
+    return ret;
+  }
+
+  size_t i = nextAlignedIndex(haystack.data());
+  for (; i < haystack.size(); i += 16) {
+    ret = scanHaystackBlock<true>(haystack, needles, i);
+    if (ret != std::string::npos) {
+      return ret;
+    }
+  }
+
+  return std::string::npos;
+}
+} // namespace detail
+} // namespace folly
+#endif

package/external/folly/folly/detail/RangeSse42.h

@@ -0,0 +1,30 @@
+/*
+ * 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 <cstddef>
+
+#include <folly/detail/RangeCommon.h>
+
+namespace folly {
+
+namespace detail {
+
+size_t qfind_first_byte_of_sse42(
+    const StringPieceLite haystack, const StringPieceLite needles);
+} // namespace detail
+} // namespace folly

package/external/folly/folly/detail/SimpleSimdStringUtils.cpp

@@ -0,0 +1,31 @@
+/*
+ * 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/SimpleSimdStringUtils.h>
+
+#include <folly/algorithm/simd/detail/SimdPlatform.h>
+#include <folly/detail/SimpleSimdStringUtilsImpl.h>
+
+namespace folly {
+namespace detail {
+
+bool simdHasSpaceOrCntrlSymbols(folly::StringPiece s) {
+  return SimpleSimdStringUtilsImpl<
+      simd::detail::SimdPlatform<std::uint8_t>>::hasSpaceOrCntrlSymbols(s);
+}
+
+} // namespace detail
+} // namespace folly

package/external/folly/folly/detail/SimpleSimdStringUtils.h

@@ -0,0 +1,27 @@
+/*
+ * 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/Range.h>
+
+namespace folly {
+namespace detail {
+
+bool simdHasSpaceOrCntrlSymbols(folly::StringPiece s);
+
+} // namespace detail
+} // namespace folly

package/external/folly/folly/detail/SimpleSimdStringUtilsImpl.h

@@ -0,0 +1,63 @@
+/*
+ * 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/Range.h>
+#include <folly/algorithm/simd/detail/SimdAnyOf.h>
+#include <folly/algorithm/simd/detail/SimdPlatform.h>
+
+namespace folly {
+namespace detail {
+
+// Implementations of SimpleSimdStringUtils
+
+template <typename Platform>
+struct SimpleSimdStringUtilsImpl {
+  using reg_t = typename Platform::reg_t;
+  using logical_t = typename Platform::logical_t;
+
+  struct HasSpaceOrCntrlSymbolsLambda {
+    FOLLY_ALWAYS_INLINE
+    logical_t operator()(reg_t reg) {
+      // This happens to be equivalent to std::isspace(c) || std::iscntrl(c)
+      return Platform::logical_or(
+          Platform::less_equal(reg, 0x20), Platform::equal(reg, 0x7F));
+    }
+  };
+
+  FOLLY_ALWAYS_INLINE
+  static bool hasSpaceOrCntrlSymbols(folly::StringPiece s) {
+    return simd::detail::simdAnyOf<Platform, /*unrolling*/ 4>(
+        reinterpret_cast<const std::uint8_t*>(s.data()),
+        reinterpret_cast<const std::uint8_t*>(s.data() + s.size()),
+        HasSpaceOrCntrlSymbolsLambda{});
+  }
+};
+
+template <>
+struct SimpleSimdStringUtilsImpl<void> {
+  FOLLY_ALWAYS_INLINE
+  static bool hasSpaceOrCntrlSymbols(folly::StringPiece s) {
+    return std::any_of(s.begin(), s.end(), [](char c) {
+      std::uint32_t uc = static_cast<std::uint8_t>(c);
+      return uc <= 0x20 || c == 0x7F;
+    });
+  }
+};
+
+} // namespace detail
+} // namespace folly

package/external/folly/folly/detail/Singleton.h

@@ -0,0 +1,34 @@
+/*
+ * 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/Traits.h>
+
+namespace folly {
+namespace detail {
+
+struct FOLLY_EXPORT DefaultTag {};
+
+template <typename T>
+struct DefaultMake {
+  T operator()() const { return T(); }
+};
+
+} // namespace detail
+} // namespace folly

package/external/folly/folly/detail/SlowFingerprint.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 <folly/Fingerprint.h>
+#include <folly/Range.h>
+#include <folly/detail/FingerprintPolynomial.h>
+
+namespace folly {
+namespace detail {
+
+/**
+ * Slow, one-bit-at-a-time implementation of the Rabin fingerprint.
+ *
+ * This is useful as a reference implementation to test the Broder optimization
+ * for correctness in the unittest; it's probably too slow for any real use.
+ */
+template <int BITS>
+class SlowFingerprint {
+ public:
+  SlowFingerprint() : poly_(FingerprintTable<BITS>::poly) {
+    // Use the same starting value as Fingerprint, (1 << (BITS-1))
+    fp_.addXk(BITS - 1);
+  }
+
+  SlowFingerprint& update8(uint8_t v) {
+    updateLSB(v, 8);
+    return *this;
+  }
+
+  SlowFingerprint& update32(uint32_t v) {
+    updateLSB(v, 32);
+    return *this;
+  }
+
+  SlowFingerprint& update64(uint64_t v) {
+    updateLSB(v, 64);
+    return *this;
+  }
+
+  SlowFingerprint& update(const folly::StringPiece str) {
+    const char* p = str.start();
+    for (int i = str.size(); i != 0; p++, i--) {
+      update8(static_cast<uint8_t>(*p));
+    }
+    return *this;
+  }
+
+  void write(uint64_t* out) const {
+    for (int i = 0; i < fp_.size(); ++i) {
+      out[i] = fp_.get(i);
+    }
+  }
+
+ private:
+  void updateBit(bool bit) {
+    fp_.mulXmod(poly_);
+    if (bit) {
+      fp_.addXk(0);
+    }
+  }
+
+  void updateLSB(uint64_t val, int bits) {
+    val <<= (64 - bits);
+    for (; bits != 0; --bits) {
+      updateBit(val & (1ULL << 63));
+      val <<= 1;
+    }
+  }
+
+  const FingerprintPolynomial<BITS - 1> poly_;
+  FingerprintPolynomial<BITS - 1> fp_;
+};
+
+} // namespace detail
+} // namespace folly