[libc] Add differential fuzzers for ldexp and remquo.

libc/fuzzing/CMakeLists.txt

 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fsanitize=fuzzer")
 add_custom_target(libc-fuzzer)
 add_dependencies(check-libc libc-fuzzer)
 
+add_subdirectory(math)
 add_subdirectory(string)

libc/fuzzing/math/CMakeLists.txt

+add_libc_fuzzer(
+  ldexp_differential_fuzz
+  SRCS
+    ldexp_differential_fuzz.cpp
+  HDRS
+    LdExpDiff.h
+  DEPENDS
+    libc.src.math.ldexp
+    libc.utils.FPUtil.fputil
+)
+
+add_libc_fuzzer(
+  ldexpf_differential_fuzz
+  SRCS
+    ldexpf_differential_fuzz.cpp
+  HDRS
+    LdExpDiff.h
+  DEPENDS
+    libc.src.math.ldexpf
+    libc.utils.FPUtil.fputil
+)
+
+add_libc_fuzzer(
+  ldexpl_differential_fuzz
+  SRCS
+    ldexpl_differential_fuzz.cpp
+  HDRS
+    LdExpDiff.h
+  DEPENDS
+    libc.src.math.ldexpl
+    libc.utils.FPUtil.fputil
+)
+
+add_libc_fuzzer(
+  remquo_differential_fuzz
+  SRCS
+    remquo_differential_fuzz.cpp
+  HDRS
+    RemQuoDiff.h
+  DEPENDS
+    libc.src.math.remquo
+    libc.utils.FPUtil.fputil
+)
+
+add_libc_fuzzer(
+  remquof_differential_fuzz
+  SRCS
+    remquof_differential_fuzz.cpp
+  HDRS
+    RemQuoDiff.h
+  DEPENDS
+    libc.src.math.remquof
+    libc.utils.FPUtil.fputil
+)
+
+add_libc_fuzzer(
+  remquol_differential_fuzz
+  SRCS
+    remquol_differential_fuzz.cpp
+  HDRS
+    RemQuoDiff.h
+  DEPENDS
+    libc.src.math.remquol
+    libc.utils.FPUtil.fputil
+)

libc/fuzzing/math/LdExpDiff.h

+//===-- Template for diffing ldexp results ----------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "utils/FPUtil/FPBits.h"
+
+#include <math.h>
+#include <stddef.h>
+#include <stdint.h>
+
+template <typename T> using LdExpFunc = T (*)(T, int);
+
+template <typename T>
+void LdExpDiff(LdExpFunc<T> func1, LdExpFunc<T> func2, const uint8_t *data,
+               size_t size) {
+  constexpr size_t typeSize = sizeof(T);
+  if (size < typeSize + sizeof(int))
+    return;
+
+  T x = *reinterpret_cast<const T *>(data);
+  T i = *reinterpret_cast<const int *>(data + typeSize);
+
+  T result1 = func1(x, i);
+  T result2 = func2(x, i);
+  if (isnan(result1)) {
+    if (!isnan(result2))
+      __builtin_trap();
+    return;
+  }
+  if (isinf(result1)) {
+    if (isinf(result2) != isinf(result1))
+      __builtin_trap();
+    return;
+  }
+
+  __llvm_libc::fputil::FPBits<T> bits1(result1);
+  __llvm_libc::fputil::FPBits<T> bits2(result2);
+  if (bits1.bitsAsUInt() != bits2.bitsAsUInt())
+    __builtin_trap();
+}

libc/fuzzing/math/RemQuoDiff.h

+//===-- Template for diffing remquo results ---------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "utils/FPUtil/FPBits.h"
+
+#include <math.h>
+#include <stddef.h>
+#include <stdint.h>
+
+template <typename T> using RemQuoFunc = T (*)(T, T, int *);
+
+template <typename T>
+void RemQuoDiff(RemQuoFunc<T> func1, RemQuoFunc<T> func2, const uint8_t *data,
+                size_t size) {
+  constexpr size_t typeSize = sizeof(T);
+  if (size < 2 * typeSize)
+    return;
+
+  T x = *reinterpret_cast<const T *>(data);
+  T y = *reinterpret_cast<const T *>(data + typeSize);
+
+  int q1, q2;
+  T remainder1 = func1(x, y, &q1);
+  T remainder2 = func2(x, y, &q2);
+
+  if (isnan(remainder1)) {
+    if (!isnan(remainder2))
+      __builtin_trap();
+    return;
+  }
+  if (isinf(remainder1)) {
+    if (isinf(remainder2) != isinf(remainder1))
+      __builtin_trap();
+    return;
+  }
+
+  // Compare only the 3 LS bits of the quotient.
+  if ((q1 & 0x7) != (q2 & 0x7))
+    __builtin_trap();
+
+  __llvm_libc::fputil::FPBits<T> bits1(remainder1);
+  __llvm_libc::fputil::FPBits<T> bits2(remainder2);
+  if (bits1.bitsAsUInt() != bits2.bitsAsUInt())
+    __builtin_trap();
+}

libc/fuzzing/math/ldexp_differential_fuzz.cpp

+//===-- ldexp_fuzz.cpp ----------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+///
+/// Differential fuzz test for llvm-libc ldexp implementation.
+///
+//===----------------------------------------------------------------------===//
+
+#include "fuzzing/math/LdExpDiff.h"
+#include "src/math/ldexp.h"
+
+#include <math.h>
+#include <stddef.h>
+#include <stdint.h>
+
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
+  LdExpDiff<double>(&__llvm_libc::ldexp, &::ldexp, data, size);
+  return 0;
+}

libc/fuzzing/math/ldexpf_differential_fuzz.cpp

+//===-- ldexpf_fuzz.cpp ---------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+///
+/// Differential fuzz test for llvm-libc ldexpf implementation.
+///
+//===----------------------------------------------------------------------===//
+
+#include "fuzzing/math/LdExpDiff.h"
+#include "src/math/ldexpf.h"
+
+#include <math.h>
+#include <stddef.h>
+#include <stdint.h>
+
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
+  LdExpDiff<float>(&__llvm_libc::ldexpf, &::ldexpf, data, size);
+  return 0;
+}

libc/fuzzing/math/ldexpl_differential_fuzz.cpp

+//===-- ldexpl_fuzz.cpp ---------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+///
+/// Differential fuzz test for llvm-libc ldexpl implementation.
+///
+//===----------------------------------------------------------------------===//
+
+#include "fuzzing/math/LdExpDiff.h"
+#include "src/math/ldexpl.h"
+
+#include <math.h>
+#include <stddef.h>
+#include <stdint.h>
+
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
+  LdExpDiff<long double>(&__llvm_libc::ldexpl, &::ldexpl, data, size);
+  return 0;
+}

libc/fuzzing/math/remquo_differential_fuzz.cpp

+//===-- remquo_fuzz.cpp ---------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+///
+/// Differential fuzz test for llvm-libc remquo implementation.
+///
+//===----------------------------------------------------------------------===//
+
+#include "fuzzing/math/RemQuoDiff.h"
+#include "src/math/remquo.h"
+
+#include <math.h>
+#include <stddef.h>
+#include <stdint.h>
+
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
+  RemQuoDiff<double>(&__llvm_libc::remquo, &::remquo, data, size);
+  return 0;
+}

libc/fuzzing/math/remquof_differential_fuzz.cpp

+//===-- remquof_fuzz.cpp --------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+///
+/// Differential fuzz test for llvm-libc remquof implementation.
+///
+//===----------------------------------------------------------------------===//
+
+#include "fuzzing/math/RemQuoDiff.h"
+#include "src/math/remquof.h"
+
+#include <math.h>
+#include <stddef.h>
+#include <stdint.h>
+
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
+  RemQuoDiff<float>(&__llvm_libc::remquof, &::remquof, data, size);
+  return 0;
+}

libc/fuzzing/math/remquol_differential_fuzz.cpp

+//===-- remquol_fuzz.cpp --------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+///
+/// Differential fuzz test for llvm-libc remquol implementation.
+///
+//===----------------------------------------------------------------------===//
+
+#include "fuzzing/math/RemQuoDiff.h"
+#include "src/math/remquol.h"
+
+#include <math.h>
+#include <stddef.h>
+#include <stdint.h>
+
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
+  RemQuoDiff<long double>(&__llvm_libc::remquol, &::remquol, data, size);
+  return 0;
+}