diff --git a/libc/fuzzing/math/CMakeLists.txt b/libc/fuzzing/math/CMakeLists.txt index e3c29651917fc..4425fcd974455 100644 --- a/libc/fuzzing/math/CMakeLists.txt +++ b/libc/fuzzing/math/CMakeLists.txt @@ -98,15 +98,6 @@ add_libc_fuzzer( libc.src.math.cos ) -add_libc_fuzzer( - atan_fuzz - NEED_MPFR - SRCS - atan_fuzz.cpp - DEPENDS - libc.src.math.atan -) - add_libc_fuzzer( tan_fuzz NEED_MPFR @@ -124,3 +115,48 @@ add_libc_fuzzer( DEPENDS libc.src.math.sincos ) + +add_libc_fuzzer( + log_fuzz + NEED_MPFR + SRCS + log_fuzz.cpp + DEPENDS + libc.src.math.log +) + +add_libc_fuzzer( + log10_fuzz + NEED_MPFR + SRCS + log10_fuzz.cpp + DEPENDS + libc.src.math.log10 +) + +add_libc_fuzzer( + log1p_fuzz + NEED_MPFR + SRCS + log1p_fuzz.cpp + DEPENDS + libc.src.math.log1p +) + +add_libc_fuzzer( + log2_fuzz + NEED_MPFR + SRCS + log2_fuzz.cpp + DEPENDS + libc.src.math.log2 +) + +add_libc_fuzzer( + sqrt_fuzz + NEED_MPFR + SRCS + sqrt_fuzz.cpp + DEPENDS + libc.src.__support.FPUtil.generic.sqrt +) diff --git a/libc/fuzzing/math/atan_fuzz.cpp b/libc/fuzzing/math/atan_fuzz.cpp deleted file mode 100644 index 3b485786e3a63..0000000000000 --- a/libc/fuzzing/math/atan_fuzz.cpp +++ /dev/null @@ -1,38 +0,0 @@ -//===-- atan_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 -// -//===----------------------------------------------------------------------===// -/// -/// Fuzzing test for llvm-libc atan implementation. -/// -//===----------------------------------------------------------------------===// - -#include "src/math/atan.h" -#include "utils/MPFRWrapper/mpfr_inc.h" -#include - -extern "C" int LLVMFuzzerTestOneInput(double x) { - // remove NaN and inf - if (isnan(x) || isinf(x)) - return 0; - // signed zeros already tested in unit tests - if (signbit(x) && x == 0.0) - return 0; - mpfr_t input; - mpfr_init2(input, 53); - mpfr_set_d(input, x, MPFR_RNDN); - int output = mpfr_atan(input, input, MPFR_RNDN); - mpfr_subnormalize(input, output, MPFR_RNDN); - double to_compare = mpfr_get_d(input, MPFR_RNDN); - - double result = LIBC_NAMESPACE::atan(x); - - if (result != to_compare) - __builtin_trap(); - - mpfr_clear(input); - return 0; -} diff --git a/libc/fuzzing/math/log10_fuzz.cpp b/libc/fuzzing/math/log10_fuzz.cpp new file mode 100644 index 0000000000000..23134f4903a45 --- /dev/null +++ b/libc/fuzzing/math/log10_fuzz.cpp @@ -0,0 +1,51 @@ +//===-- log10_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 +// +//===----------------------------------------------------------------------===// +/// +/// Fuzzing test for llvm-libc log10 implementation. +/// +//===----------------------------------------------------------------------===// + +#include "src/math/log10.h" +#include "utils/MPFRWrapper/mpfr_inc.h" +#include +#include +#include +#include + +extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) { + mpfr_t input; + mpfr_init2(input, 53); + for (size_t i = 0; i < size / sizeof(double); ++i) { + double x; + std::memcpy(&x, data, sizeof(double)); + data += sizeof(double); + + // remove NaN and inf and values outside accepted range + if (isnan(x) || isinf(x) || x < 0) + return 0; + // signed zeros already tested in unit tests + if (signbit(x) && x == 0.0) + return 0; + + mpfr_set_d(input, x, MPFR_RNDN); + int output = mpfr_log10(input, input, MPFR_RNDN); + mpfr_subnormalize(input, output, MPFR_RNDN); + double to_compare = mpfr_get_d(input, MPFR_RNDN); + + double result = LIBC_NAMESPACE::log10(x); + + if (result != to_compare) { + std::cout << std::hexfloat << "Failing input: " << x << std::endl; + std::cout << std::hexfloat << "Failing output: " << result << std::endl; + std::cout << std::hexfloat << "Expected: " << to_compare << std::endl; + __builtin_trap(); + } + } + mpfr_clear(input); + return 0; +} diff --git a/libc/fuzzing/math/log1p_fuzz.cpp b/libc/fuzzing/math/log1p_fuzz.cpp new file mode 100644 index 0000000000000..5e138a65e3716 --- /dev/null +++ b/libc/fuzzing/math/log1p_fuzz.cpp @@ -0,0 +1,50 @@ +//===-- log1p_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 +// +//===----------------------------------------------------------------------===// +/// +/// Fuzzing test for llvm-libc log1p implementation. +/// +//===----------------------------------------------------------------------===// + +#include "src/math/log1p.h" +#include "utils/MPFRWrapper/mpfr_inc.h" +#include +#include +#include +#include + +extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) { + mpfr_t input; + mpfr_init2(input, 53); + for (size_t i = 0; i < size / sizeof(double); ++i) { + double x; + std::memcpy(&x, data, sizeof(double)); + data += sizeof(double); + // remove NaN and inf and values outside accepted range + if (isnan(x) || isinf(x) || x < -1) + return 0; + // signed zeros already tested in unit tests + if (signbit(x) && x == 0.0) + return 0; + + mpfr_set_d(input, x, MPFR_RNDN); + int output = mpfr_log1p(input, input, MPFR_RNDN); + mpfr_subnormalize(input, output, MPFR_RNDN); + double to_compare = mpfr_get_d(input, MPFR_RNDN); + + double result = LIBC_NAMESPACE::log1p(x); + + if (result != to_compare) { + std::cout << std::hexfloat << "Failing input: " << x << std::endl; + std::cout << std::hexfloat << "Failing output: " << result << std::endl; + std::cout << std::hexfloat << "Expected: " << to_compare << std::endl; + __builtin_trap(); + } + } + mpfr_clear(input); + return 0; +} diff --git a/libc/fuzzing/math/log2_fuzz.cpp b/libc/fuzzing/math/log2_fuzz.cpp new file mode 100644 index 0000000000000..aa19649b95126 --- /dev/null +++ b/libc/fuzzing/math/log2_fuzz.cpp @@ -0,0 +1,51 @@ +//===-- log2_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 +// +//===----------------------------------------------------------------------===// +/// +/// Fuzzing test for llvm-libc log2 implementation. +/// +//===----------------------------------------------------------------------===// + +#include "src/math/log2.h" +#include "utils/MPFRWrapper/mpfr_inc.h" +#include +#include +#include +#include + +extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) { + mpfr_t input; + mpfr_init2(input, 53); + for (size_t i = 0; i < size / sizeof(double); ++i) { + double x; + std::memcpy(&x, data, sizeof(double)); + data += sizeof(double); + + // remove NaN and inf and values outside accepted range + if (isnan(x) || isinf(x) || x < 0) + return 0; + // signed zeros already tested in unit tests + if (signbit(x) && x == 0.0) + return 0; + + mpfr_set_d(input, x, MPFR_RNDN); + int output = mpfr_log2(input, input, MPFR_RNDN); + mpfr_subnormalize(input, output, MPFR_RNDN); + double to_compare = mpfr_get_d(input, MPFR_RNDN); + + double result = LIBC_NAMESPACE::log2(x); + + if (result != to_compare) { + std::cout << std::hexfloat << "Failing input: " << x << std::endl; + std::cout << std::hexfloat << "Failing output: " << result << std::endl; + std::cout << std::hexfloat << "Expected: " << to_compare << std::endl; + __builtin_trap(); + } + } + mpfr_clear(input); + return 0; +} diff --git a/libc/fuzzing/math/log_fuzz.cpp b/libc/fuzzing/math/log_fuzz.cpp new file mode 100644 index 0000000000000..03aa678d1f16c --- /dev/null +++ b/libc/fuzzing/math/log_fuzz.cpp @@ -0,0 +1,50 @@ +//===-- log_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 +// +//===----------------------------------------------------------------------===// +/// +/// Fuzzing test for llvm-libc log implementation. +/// +//===----------------------------------------------------------------------===// + +#include "src/math/log.h" +#include "utils/MPFRWrapper/mpfr_inc.h" +#include +#include +#include +#include + +extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) { + mpfr_t input; + mpfr_init2(input, 53); + for (size_t i = 0; i < size / sizeof(double); ++i) { + double x; + std::memcpy(&x, data, sizeof(double)); + data += sizeof(double); + + // remove NaN and inf and values outside accepted range + if (isnan(x) || isinf(x) || x < 0) + return 0; + // signed zeros already tested in unit tests + if (signbit(x) && x == 0.0) + return 0; + mpfr_set_d(input, x, MPFR_RNDN); + int output = mpfr_log(input, input, MPFR_RNDN); + mpfr_subnormalize(input, output, MPFR_RNDN); + double to_compare = mpfr_get_d(input, MPFR_RNDN); + + double result = LIBC_NAMESPACE::log(x); + + if (result != to_compare) { + std::cout << std::hexfloat << "Failing input: " << x << std::endl; + std::cout << std::hexfloat << "Failing output: " << result << std::endl; + std::cout << std::hexfloat << "Expected: " << to_compare << std::endl; + __builtin_trap(); + } + } + mpfr_clear(input); + return 0; +} diff --git a/libc/fuzzing/math/sincos_fuzz.cpp b/libc/fuzzing/math/sincos_fuzz.cpp index 8cc6f7291a3df..fd3dfae23168c 100644 --- a/libc/fuzzing/math/sincos_fuzz.cpp +++ b/libc/fuzzing/math/sincos_fuzz.cpp @@ -6,7 +6,7 @@ // //===----------------------------------------------------------------------===// /// -/// Fuzzing test for llvm-libc cos implementation. +/// Fuzzing test for llvm-libc sincos implementation. /// //===----------------------------------------------------------------------===// diff --git a/libc/fuzzing/math/sqrt_fuzz.cpp b/libc/fuzzing/math/sqrt_fuzz.cpp new file mode 100644 index 0000000000000..e81cf1afd3728 --- /dev/null +++ b/libc/fuzzing/math/sqrt_fuzz.cpp @@ -0,0 +1,50 @@ +//===-- sqrt_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 +// +//===----------------------------------------------------------------------===// +/// +/// Fuzzing test for llvm-libc sqrt implementation. +/// +//===----------------------------------------------------------------------===// + +#include "src/__support/FPUtil/generic/sqrt.h" +#include "utils/MPFRWrapper/mpfr_inc.h" +#include +#include +#include +#include + +extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) { + mpfr_t input; + mpfr_init2(input, 53); + for (size_t i = 0; i < size / sizeof(double); ++i) { + double x; + std::memcpy(&x, data, sizeof(double)); + data += sizeof(double); + // remove NaN and inf and values outside accepted range + if (isnan(x) || isinf(x) || x < 0) + return 0; + // signed zeros already tested in unit tests + if (signbit(x) && x == 0.0) + return 0; + + mpfr_set_d(input, x, MPFR_RNDN); + int output = mpfr_sqrt(input, input, MPFR_RNDN); + mpfr_subnormalize(input, output, MPFR_RNDN); + double to_compare = mpfr_get_d(input, MPFR_RNDN); + + double result = LIBC_NAMESPACE::fputil::sqrt(x); + + if (result != to_compare) { + std::cout << std::hexfloat << "Failing input: " << x << std::endl; + std::cout << std::hexfloat << "Failing output: " << result << std::endl; + std::cout << std::hexfloat << "Expected: " << to_compare << std::endl; + __builtin_trap(); + } + } + mpfr_clear(input); + return 0; +}