react-native-windows 0.84.0-preview.9 → 0.84.1

package/external/folly/folly/synchronization/RelaxedAtomic.h

@@ -0,0 +1,336 @@
+/*
+ * 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 <cstdint>
+
+namespace folly {
+
+//  relaxed_atomic
+//
+//  Like atomic, but without the std::memory_order parameters on any member
+//  functions. All operations use std::memory_order_relaxed, rather than the
+//  std::memory_order_seq_cst, which is the default memory order in std::atomic.
+//
+//  Useful for values which may be loaded and stored concurrently, such as
+//  counters, but which do not guard any associated data.
+template <typename T>
+struct relaxed_atomic;
+
+namespace detail {
+
+template <typename T>
+struct relaxed_atomic_base : protected std::atomic<T> {
+ private:
+  using atomic = std::atomic<T>;
+
+ public:
+  using value_type = T;
+
+  using atomic::atomic;
+
+  T operator=(T desired) noexcept {
+    store(desired);
+    return desired;
+  }
+  T operator=(T desired) volatile noexcept {
+    store(desired);
+    return desired;
+  }
+
+  bool is_lock_free() const noexcept { return atomic::is_lock_free(); }
+  bool is_lock_free() const volatile noexcept { return atomic::is_lock_free(); }
+
+  void store(T desired) noexcept {
+    atomic::store(desired, std::memory_order_relaxed);
+  }
+  void store(T desired) volatile noexcept {
+    atomic::store(desired, std::memory_order_relaxed);
+  }
+
+  T load() const noexcept { return atomic::load(std::memory_order_relaxed); }
+  T load() const volatile noexcept {
+    return atomic::load(std::memory_order_relaxed);
+  }
+
+  operator T() const noexcept { return load(); }
+  operator T() const volatile noexcept { return load(); }
+
+  T exchange(T desired) noexcept {
+    return atomic::exchange(desired, std::memory_order_relaxed);
+  }
+  T exchange(T desired) volatile noexcept {
+    return atomic::exchange(desired, std::memory_order_relaxed);
+  }
+
+  bool compare_exchange_weak(T& expected, T desired) noexcept {
+    return atomic::compare_exchange_weak(
+        expected, desired, std::memory_order_relaxed);
+  }
+  bool compare_exchange_weak(T& expected, T desired) volatile noexcept {
+    return atomic::compare_exchange_weak(
+        expected, desired, std::memory_order_relaxed);
+  }
+
+  bool compare_exchange_strong(T& expected, T desired) noexcept {
+    return atomic::compare_exchange_strong(
+        expected, desired, std::memory_order_relaxed);
+  }
+  bool compare_exchange_strong(T& expected, T desired) volatile noexcept {
+    return atomic::compare_exchange_strong(
+        expected, desired, std::memory_order_relaxed);
+  }
+};
+
+template <typename T>
+struct relaxed_atomic_integral_base : private relaxed_atomic_base<T> {
+ private:
+  using atomic = std::atomic<T>;
+  using base = relaxed_atomic_base<T>;
+
+ public:
+  using typename base::value_type;
+
+  using base::relaxed_atomic_base;
+  using base::operator=;
+  using base::operator T;
+  using base::compare_exchange_strong;
+  using base::compare_exchange_weak;
+  using base::exchange;
+  using base::is_lock_free;
+  using base::load;
+  using base::store;
+
+  T fetch_add(T arg) noexcept {
+    return atomic::fetch_add(arg, std::memory_order_relaxed);
+  }
+  T fetch_add(T arg) volatile noexcept {
+    return atomic::fetch_add(arg, std::memory_order_relaxed);
+  }
+
+  T fetch_sub(T arg) noexcept {
+    return atomic::fetch_sub(arg, std::memory_order_relaxed);
+  }
+  T fetch_sub(T arg) volatile noexcept {
+    return atomic::fetch_sub(arg, std::memory_order_relaxed);
+  }
+
+  T fetch_and(T arg) noexcept {
+    return atomic::fetch_and(arg, std::memory_order_relaxed);
+  }
+  T fetch_and(T arg) volatile noexcept {
+    return atomic::fetch_and(arg, std::memory_order_relaxed);
+  }
+
+  T fetch_or(T arg) noexcept {
+    return atomic::fetch_or(arg, std::memory_order_relaxed);
+  }
+  T fetch_or(T arg) volatile noexcept {
+    return atomic::fetch_or(arg, std::memory_order_relaxed);
+  }
+
+  T fetch_xor(T arg) noexcept {
+    return atomic::fetch_xor(arg, std::memory_order_relaxed);
+  }
+  T fetch_xor(T arg) volatile noexcept {
+    return atomic::fetch_xor(arg, std::memory_order_relaxed);
+  }
+
+  T operator++() noexcept { return fetch_add(1) + 1; }
+  T operator++() volatile noexcept { return fetch_add(1) + 1; }
+
+  T operator++(int) noexcept { return fetch_add(1); }
+  T operator++(int) volatile noexcept { return fetch_add(1); }
+
+  T operator--() noexcept { return fetch_sub(1) - 1; }
+  T operator--() volatile noexcept { return fetch_sub(1) - 1; }
+
+  T operator--(int) noexcept { return fetch_sub(1); }
+  T operator--(int) volatile noexcept { return fetch_sub(1); }
+
+  T operator+=(T arg) noexcept { return fetch_add(arg) + arg; }
+  T operator+=(T arg) volatile noexcept { return fetch_add(arg) + arg; }
+
+  T operator-=(T arg) noexcept { return fetch_sub(arg) - arg; }
+  T operator-=(T arg) volatile noexcept { return fetch_sub(arg) - arg; }
+
+  T operator&=(T arg) noexcept { return fetch_and(arg) & arg; }
+  T operator&=(T arg) volatile noexcept { return fetch_and(arg) & arg; }
+
+  T operator|=(T arg) noexcept { return fetch_or(arg) | arg; }
+  T operator|=(T arg) volatile noexcept { return fetch_or(arg) | arg; }
+
+  T operator^=(T arg) noexcept { return fetch_xor(arg) ^ arg; }
+  T operator^=(T arg) volatile noexcept { return fetch_xor(arg) ^ arg; }
+};
+
+} // namespace detail
+
+template <>
+struct relaxed_atomic<bool> : detail::relaxed_atomic_base<bool> {
+ private:
+  using base = detail::relaxed_atomic_base<bool>;
+
+ public:
+  using typename base::value_type;
+
+  using base::relaxed_atomic_base;
+  using base::operator=;
+  using base::operator bool;
+};
+
+using relaxed_atomic_bool = relaxed_atomic<bool>;
+
+template <typename T>
+struct relaxed_atomic : detail::relaxed_atomic_base<T> {
+ private:
+  using base = detail::relaxed_atomic_base<T>;
+
+ public:
+  using typename base::value_type;
+
+  using base::relaxed_atomic_base;
+  using base::operator=;
+  using base::operator T;
+};
+
+template <typename T>
+struct relaxed_atomic<T*> : detail::relaxed_atomic_base<T*> {
+ private:
+  using atomic = std::atomic<T*>;
+  using base = detail::relaxed_atomic_base<T*>;
+
+ public:
+  using typename base::value_type;
+
+  using detail::relaxed_atomic_base<T*>::relaxed_atomic_base;
+  using base::operator=;
+  using base::operator T*;
+
+  T* fetch_add(std::ptrdiff_t arg) noexcept {
+    return atomic::fetch_add(arg, std::memory_order_relaxed);
+  }
+  T* fetch_add(std::ptrdiff_t arg) volatile noexcept {
+    return atomic::fetch_add(arg, std::memory_order_relaxed);
+  }
+
+  T* fetch_sub(std::ptrdiff_t arg) noexcept {
+    return atomic::fetch_sub(arg, std::memory_order_relaxed);
+  }
+  T* fetch_sub(std::ptrdiff_t arg) volatile noexcept {
+    return atomic::fetch_sub(arg, std::memory_order_relaxed);
+  }
+
+  T* operator++() noexcept { return fetch_add(1) + 1; }
+  T* operator++() volatile noexcept { return fetch_add(1) + 1; }
+
+  T* operator++(int) noexcept { return fetch_add(1); }
+  T* operator++(int) volatile noexcept { return fetch_add(1); }
+
+  T* operator--() noexcept { return fetch_sub(1) - 1; }
+  T* operator--() volatile noexcept { return fetch_sub(1) - 1; }
+
+  T* operator--(int) noexcept { return fetch_sub(1); }
+  T* operator--(int) volatile noexcept { return fetch_sub(1); }
+
+  T* operator+=(std::ptrdiff_t arg) noexcept { return fetch_add(arg) + arg; }
+  T* operator+=(std::ptrdiff_t arg) volatile noexcept {
+    return fetch_add(arg) + arg;
+  }
+
+  T* operator-=(std::ptrdiff_t arg) noexcept { return fetch_sub(arg) - arg; }
+  T* operator-=(std::ptrdiff_t arg) volatile noexcept {
+    return fetch_sub(arg) - arg;
+  }
+};
+
+template <typename T>
+relaxed_atomic(T) -> relaxed_atomic<T>;
+
+#define FOLLY_RELAXED_ATOMIC_DEFINE_INTEGRAL_SPECIALIZATION(type)            \
+  template <>                                                                \
+  struct relaxed_atomic<type> : detail::relaxed_atomic_integral_base<type> { \
+   private:                                                                  \
+    using base = detail::relaxed_atomic_integral_base<type>;                 \
+                                                                             \
+   public:                                                                   \
+    using base::relaxed_atomic_integral_base;                                \
+    using base::operator=;                                                   \
+    using base::operator type;                                               \
+  };
+
+FOLLY_RELAXED_ATOMIC_DEFINE_INTEGRAL_SPECIALIZATION(char)
+FOLLY_RELAXED_ATOMIC_DEFINE_INTEGRAL_SPECIALIZATION(signed char)
+FOLLY_RELAXED_ATOMIC_DEFINE_INTEGRAL_SPECIALIZATION(unsigned char)
+FOLLY_RELAXED_ATOMIC_DEFINE_INTEGRAL_SPECIALIZATION(signed short)
+FOLLY_RELAXED_ATOMIC_DEFINE_INTEGRAL_SPECIALIZATION(unsigned short)
+FOLLY_RELAXED_ATOMIC_DEFINE_INTEGRAL_SPECIALIZATION(signed int)
+FOLLY_RELAXED_ATOMIC_DEFINE_INTEGRAL_SPECIALIZATION(unsigned int)
+FOLLY_RELAXED_ATOMIC_DEFINE_INTEGRAL_SPECIALIZATION(signed long)
+FOLLY_RELAXED_ATOMIC_DEFINE_INTEGRAL_SPECIALIZATION(unsigned long)
+FOLLY_RELAXED_ATOMIC_DEFINE_INTEGRAL_SPECIALIZATION(signed long long)
+FOLLY_RELAXED_ATOMIC_DEFINE_INTEGRAL_SPECIALIZATION(unsigned long long)
+
+#undef FOLLY_RELAXED_ATOMIC_DEFINE_INTEGRAL_SPECIALIZATION
+
+using relaxed_atomic_char = relaxed_atomic<char>;
+using relaxed_atomic_schar = relaxed_atomic<signed char>;
+using relaxed_atomic_uchar = relaxed_atomic<unsigned char>;
+using relaxed_atomic_short = relaxed_atomic<short>;
+using relaxed_atomic_ushort = relaxed_atomic<unsigned short>;
+using relaxed_atomic_int = relaxed_atomic<int>;
+using relaxed_atomic_uint = relaxed_atomic<unsigned int>;
+using relaxed_atomic_long = relaxed_atomic<long>;
+using relaxed_atomic_ulong = relaxed_atomic<unsigned long>;
+using relaxed_atomic_llong = relaxed_atomic<long long>;
+using relaxed_atomic_ullong = relaxed_atomic<unsigned long long>;
+using relaxed_atomic_char16_t = relaxed_atomic<char16_t>;
+using relaxed_atomic_char32_t = relaxed_atomic<char32_t>;
+using relaxed_atomic_wchar_t = relaxed_atomic<wchar_t>;
+using relaxed_atomic_int8_t = relaxed_atomic<std::int8_t>;
+using relaxed_atomic_uint8_t = relaxed_atomic<std::uint8_t>;
+using relaxed_atomic_int16_t = relaxed_atomic<std::int16_t>;
+using relaxed_atomic_uint16_t = relaxed_atomic<std::uint16_t>;
+using relaxed_atomic_int32_t = relaxed_atomic<std::int32_t>;
+using relaxed_atomic_uint32_t = relaxed_atomic<std::uint32_t>;
+using relaxed_atomic_int64_t = relaxed_atomic<std::int64_t>;
+using relaxed_atomic_uint64_t = relaxed_atomic<std::uint64_t>;
+using relaxed_atomic_int_least8_t = relaxed_atomic<std::int_least8_t>;
+using relaxed_atomic_uint_least8_t = relaxed_atomic<std::uint_least8_t>;
+using relaxed_atomic_int_least16_t = relaxed_atomic<std::int_least16_t>;
+using relaxed_atomic_uint_least16_t = relaxed_atomic<std::uint_least16_t>;
+using relaxed_atomic_int_least32_t = relaxed_atomic<std::int_least32_t>;
+using relaxed_atomic_uint_least32_t = relaxed_atomic<std::uint_least32_t>;
+using relaxed_atomic_int_least64_t = relaxed_atomic<std::int_least64_t>;
+using relaxed_atomic_uint_least64_t = relaxed_atomic<std::uint_least64_t>;
+using relaxed_atomic_int_fast8_t = relaxed_atomic<std::int_fast8_t>;
+using relaxed_atomic_uint_fast8_t = relaxed_atomic<std::uint_fast8_t>;
+using relaxed_atomic_int_fast16_t = relaxed_atomic<std::int_fast16_t>;
+using relaxed_atomic_uint_fast16_t = relaxed_atomic<std::uint_fast16_t>;
+using relaxed_atomic_int_fast32_t = relaxed_atomic<std::int_fast32_t>;
+using relaxed_atomic_uint_fast32_t = relaxed_atomic<std::uint_fast32_t>;
+using relaxed_atomic_int_fast64_t = relaxed_atomic<std::int_fast64_t>;
+using relaxed_atomic_uint_fast64_t = relaxed_atomic<std::uint_fast64_t>;
+using relaxed_atomic_intptr_t = relaxed_atomic<std::intptr_t>;
+using relaxed_atomic_uintptr_t = relaxed_atomic<std::uintptr_t>;
+using relaxed_atomic_size_t = relaxed_atomic<std::size_t>;
+using relaxed_atomic_ptrdiff_t = relaxed_atomic<std::ptrdiff_t>;
+using relaxed_atomic_intmax_t = relaxed_atomic<std::intmax_t>;
+using relaxed_atomic_uintmax_t = relaxed_atomic<std::uintmax_t>;
+
+} // namespace folly

package/external/folly/folly/synchronization/SanitizeThread.cpp

@@ -0,0 +1,141 @@
+/*
+ * 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/synchronization/SanitizeThread.h>
+
+#include <folly/lang/Extern.h>
+
+// abseil uses size_t for size params while other FB code and libraries use
+// long, so it is helpful to keep these declarations out of widely-included
+// header files.
+
+extern "C" void AnnotateRWLockCreate(
+    char const* f, int l, const volatile void* addr);
+
+extern "C" void AnnotateRWLockCreateStatic(
+    char const* f, int l, const volatile void* addr);
+
+extern "C" void AnnotateRWLockDestroy(
+    char const* f, int l, const volatile void* addr);
+
+extern "C" void AnnotateRWLockAcquired(
+    char const* f, int l, const volatile void* addr, long w);
+
+extern "C" void AnnotateRWLockReleased(
+    char const* f, int l, const volatile void* addr, long w);
+
+extern "C" void AnnotateBenignRaceSized(
+    char const* f,
+    int l,
+    const volatile void* addr,
+    long size,
+    char const* desc);
+
+extern "C" void AnnotateIgnoreReadsBegin(char const* f, int l);
+
+extern "C" void AnnotateIgnoreReadsEnd(char const* f, int l);
+
+extern "C" void AnnotateIgnoreWritesBegin(char const* f, int l);
+
+extern "C" void AnnotateIgnoreWritesEnd(char const* f, int l);
+
+extern "C" void AnnotateIgnoreSyncBegin(char const* f, int l);
+
+extern "C" void AnnotateIgnoreSyncEnd(char const* f, int l);
+
+namespace {
+
+FOLLY_CREATE_EXTERN_ACCESSOR(
+    annotate_rwlock_create_access_v, AnnotateRWLockCreate);
+
+FOLLY_CREATE_EXTERN_ACCESSOR(
+    annotate_rwlock_create_static_access_v, AnnotateRWLockCreateStatic);
+
+FOLLY_CREATE_EXTERN_ACCESSOR(
+    annotate_rwlock_destroy_access_v, AnnotateRWLockDestroy);
+
+FOLLY_CREATE_EXTERN_ACCESSOR(
+    annotate_rwlock_acquired_access_v, AnnotateRWLockAcquired);
+
+FOLLY_CREATE_EXTERN_ACCESSOR(
+    annotate_rwlock_released_access_v, AnnotateRWLockReleased);
+
+FOLLY_CREATE_EXTERN_ACCESSOR(
+    annotate_benign_race_sized_access_v, AnnotateBenignRaceSized);
+
+FOLLY_CREATE_EXTERN_ACCESSOR(
+    annotate_ignore_reads_begin_access_v, AnnotateIgnoreReadsBegin);
+
+FOLLY_CREATE_EXTERN_ACCESSOR(
+    annotate_ignore_reads_end_access_v, AnnotateIgnoreReadsEnd);
+
+FOLLY_CREATE_EXTERN_ACCESSOR(
+    annotate_ignore_writes_begin_access_v, AnnotateIgnoreWritesBegin);
+
+FOLLY_CREATE_EXTERN_ACCESSOR(
+    annotate_ignore_writes_end_access_v, AnnotateIgnoreWritesEnd);
+
+FOLLY_CREATE_EXTERN_ACCESSOR(
+    annotate_ignore_sync_begin_access_v, AnnotateIgnoreSyncBegin);
+
+FOLLY_CREATE_EXTERN_ACCESSOR(
+    annotate_ignore_sync_end_access_v, AnnotateIgnoreSyncEnd);
+
+} // namespace
+
+static constexpr auto const E = folly::kIsSanitizeThread;
+
+namespace folly {
+namespace detail {
+
+FOLLY_STORAGE_CONSTEXPR annotate_rwlock_cd_t* const annotate_rwlock_create_v =
+    annotate_rwlock_create_access_v<E>;
+
+FOLLY_STORAGE_CONSTEXPR annotate_rwlock_cd_t* const
+    annotate_rwlock_create_static_v = annotate_rwlock_create_static_access_v<E>;
+
+FOLLY_STORAGE_CONSTEXPR annotate_rwlock_cd_t* const annotate_rwlock_destroy_v =
+    annotate_rwlock_destroy_access_v<E>;
+
+FOLLY_STORAGE_CONSTEXPR annotate_rwlock_ar_t* const annotate_rwlock_acquired_v =
+    annotate_rwlock_acquired_access_v<E>;
+
+FOLLY_STORAGE_CONSTEXPR annotate_rwlock_ar_t* const annotate_rwlock_released_v =
+    annotate_rwlock_released_access_v<E>;
+
+FOLLY_STORAGE_CONSTEXPR annotate_benign_race_sized_t* const
+    annotate_benign_race_sized_v = annotate_benign_race_sized_access_v<E>;
+
+FOLLY_STORAGE_CONSTEXPR annotate_ignore_t* const annotate_ignore_reads_begin_v =
+    annotate_ignore_reads_begin_access_v<E>;
+
+FOLLY_STORAGE_CONSTEXPR annotate_ignore_t* const annotate_ignore_reads_end_v =
+    annotate_ignore_reads_end_access_v<E>;
+
+FOLLY_STORAGE_CONSTEXPR annotate_ignore_t* const
+    annotate_ignore_writes_begin_v = annotate_ignore_writes_begin_access_v<E>;
+
+FOLLY_STORAGE_CONSTEXPR annotate_ignore_t* const annotate_ignore_writes_end_v =
+    annotate_ignore_writes_end_access_v<E>;
+
+FOLLY_STORAGE_CONSTEXPR annotate_ignore_t* const annotate_ignore_sync_begin_v =
+    annotate_ignore_sync_begin_access_v<E>;
+
+FOLLY_STORAGE_CONSTEXPR annotate_ignore_t* const annotate_ignore_sync_end_v =
+    annotate_ignore_sync_end_access_v<E>;
+
+} // namespace detail
+} // namespace folly

package/external/folly/folly/synchronization/SanitizeThread.h

@@ -0,0 +1,166 @@
+/*
+ * 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>
+
+namespace folly {
+
+enum class annotate_rwlock_level : long {
+  rdlock = 0,
+  wrlock = 1,
+};
+
+namespace detail {
+
+using annotate_rwlock_cd_t = void(char const*, int, void const volatile*);
+using annotate_rwlock_ar_t = void(char const*, int, void const volatile*, long);
+using annotate_benign_race_sized_t =
+    void(char const*, int, void const volatile*, long, char const*);
+using annotate_ignore_t = void(char const*, int);
+
+extern annotate_rwlock_cd_t* const annotate_rwlock_create_v;
+extern annotate_rwlock_cd_t* const annotate_rwlock_create_static_v;
+extern annotate_rwlock_cd_t* const annotate_rwlock_destroy_v;
+extern annotate_rwlock_ar_t* const annotate_rwlock_acquired_v;
+extern annotate_rwlock_ar_t* const annotate_rwlock_released_v;
+extern annotate_benign_race_sized_t* const annotate_benign_race_sized_v;
+extern annotate_ignore_t* const annotate_ignore_reads_begin_v;
+extern annotate_ignore_t* const annotate_ignore_reads_end_v;
+extern annotate_ignore_t* const annotate_ignore_writes_begin_v;
+extern annotate_ignore_t* const annotate_ignore_writes_end_v;
+extern annotate_ignore_t* const annotate_ignore_sync_begin_v;
+extern annotate_ignore_t* const annotate_ignore_sync_end_v;
+
+} // namespace detail
+
+FOLLY_ALWAYS_INLINE static void annotate_rwlock_create(
+    void const volatile* const addr, char const* const f, int const l) {
+  auto fun = detail::annotate_rwlock_create_v;
+  return kIsSanitizeThread && fun ? fun(f, l, addr) : void();
+}
+
+FOLLY_ALWAYS_INLINE static void annotate_rwlock_create_static(
+    void const volatile* const addr, char const* const f, int const l) {
+  auto fun = detail::annotate_rwlock_create_static_v;
+  return kIsSanitizeThread && fun ? fun(f, l, addr) : void();
+}
+
+FOLLY_ALWAYS_INLINE static void annotate_rwlock_destroy(
+    void const volatile* const addr, char const* const f, int const l) {
+  auto fun = detail::annotate_rwlock_destroy_v;
+  return kIsSanitizeThread && fun ? fun(f, l, addr) : void();
+}
+
+FOLLY_ALWAYS_INLINE static void annotate_rwlock_acquired(
+    void const volatile* const addr,
+    annotate_rwlock_level const w,
+    char const* const f,
+    int const l) {
+  auto fun = detail::annotate_rwlock_acquired_v;
+  return kIsSanitizeThread && fun ? fun(f, l, addr, long(w)) : void();
+}
+
+FOLLY_ALWAYS_INLINE static void annotate_rwlock_try_acquired(
+    void const volatile* const addr,
+    annotate_rwlock_level const w,
+    bool const result,
+    char const* const f,
+    int const l) {
+  return result ? annotate_rwlock_acquired(addr, w, f, l) : void();
+}
+
+FOLLY_ALWAYS_INLINE static void annotate_rwlock_released(
+    void const volatile* const addr,
+    annotate_rwlock_level const w,
+    char const* const f,
+    int const l) {
+  auto fun = detail::annotate_rwlock_released_v;
+  return kIsSanitizeThread && fun ? fun(f, l, addr, long(w)) : void();
+}
+
+FOLLY_ALWAYS_INLINE static void annotate_benign_race_sized(
+    void const volatile* const addr,
+    long const size,
+    char const* const desc,
+    char const* const f,
+    int const l) {
+  auto fun = detail::annotate_benign_race_sized_v;
+  return kIsSanitizeThread && fun ? fun(f, l, addr, size, desc) : void();
+}
+
+FOLLY_ALWAYS_INLINE static void annotate_ignore_reads_begin(
+    char const* const f, int const l) {
+  auto fun = detail::annotate_ignore_reads_begin_v;
+  return kIsSanitizeThread && fun ? fun(f, l) : void();
+}
+
+FOLLY_ALWAYS_INLINE static void annotate_ignore_reads_end(
+    char const* const f, int const l) {
+  auto fun = detail::annotate_ignore_reads_end_v;
+  return kIsSanitizeThread && fun ? fun(f, l) : void();
+}
+
+FOLLY_ALWAYS_INLINE static void annotate_ignore_writes_begin(
+    char const* const f, int const l) {
+  auto fun = detail::annotate_ignore_writes_begin_v;
+  return kIsSanitizeThread && fun ? fun(f, l) : void();
+}
+
+FOLLY_ALWAYS_INLINE static void annotate_ignore_writes_end(
+    char const* const f, int const l) {
+  auto fun = detail::annotate_ignore_writes_end_v;
+  return kIsSanitizeThread && fun ? fun(f, l) : void();
+}
+
+FOLLY_ALWAYS_INLINE static void annotate_ignore_sync_begin(
+    char const* const f, int const l) {
+  auto fun = detail::annotate_ignore_sync_begin_v;
+  return kIsSanitizeThread && fun ? fun(f, l) : void();
+}
+
+FOLLY_ALWAYS_INLINE static void annotate_ignore_sync_end(
+    char const* const f, int const l) {
+  auto fun = detail::annotate_ignore_sync_end_v;
+  return kIsSanitizeThread && fun ? fun(f, l) : void();
+}
+
+class annotate_ignore_thread_sanitizer_guard {
+ public:
+  annotate_ignore_thread_sanitizer_guard(
+      char const* const file, int const line) noexcept
+      : file_{file}, line_{line} {
+    annotate_ignore_reads_begin(file_, line_);
+    annotate_ignore_writes_begin(file_, line_);
+  }
+
+  annotate_ignore_thread_sanitizer_guard(
+      const annotate_ignore_thread_sanitizer_guard&) = delete;
+  annotate_ignore_thread_sanitizer_guard& operator=(
+      const annotate_ignore_thread_sanitizer_guard&) = delete;
+
+  ~annotate_ignore_thread_sanitizer_guard() {
+    annotate_ignore_reads_end(file_, line_);
+    annotate_ignore_writes_end(file_, line_);
+  }
+
+ private:
+  char const* const file_;
+  int const line_;
+};
+
+} // namespace folly