caio/clang-p2996
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

[libc] Mass replace enclosing namespace (#67032)

Browse Source 
This is step 4 of
https://discourse.llvm.org/t/rfc-customizable-namespace-to-allow-testing-the-libc-when-the-system-libc-is-also-llvms-libc/73079
This commit is contained in:
Guillaume Chatelet
2023-09-26 11:45:04 +02:00
committed by GitHub
parent 7675f541f7
commit b6bc9d72f6
2032 changed files with 8520 additions and 8344 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
libc/fuzzing/math/Compare.h
View File

@@ -13,10 +13,11 @@
#include "src/__support/FPUtil/FPBits.h"
template <typename T>
__llvm_libc::cpp::enable_if_t<__llvm_libc::cpp::is_floating_point_v<T>, bool>
LIBC_NAMESPACE::cpp::enable_if_t<LIBC_NAMESPACE::cpp::is_floating_point_v<T>,
bool>
ValuesEqual(T x1, T x2) {
__llvm_libc::fputil::FPBits<T> bits1(x1);
__llvm_libc::fputil::FPBits<T> bits2(x2);
LIBC_NAMESPACE::fputil::FPBits<T> bits1(x1);
LIBC_NAMESPACE::fputil::FPBits<T> bits2(x2);
// If either is NaN, we want both to be NaN.
if (bits1.is_nan() || bits2.is_nan())
return bits2.is_nan() && bits2.is_nan();
@@ -26,7 +27,7 @@ ValuesEqual(T x1, T x2) {
}
template <typename T>
__llvm_libc::cpp::enable_if_t<__llvm_libc::cpp::is_integral_v<T>, bool>
LIBC_NAMESPACE::cpp::enable_if_t<LIBC_NAMESPACE::cpp::is_integral_v<T>, bool>
ValuesEqual(T x1, T x2) {
return x1 == x2;
}

4
libc/fuzzing/math/RemQuoDiff.h
View File

@@ -44,8 +44,8 @@ void RemQuoDiff(RemQuoFunc<T> func1, RemQuoFunc<T> func2, const uint8_t *data,
if ((q1 & 0x7) != (q2 & 0x7))
__builtin_trap();
__llvm_libc::fputil::FPBits<T> bits1(remainder1);
__llvm_libc::fputil::FPBits<T> bits2(remainder2);
LIBC_NAMESPACE::fputil::FPBits<T> bits1(remainder1);
LIBC_NAMESPACE::fputil::FPBits<T> bits2(remainder2);
if (bits1.uintval() != bits2.uintval())
__builtin_trap();
}

94
libc/fuzzing/math/math_differential_fuzz.cpp
View File

@@ -70,83 +70,89 @@
extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
SingleInputSingleOutputDiff<float>(&__llvm_libc::ceilf, &::ceilf, data, size);
SingleInputSingleOutputDiff<double>(&__llvm_libc::ceil, &::ceil, data, size);
SingleInputSingleOutputDiff<long double>(&__llvm_libc::ceill, &::ceill, data,
size);
SingleInputSingleOutputDiff<float>(&__llvm_libc::floorf, &::floorf, data,
SingleInputSingleOutputDiff<float>(&LIBC_NAMESPACE::ceilf, &::ceilf, data,
size);
SingleInputSingleOutputDiff<double>(&__llvm_libc::floor, &::floor, data,
SingleInputSingleOutputDiff<double>(&LIBC_NAMESPACE::ceil, &::ceil, data,
size);
SingleInputSingleOutputDiff<long double>(&__llvm_libc::floorl, &::floorl,
SingleInputSingleOutputDiff<long double>(&LIBC_NAMESPACE::ceill, &::ceill,
data, size);
SingleInputSingleOutputDiff<float>(&__llvm_libc::roundf, &::roundf, data,
SingleInputSingleOutputDiff<float>(&LIBC_NAMESPACE::floorf, &::floorf, data,
size);
SingleInputSingleOutputDiff<double>(&__llvm_libc::round, &::round, data,
SingleInputSingleOutputDiff<double>(&LIBC_NAMESPACE::floor, &::floor, data,
size);
SingleInputSingleOutputDiff<long double>(&__llvm_libc::roundl, &::roundl,
SingleInputSingleOutputDiff<long double>(&LIBC_NAMESPACE::floorl, &::floorl,
data, size);
SingleInputSingleOutputDiff<float>(&__llvm_libc::truncf, &::truncf, data,
SingleInputSingleOutputDiff<float>(&LIBC_NAMESPACE::roundf, &::roundf, data,
size);
SingleInputSingleOutputDiff<double>(&__llvm_libc::trunc, &::trunc, data,
SingleInputSingleOutputDiff<double>(&LIBC_NAMESPACE::round, &::round, data,
size);
SingleInputSingleOutputDiff<long double>(&__llvm_libc::truncl, &::truncl,
SingleInputSingleOutputDiff<long double>(&LIBC_NAMESPACE::roundl, &::roundl,
data, size);
SingleInputSingleOutputDiff<float>(&__llvm_libc::logbf, &::logbf, data, size);
SingleInputSingleOutputDiff<double>(&__llvm_libc::logb, &::logb, data, size);
SingleInputSingleOutputDiff<long double>(&__llvm_libc::logbl, &::logbl, data,
size);
SingleInputSingleOutputDiff<float>(&LIBC_NAMESPACE::truncf, &::truncf, data,
size);
SingleInputSingleOutputDiff<double>(&LIBC_NAMESPACE::trunc, &::trunc, data,
size);
SingleInputSingleOutputDiff<long double>(&LIBC_NAMESPACE::truncl, &::truncl,
data, size);
TwoInputSingleOutputDiff<float, float>(&__llvm_libc::hypotf, &::hypotf, data,
size);
SingleInputSingleOutputDiff<float>(&LIBC_NAMESPACE::logbf, &::logbf, data,
size);
SingleInputSingleOutputDiff<double>(&LIBC_NAMESPACE::logb, &::logb, data,
size);
SingleInputSingleOutputDiff<long double>(&LIBC_NAMESPACE::logbl, &::logbl,
data, size);
TwoInputSingleOutputDiff<float, float>(&__llvm_libc::remainderf,
TwoInputSingleOutputDiff<float, float>(&LIBC_NAMESPACE::hypotf, &::hypotf,
data, size);
TwoInputSingleOutputDiff<float, float>(&LIBC_NAMESPACE::remainderf,
&::remainderf, data, size);
TwoInputSingleOutputDiff<double, double>(&__llvm_libc::remainder,
TwoInputSingleOutputDiff<double, double>(&LIBC_NAMESPACE::remainder,
&::remainder, data, size);
TwoInputSingleOutputDiff<long double, long double>(&__llvm_libc::remainderl,
&::remainderl, data, size);
TwoInputSingleOutputDiff<long double, long double>(
&LIBC_NAMESPACE::remainderl, &::remainderl, data, size);
TwoInputSingleOutputDiff<float, float>(&__llvm_libc::fdimf, &::fdimf, data,
TwoInputSingleOutputDiff<float, float>(&LIBC_NAMESPACE::fdimf, &::fdimf, data,
size);
TwoInputSingleOutputDiff<double, double>(&__llvm_libc::fdim, &::fdim, data,
TwoInputSingleOutputDiff<double, double>(&LIBC_NAMESPACE::fdim, &::fdim, data,
size);
TwoInputSingleOutputDiff<long double, long double>(&__llvm_libc::fdiml,
TwoInputSingleOutputDiff<long double, long double>(&LIBC_NAMESPACE::fdiml,
&::fdiml, data, size);
SingleInputSingleOutputDiff<float>(&__llvm_libc::sqrtf, &::sqrtf, data, size);
SingleInputSingleOutputDiff<double>(&__llvm_libc::sqrt, &::sqrt, data, size);
SingleInputSingleOutputDiff<long double>(&__llvm_libc::sqrtl, &::sqrtl, data,
size);
SingleInputSingleOutputDiff<float>(&LIBC_NAMESPACE::sqrtf, &::sqrtf, data,
size);
SingleInputSingleOutputDiff<double>(&LIBC_NAMESPACE::sqrt, &::sqrt, data,
size);
SingleInputSingleOutputDiff<long double>(&LIBC_NAMESPACE::sqrtl, &::sqrtl,
data, size);
SingleInputSingleOutputWithSideEffectDiff<float, int>(&__llvm_libc::frexpf,
SingleInputSingleOutputWithSideEffectDiff<float, int>(&LIBC_NAMESPACE::frexpf,
&::frexpf, data, size);
SingleInputSingleOutputWithSideEffectDiff<double, int>(&__llvm_libc::frexp,
SingleInputSingleOutputWithSideEffectDiff<double, int>(&LIBC_NAMESPACE::frexp,
&::frexp, data, size);
SingleInputSingleOutputWithSideEffectDiff<long double, int>(
&__llvm_libc::frexpl, &::frexpl, data, size);
&LIBC_NAMESPACE::frexpl, &::frexpl, data, size);
SingleInputSingleOutputWithSideEffectDiff<float, float>(&__llvm_libc::modff,
&::modff, data, size);
SingleInputSingleOutputWithSideEffectDiff<float, float>(
&LIBC_NAMESPACE::modff, &::modff, data, size);
SingleInputSingleOutputWithSideEffectDiff<double, double>(
&__llvm_libc::modf, &::modf, data, size);
&LIBC_NAMESPACE::modf, &::modf, data, size);
SingleInputSingleOutputWithSideEffectDiff<long double, long double>(
&__llvm_libc::modfl, &::modfl, data, size);
&LIBC_NAMESPACE::modfl, &::modfl, data, size);
TwoInputSingleOutputDiff<float, int>(&__llvm_libc::ldexpf, &::ldexpf, data,
TwoInputSingleOutputDiff<float, int>(&LIBC_NAMESPACE::ldexpf, &::ldexpf, data,
size);
TwoInputSingleOutputDiff<double, int>(&__llvm_libc::ldexp, &::ldexp, data,
TwoInputSingleOutputDiff<double, int>(&LIBC_NAMESPACE::ldexp, &::ldexp, data,
size);
TwoInputSingleOutputDiff<long double, int>(&__llvm_libc::ldexpl, &::ldexpl,
TwoInputSingleOutputDiff<long double, int>(&LIBC_NAMESPACE::ldexpl, &::ldexpl,
data, size);
RemQuoDiff<float>(&__llvm_libc::remquof, &::remquof, data, size);
RemQuoDiff<double>(&__llvm_libc::remquo, &::remquo, data, size);
RemQuoDiff<long double>(&__llvm_libc::remquol, &::remquol, data, size);
RemQuoDiff<float>(&LIBC_NAMESPACE::remquof, &::remquof, data, size);
RemQuoDiff<double>(&LIBC_NAMESPACE::remquo, &::remquo, data, size);
RemQuoDiff<long double>(&LIBC_NAMESPACE::remquol, &::remquol, data, size);
return 0;
}

4
libc/fuzzing/math/nextafter_differential_fuzz.cpp
View File

@@ -18,9 +18,9 @@
#include "src/math/nextafterl.h"
extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
TwoInputSingleOutputDiff<float, float>(&__llvm_libc::nextafterf,
TwoInputSingleOutputDiff<float, float>(&LIBC_NAMESPACE::nextafterf,
&::nextafterf, data, size);
TwoInputSingleOutputDiff<double, double>(&__llvm_libc::nextafter,
TwoInputSingleOutputDiff<double, double>(&LIBC_NAMESPACE::nextafter,
&::nextafter, data, size);
return 0;
}

10
libc/fuzzing/stdio/printf_float_conv_fuzz.cpp
View File

@@ -38,7 +38,7 @@ enum class TestResult {
inline TestResult test_vals(const char *fmt, double num, int prec, int width) {
// Call snprintf on a nullptr to get the buffer size.
int buffer_size = __llvm_libc::snprintf(nullptr, 0, fmt, width, prec, num);
int buffer_size = LIBC_NAMESPACE::snprintf(nullptr, 0, fmt, width, prec, num);
if (buffer_size < 0) {
return TestResult::BufferSizeFailed;
@@ -50,8 +50,8 @@ inline TestResult test_vals(const char *fmt, double num, int prec, int width) {
int test_result = 0;
int reference_result = 0;
test_result =
__llvm_libc::snprintf(test_buff, buffer_size + 1, fmt, width, prec, num);
test_result = LIBC_NAMESPACE::snprintf(test_buff, buffer_size + 1, fmt, width,
prec, num);
reference_result =
mpfr_snprintf(reference_buff, buffer_size + 1, fmt, width, prec, num);
@@ -84,7 +84,7 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
int prec = 0;
int width = 0;
__llvm_libc::fputil::FPBits<double>::UIntType raw_num = 0;
LIBC_NAMESPACE::fputil::FPBits<double>::UIntType raw_num = 0;
// Copy as many bytes of data as will fit into num, prec, and with. Any extras
// are ignored.
@@ -98,7 +98,7 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
}
}
num = __llvm_libc::fputil::FPBits<double>(raw_num).get_val();
num = LIBC_NAMESPACE::fputil::FPBits<double>(raw_num).get_val();
if (width > MAX_SIZE) {
width = MAX_SIZE;

2
libc/fuzzing/stdio/printf_parser_fuzz.cpp
View File

@@ -16,7 +16,7 @@
#include <stdarg.h>
#include <stdint.h>
using namespace __llvm_libc;
using namespace LIBC_NAMESPACE;
// The design for the printf parser fuzzer is fairly simple. The parser uses a
// mock arg list that will never fail, and is passed a randomized string. The

3
libc/fuzzing/stdlib/atof_differential_fuzz.cpp
View File

@@ -26,7 +26,8 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
container[i] = data[i];
container[size] = '\0'; // Add null terminator to container.
StringParserOutputDiff<double>(&__llvm_libc::atof, &::atof, container, size);
StringParserOutputDiff<double>(&LIBC_NAMESPACE::atof, &::atof, container,
size);
delete[] container;
return 0;
}

2
libc/fuzzing/stdlib/qsort_fuzz.cpp
View File

@@ -34,7 +34,7 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
for (size_t i = 0; i < array_size; ++i)
array[i] = data_as_int[i];
__llvm_libc::qsort(array, array_size, sizeof(int), int_compare);
LIBC_NAMESPACE::qsort(array, array_size, sizeof(int), int_compare);
for (size_t i = 0; i < array_size - 1; ++i) {
if (array[i] > array[i + 1])

10
libc/fuzzing/stdlib/strtofloat_fuzz.cpp
View File

@@ -22,7 +22,7 @@
#include "utils/MPFRWrapper/mpfr_inc.h"
using __llvm_libc::fputil::FloatProperties;
using LIBC_NAMESPACE::fputil::FloatProperties;
// This function calculates the effective precision for a given float type and
// exponent. Subnormals have a lower effective precision since they don't
@@ -113,7 +113,7 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
mpfr_init2(mpfr_float, float_precision);
mpfr_strtofr(mpfr_float, str_ptr, &out_ptr, base, MPFR_RNDN);
float volatile float_result = mpfr_get_flt(mpfr_float, MPFR_RNDN);
auto volatile strtof_result = __llvm_libc::strtof(str_ptr, &out_ptr);
auto volatile strtof_result = LIBC_NAMESPACE::strtof(str_ptr, &out_ptr);
ptrdiff_t strtof_strlen = out_ptr - str_ptr;
if (result_strlen != strtof_strlen)
__builtin_trap();
@@ -132,8 +132,8 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
mpfr_init2(mpfr_double, double_precision);
mpfr_strtofr(mpfr_double, str_ptr, &out_ptr, base, MPFR_RNDN);
double volatile double_result = mpfr_get_d(mpfr_double, MPFR_RNDN);
auto volatile strtod_result = __llvm_libc::strtod(str_ptr, &out_ptr);
auto volatile atof_result = __llvm_libc::atof(str_ptr);
auto volatile strtod_result = LIBC_NAMESPACE::strtod(str_ptr, &out_ptr);
auto volatile atof_result = LIBC_NAMESPACE::atof(str_ptr);
ptrdiff_t strtod_strlen = out_ptr - str_ptr;
if (result_strlen != strtod_strlen)
__builtin_trap();
@@ -153,7 +153,7 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
mpfr_strtofr(mpfr_long_double, str_ptr, &out_ptr, base, MPFR_RNDN);
long double volatile long_double_result =
mpfr_get_ld(mpfr_long_double, MPFR_RNDN);
auto volatile strtold_result = __llvm_libc::strtold(str_ptr, &out_ptr);
auto volatile strtold_result = LIBC_NAMESPACE::strtold(str_ptr, &out_ptr);
ptrdiff_t strtold_strlen = out_ptr - str_ptr;
if (result_strlen != strtold_strlen)
__builtin_trap();

14
libc/fuzzing/stdlib/strtointeger_differential_fuzz.cpp
View File

@@ -61,19 +61,19 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
// random even when the input is cleaned.
container[0] = data[0];
StringParserOutputDiff<int>(&__llvm_libc::atoi, &::atoi, container, size);
StringParserOutputDiff<long>(&__llvm_libc::atol, &::atol, container, size);
StringParserOutputDiff<long long>(&__llvm_libc::atoll, &::atoll, container,
StringParserOutputDiff<int>(&LIBC_NAMESPACE::atoi, &::atoi, container, size);
StringParserOutputDiff<long>(&LIBC_NAMESPACE::atol, &::atol, container, size);
StringParserOutputDiff<long long>(&LIBC_NAMESPACE::atoll, &::atoll, container,
size);
StringToNumberOutputDiff<long>(&__llvm_libc::strtol, &::strtol, container,
StringToNumberOutputDiff<long>(&LIBC_NAMESPACE::strtol, &::strtol, container,
size);
StringToNumberOutputDiff<long long>(&__llvm_libc::strtoll, &::strtoll,
StringToNumberOutputDiff<long long>(&LIBC_NAMESPACE::strtoll, &::strtoll,
container, size);
StringToNumberOutputDiff<unsigned long>(&__llvm_libc::strtoul, &::strtoul,
StringToNumberOutputDiff<unsigned long>(&LIBC_NAMESPACE::strtoul, &::strtoul,
container, size);
StringToNumberOutputDiff<unsigned long long>(&__llvm_libc::strtoull,
StringToNumberOutputDiff<unsigned long long>(&LIBC_NAMESPACE::strtoull,
&::strtoull, container, size);
delete[] container;

16
libc/fuzzing/stdlib/strtointeger_fuzz.cpp
View File

@@ -48,20 +48,22 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
char *out_ptr = nullptr;
auto volatile atoi_output = __llvm_libc::atoi(str_ptr);
auto volatile atol_output = __llvm_libc::atol(str_ptr);
auto volatile atoll_output = __llvm_libc::atoll(str_ptr);
auto volatile strtol_output = __llvm_libc::strtol(str_ptr, &out_ptr, base);
auto volatile atoi_output = LIBC_NAMESPACE::atoi(str_ptr);
auto volatile atol_output = LIBC_NAMESPACE::atol(str_ptr);
auto volatile atoll_output = LIBC_NAMESPACE::atoll(str_ptr);
auto volatile strtol_output = LIBC_NAMESPACE::strtol(str_ptr, &out_ptr, base);
if (str_ptr + container_size - 1 < out_ptr)
__builtin_trap();
auto volatile strtoll_output = __llvm_libc::strtoll(str_ptr, &out_ptr, base);
auto volatile strtoll_output =
LIBC_NAMESPACE::strtoll(str_ptr, &out_ptr, base);
if (str_ptr + container_size - 1 < out_ptr)
__builtin_trap();
auto volatile strtoul_output = __llvm_libc::strtoul(str_ptr, &out_ptr, base);
auto volatile strtoul_output =
LIBC_NAMESPACE::strtoul(str_ptr, &out_ptr, base);
if (str_ptr + container_size - 1 < out_ptr)
__builtin_trap();
auto volatile strtoull_output =
__llvm_libc::strtoull(str_ptr, &out_ptr, base);
LIBC_NAMESPACE::strtoull(str_ptr, &out_ptr, base);
if (str_ptr + container_size - 1 < out_ptr)
__builtin_trap();

4
libc/fuzzing/string/strcmp_fuzz.cpp
View File

@@ -64,12 +64,12 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
// The expected result should be the difference between the first non-equal
// characters of s1 and s2. If all characters are equal, the expected result
// should be '\0' - '\0' = 0.
if (__llvm_libc::strcmp(s1, s2) != ch1 - ch2)
if (LIBC_NAMESPACE::strcmp(s1, s2) != ch1 - ch2)
__builtin_trap();
// Verify reversed operands. This should be the negated value of the previous
// result, except of course if the previous result was zero.
if (__llvm_libc::strcmp(s2, s1) != ch2 - ch1)
if (LIBC_NAMESPACE::strcmp(s2, s1) != ch2 - ch1)
__builtin_trap();
delete[] data1;

2
libc/fuzzing/string/strcpy_fuzz.cpp
View File

@@ -21,7 +21,7 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
char *dest = new char[size];
if (!dest) __builtin_trap();
__llvm_libc::strcpy(dest, src);
LIBC_NAMESPACE::strcpy(dest, src);
size_t i;
for (i = 0; src[i] != '\0'; i++) {

6
libc/fuzzing/string/strstr_fuzz.cpp
View File

@@ -54,11 +54,11 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
const char *needle = reinterpret_cast<const char *>(container);
const char *haystack = reinterpret_cast<const char *>(data + i);
const char *result = __llvm_libc::strstr(haystack, needle);
const char *result = LIBC_NAMESPACE::strstr(haystack, needle);
// A null terminator may exist earlier in each, so this needs to be recorded.
const size_t haystack_size = __llvm_libc::strlen(haystack);
const size_t needle_size = __llvm_libc::strlen(needle);
const size_t haystack_size = LIBC_NAMESPACE::strlen(haystack);
const size_t needle_size = LIBC_NAMESPACE::strlen(needle);
if (result) {
// The needle is in the haystack.