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

package/external/folly/folly/portability/Filesystem.h

@@ -0,0 +1,114 @@
+/*
+ * 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
+
+#if __has_include(<filesystem>)
+#include <filesystem>
+#elif __has_include(<experimental/filesystem>)
+#include <experimental/filesystem>
+#else
+#error require filesystem
+#endif
+
+namespace folly::fs {
+
+enum class which_enum {
+  std = 1,
+  std_experimental = 2,
+};
+
+#if __cpp_lib_filesystem >= 201703
+
+namespace std_fs = std::filesystem;
+inline constexpr which_enum which = which_enum::std;
+
+#elif __cpp_lib_experimental_filesystem >= 201406
+
+namespace std_fs = std::experimental::filesystem;
+inline constexpr which_enum which = which_enum::std_experimental;
+
+#else
+#error require filesystem
+#endif
+
+//  imports
+
+using std_fs::absolute;
+using std_fs::canonical;
+using std_fs::copy;
+using std_fs::copy_file;
+using std_fs::copy_options;
+using std_fs::copy_symlink;
+using std_fs::create_directories;
+using std_fs::create_directory;
+using std_fs::create_directory_symlink;
+using std_fs::create_hard_link;
+using std_fs::create_symlink;
+using std_fs::current_path;
+using std_fs::directory_entry;
+using std_fs::directory_iterator;
+using std_fs::directory_options;
+using std_fs::equivalent;
+using std_fs::exists;
+using std_fs::file_size;
+using std_fs::file_status;
+using std_fs::file_time_type;
+using std_fs::file_type;
+using std_fs::filesystem_error;
+using std_fs::hard_link_count;
+using std_fs::is_block_file;
+using std_fs::is_character_file;
+using std_fs::is_directory;
+using std_fs::is_empty;
+using std_fs::is_fifo;
+using std_fs::is_other;
+using std_fs::is_regular_file;
+using std_fs::is_socket;
+using std_fs::is_symlink;
+using std_fs::last_write_time;
+using std_fs::path;
+using std_fs::permissions;
+using std_fs::perms;
+using std_fs::read_symlink;
+using std_fs::recursive_directory_iterator;
+using std_fs::remove;
+using std_fs::remove_all;
+using std_fs::rename;
+using std_fs::resize_file;
+using std_fs::space;
+using std_fs::space_info;
+using std_fs::status;
+using std_fs::status_known;
+using std_fs::symlink_status;
+using std_fs::temp_directory_path;
+using std_fs::u8path;
+
+#if __cpp_lib_filesystem >= 201703
+
+using std_fs::perm_options;
+using std_fs::proximate;
+using std_fs::relative;
+using std_fs::weakly_canonical;
+
+#endif
+
+struct lexically_normal_fn {
+  path operator()(path const& p) const;
+};
+inline constexpr lexically_normal_fn lexically_normal;
+
+} // namespace folly::fs

package/external/folly/folly/portability/FmtCompile.h

@@ -0,0 +1,40 @@
+/*
+ * 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 <fmt/compile.h>
+
+#if !defined(FMT_COMPILE)
+
+#define FOLLY_FMT_COMPILE(format_str) format_str
+
+#elif defined(_MSC_VER)
+
+// Workaround broken constexpr in MSVC.
+#define FOLLY_FMT_COMPILE(format_str) format_str
+
+#elif defined(__GNUC__) && !defined(__clang__) && __GNUC__ <= 8
+
+// Forcefully disable compiled format strings for GCC 8 & below until fmt is
+// updated to do this automatically.
+#define FOLLY_FMT_COMPILE(format_str) format_str
+
+#else
+
+#define FOLLY_FMT_COMPILE(format_str) FMT_COMPILE(format_str)
+
+#endif

package/external/folly/folly/portability/GFlags.h

@@ -0,0 +1,139 @@
+/*
+ * 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/Config.h>
+
+#include <cstdint>
+#include <string>
+
+#if FOLLY_HAVE_LIBGFLAGS && __has_include(<gflags/gflags.h>)
+#include <gflags/gflags.h>
+#endif
+
+#define FOLLY_GFLAGS_DECLARE_FALLBACK_(_type, _shortType, _name) \
+  namespace fL##_shortType {                                     \
+    extern _type FLAGS_##_name;                                  \
+  }                                                              \
+  using fL##_shortType::FLAGS_##_name
+
+#define FOLLY_GFLAGS_DEFINE_FALLBACK_(                \
+    _type, _shortType, _name, _default, _description) \
+  namespace fL##_shortType {                          \
+    _type FLAGS_##_name = _default;                   \
+  }                                                   \
+  using fL##_shortType::FLAGS_##_name
+
+#if FOLLY_HAVE_LIBGFLAGS && __has_include(<gflags/gflags.h>)
+
+#define FOLLY_GFLAGS_DECLARE_bool(_name) DECLARE_bool(_name)
+#define FOLLY_GFLAGS_DECLARE_double(_name) DECLARE_double(_name)
+#define FOLLY_GFLAGS_DECLARE_int32(_name) DECLARE_int32(_name)
+#define FOLLY_GFLAGS_DECLARE_int64(_name) DECLARE_int64(_name)
+#define FOLLY_GFLAGS_DECLARE_uint64(_name) DECLARE_uint64(_name)
+#define FOLLY_GFLAGS_DECLARE_string(_name) DECLARE_string(_name)
+
+#if defined(DECLARE_uint32)
+#define FOLLY_GFLAGS_DECLARE_uint32(_name) DECLARE_uint32(_name)
+#else
+#define FOLLY_GFLAGS_DECLARE_uint32(_name) \
+  FOLLY_GFLAGS_DECLARE_FALLBACK_(::std::uint32_t, U32, _name)
+#endif
+
+#define FOLLY_GFLAGS_DEFINE_bool(_name, _default, _description) \
+  DEFINE_bool(_name, _default, _description)
+#define FOLLY_GFLAGS_DEFINE_double(_name, _default, _description) \
+  DEFINE_double(_name, _default, _description)
+#define FOLLY_GFLAGS_DEFINE_int32(_name, _default, _description) \
+  DEFINE_int32(_name, _default, _description)
+#define FOLLY_GFLAGS_DEFINE_int64(_name, _default, _description) \
+  DEFINE_int64(_name, _default, _description)
+#define FOLLY_GFLAGS_DEFINE_uint64(_name, _default, _description) \
+  DEFINE_uint64(_name, _default, _description)
+#define FOLLY_GFLAGS_DEFINE_string(_name, _default, _description) \
+  DEFINE_string(_name, _default, _description)
+
+#if defined(DEFINE_uint32)
+#define FOLLY_GFLAGS_DEFINE_uint32(_name, _default, _description) \
+  DEFINE_uint32(_name, _default, _description)
+#else
+#define FOLLY_GFLAGS_DEFINE_uint32(_name, _default, _description) \
+  FOLLY_GFLAGS_DEFINE_FALLBACK_(                                  \
+      ::std::uint32_t, U32, _name, _default, _description)
+#endif
+
+#else
+
+#define FOLLY_GFLAGS_DECLARE_bool(_name) \
+  FOLLY_GFLAGS_DECLARE_FALLBACK_(bool, B, _name)
+#define FOLLY_GFLAGS_DECLARE_double(_name) \
+  FOLLY_GFLAGS_DECLARE_FALLBACK_(double, D, _name)
+#define FOLLY_GFLAGS_DECLARE_int32(_name) \
+  FOLLY_GFLAGS_DECLARE_FALLBACK_(::std::int32_t, I, _name)
+#define FOLLY_GFLAGS_DECLARE_int64(_name) \
+  FOLLY_GFLAGS_DECLARE_FALLBACK_(::std::int64_t, I64, _name)
+#define FOLLY_GFLAGS_DECLARE_uint32(_name) \
+  FOLLY_GFLAGS_DECLARE_FALLBACK_(::std::uint32_t, U32, _name)
+#define FOLLY_GFLAGS_DECLARE_uint64(_name) \
+  FOLLY_GFLAGS_DECLARE_FALLBACK_(::std::uint64_t, U64, _name)
+#define FOLLY_GFLAGS_DECLARE_string(_name) \
+  FOLLY_GFLAGS_DECLARE_FALLBACK_(::std::string, S, _name)
+
+#define FOLLY_GFLAGS_DEFINE_bool(_name, _default, _description) \
+  FOLLY_GFLAGS_DEFINE_FALLBACK_(bool, B, _name, _default, _description)
+#define FOLLY_GFLAGS_DEFINE_double(_name, _default, _description) \
+  FOLLY_GFLAGS_DEFINE_FALLBACK_(double, D, _name, _default, _description)
+#define FOLLY_GFLAGS_DEFINE_int32(_name, _default, _description) \
+  FOLLY_GFLAGS_DEFINE_FALLBACK_(                                 \
+      ::std::int32_t, I, _name, _default, _description)
+#define FOLLY_GFLAGS_DEFINE_int64(_name, _default, _description) \
+  FOLLY_GFLAGS_DEFINE_FALLBACK_(                                 \
+      ::std::int64_t, I64, _name, _default, _description)
+#define FOLLY_GFLAGS_DEFINE_uint32(_name, _default, _description) \
+  FOLLY_GFLAGS_DEFINE_FALLBACK_(                                  \
+      ::std::uint32_t, U32, _name, _default, _description)
+#define FOLLY_GFLAGS_DEFINE_uint64(_name, _default, _description) \
+  FOLLY_GFLAGS_DEFINE_FALLBACK_(                                  \
+      ::std::uint64_t, U64, _name, _default, _description)
+#define FOLLY_GFLAGS_DEFINE_string(_name, _default, _description) \
+  FOLLY_GFLAGS_DEFINE_FALLBACK_(::std::string, S, _name, _default, _description)
+
+#endif
+
+#if FOLLY_UNUSUAL_GFLAGS_NAMESPACE
+namespace FOLLY_GFLAGS_NAMESPACE {}
+namespace gflags {
+using namespace FOLLY_GFLAGS_NAMESPACE;
+} // namespace gflags
+#endif
+
+namespace folly {
+
+#if FOLLY_HAVE_LIBGFLAGS && __has_include(<gflags/gflags.h>)
+
+using FlagSaver = gflags::FlagSaver;
+
+#else
+
+namespace detail {
+struct GflagsFlagSaver {};
+} // namespace detail
+using FlagSaver = detail::GflagsFlagSaver;
+
+#endif
+
+} // namespace folly

package/external/folly/folly/portability/GMock.h

@@ -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.
+ */
+
+#pragma once
+
+// These _must_ be included before gmock.h, because
+// it tries to include <io.h> on it's own, but we
+// override all of those functions in Unistd.h :(
+#include <folly/portability/Unistd.h>
+#include <folly/portability/Windows.h>
+
+#include <folly/Portability.h>
+
+// Disable a couple of warnings due to GMock exporting classes
+// that derive from stdlib classes which aren't explicitly exported.
+FOLLY_PUSH_WARNING
+FOLLY_MSVC_DISABLE_WARNING(4251)
+FOLLY_MSVC_DISABLE_WARNING(4275)
+// IWYU pragma: begin_exports
+#include <gmock/gmock.h>
+// IWYU pragma: end_exports
+FOLLY_POP_WARNING

package/external/folly/folly/portability/GTest.h

@@ -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.
+ */
+
+#pragma once
+
+// These _must_ be included before gtest.h, because
+// it tries to include <io.h> on it's own, but we
+// override all of those functions in Unistd.h :(
+#include <folly/portability/Unistd.h>
+#include <folly/portability/Windows.h>
+
+#include <folly/Portability.h>
+
+// Disable a couple of warnings due to GTest exporting classes
+// that derive from stdlib classes which aren't explicitly exported.
+FOLLY_PUSH_WARNING
+FOLLY_MSVC_DISABLE_WARNING(4251)
+FOLLY_MSVC_DISABLE_WARNING(4275)
+// IWYU pragma: begin_exports
+#include <gtest/gtest.h>
+// IWYU pragma: end_exports
+FOLLY_POP_WARNING

package/external/folly/folly/portability/IOVec.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
+
+// This file only exists because without it there would be
+// a circular dependency between SysUio.h, Sockets.h, and Unistd.h
+#ifndef _WIN32
+#include <limits.h>
+#include <sys/uio.h>
+#else
+#include <stdlib.h>
+
+#define UIO_MAXIOV 16
+#define IOV_MAX UIO_MAXIOV
+
+struct iovec {
+  void* iov_base;
+  size_t iov_len;
+};
+#endif

package/external/folly/folly/portability/Libgen.cpp

@@ -0,0 +1,59 @@
+/*
+ * 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/portability/Libgen.h>
+
+#include <cstring>
+
+namespace folly {
+namespace portability {
+static char mutableDot[] = {'.', '\0'};
+char* internal_dirname(char* path) {
+  if (path == nullptr || !strcmp(path, "")) {
+    return mutableDot;
+  }
+  if (!strcmp(path, "/") || !strcmp(path, "\\")) {
+    return path;
+  }
+
+  size_t len = strlen(path);
+  if (path[len - 1] == '/' || path[len - 1] == '\\') {
+    path[len - 1] = '\0';
+  }
+
+  char* pos = strrchr(path, '/');
+  if (strrchr(path, '\\') > pos) {
+    pos = strrchr(path, '\\');
+  }
+  if (pos == nullptr) {
+    return mutableDot;
+  }
+
+  if (pos == path) {
+    *(pos + 1) = '\0';
+  } else {
+    *pos = '\0';
+  }
+  return path;
+}
+} // namespace portability
+} // namespace folly
+
+#ifdef _WIN32
+extern "C" char* dirname(char* path) {
+  return folly::portability::internal_dirname(path);
+}
+#endif

package/external/folly/folly/portability/Libgen.h

@@ -0,0 +1,29 @@
+/*
+ * 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
+
+namespace folly {
+namespace portability {
+char* internal_dirname(char* path);
+} // namespace portability
+} // namespace folly
+
+#ifndef _WIN32
+#include <libgen.h>
+#else
+extern "C" char* dirname(char* path);
+#endif

package/external/folly/folly/portability/Libunwind.h

@@ -0,0 +1,21 @@
+/*
+ * 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
+
+#if __has_include(<libunwind.h>)
+#include <libunwind.h> // @manual
+#endif

package/external/folly/folly/portability/Malloc.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/portability/Malloc.h>
+
+#if !defined(USE_JEMALLOC) && !defined(FOLLY_USE_JEMALLOC)
+#if defined(__APPLE__) && !defined(FOLLY_HAVE_MALLOC_USABLE_SIZE)
+#include <malloc/malloc.h> // @manual
+
+extern "C" size_t malloc_usable_size(void* ptr) {
+  return malloc_size(ptr);
+}
+#elif defined(_WIN32)
+extern "C" size_t malloc_usable_size(void* addr) {
+  return _msize(addr);
+}
+#endif
+#endif

package/external/folly/folly/portability/Malloc.h

@@ -0,0 +1,53 @@
+/*
+ * 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 <stdlib.h>
+
+#include <folly/CPortability.h>
+#include <folly/portability/Config.h>
+
+#if (defined(USE_JEMALLOC) || defined(FOLLY_USE_JEMALLOC)) && \
+    !defined(FOLLY_SANITIZE)
+#if defined(FOLLY_ASSUME_NO_JEMALLOC)
+#error \
+    "Both USE_JEMALLOC/FOLLY_USE_JEMALLOC and FOLLY_ASSUME_NO_JEMALLOC defined"
+#endif
+// JEMalloc provides it's own implementation of
+// malloc_usable_size, and that's what we should be using.
+#if defined(__FreeBSD__)
+#include <malloc_np.h> // @manual
+#define FOLLY_HAS_JEMALLOC_DEFS 0
+#else
+#include <jemalloc/jemalloc.h> // @manual
+#define FOLLY_HAS_JEMALLOC_DEFS 1
+#endif
+#else
+#if !defined(__FreeBSD__)
+#if __has_include(<malloc.h>)
+#include <malloc.h>
+#endif
+#define FOLLY_HAS_JEMALLOC_DEFS 0
+#endif
+
+#if defined(__APPLE__) && !defined(FOLLY_HAVE_MALLOC_USABLE_SIZE)
+// MacOS doesn't have malloc_usable_size()
+extern "C" size_t malloc_usable_size(void* ptr);
+#elif defined(_WIN32)
+extern "C" size_t malloc_usable_size(void* ptr);
+#endif
+#endif

package/external/folly/folly/portability/Math.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 <cmath>
+
+namespace folly {
+
+#if !defined(__ANDROID__) && !defined(__UCLIBC__)
+
+/**
+ * Most platforms hopefully provide std::nextafter, std::remainder.
+ */
+
+/* using override */ using std::nextafter;
+/* using override */ using std::remainder;
+
+#else // !__ANDROID__ && !__UCLIBC__
+
+/**
+ * On Android and uclibc, std::nextafter or std::remainder isn't implemented.
+ * However, the C functions and compiler builtins are still provided. Using the
+ * GCC builtin is actually slightly faster, as they're constexpr and the use
+ * cases within folly are in constexpr context.
+ */
+
+#if defined(__GNUC__) && !defined(__clang__)
+
+constexpr float nextafter(float x, float y) {
+  return __builtin_nextafterf(x, y);
+}
+
+constexpr double nextafter(double x, double y) {
+  return __builtin_nextafter(x, y);
+}
+
+constexpr long double nextafter(long double x, long double y) {
+  return __builtin_nextafterl(x, y);
+}
+
+#else // __GNUC__
+
+inline float nextafter(float x, float y) {
+  return ::nextafterf(x, y);
+}
+
+inline double nextafter(double x, double y) {
+  return ::nextafter(x, y);
+}
+
+inline long double nextafter(long double x, long double y) {
+  return ::nextafterl(x, y);
+}
+
+#endif // __GNUC__
+
+/**
+ * On uclibc, std::remainder isn't implemented.
+ * Implement it using builtin versions
+ */
+#ifdef __UCLIBC__
+constexpr float remainder(float x, float y) {
+  return __builtin_remainderf(x, y);
+}
+
+constexpr double remainder(double x, double y) {
+  return __builtin_remainder(x, y);
+}
+
+constexpr long double remainder(long double x, long double y) {
+  return __builtin_remainderl(x, y);
+}
+#endif // __UCLIBC__
+
+#endif // !__ANDROID__ && !__UCLIBC__
+} // namespace folly