[libc] Mass replace enclosing namespace (#67032)

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

5 files changed, 24 insertions, 21 deletions

diff --git a/libc/fuzzing/stdlib/atof_differential_fuzz.cpp b/libc/fuzzing/stdlib/atof_differential_fuzz.cpp
index b368129960d3..eeb96aef9abe 100644
--- a/libc/fuzzing/stdlib/atof_differential_fuzz.cpp
+++ b/libc/fuzzing/stdlib/atof_differential_fuzz.cpp
@@ -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;
 }
diff --git a/libc/fuzzing/stdlib/qsort_fuzz.cpp b/libc/fuzzing/stdlib/qsort_fuzz.cpp
index dbbc8e96f924..5d5053cff5c5 100644
--- a/libc/fuzzing/stdlib/qsort_fuzz.cpp
+++ b/libc/fuzzing/stdlib/qsort_fuzz.cpp
@@ -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])
diff --git a/libc/fuzzing/stdlib/strtofloat_fuzz.cpp b/libc/fuzzing/stdlib/strtofloat_fuzz.cpp
index 5ef506a08e4c..f6cc8abedf46 100644
--- a/libc/fuzzing/stdlib/strtofloat_fuzz.cpp
+++ b/libc/fuzzing/stdlib/strtofloat_fuzz.cpp
@@ -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();
diff --git a/libc/fuzzing/stdlib/strtointeger_differential_fuzz.cpp b/libc/fuzzing/stdlib/strtointeger_differential_fuzz.cpp
index 612be4271b23..097e6193ee6e 100644
--- a/libc/fuzzing/stdlib/strtointeger_differential_fuzz.cpp
+++ b/libc/fuzzing/stdlib/strtointeger_differential_fuzz.cpp
@@ -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;
diff --git a/libc/fuzzing/stdlib/strtointeger_fuzz.cpp b/libc/fuzzing/stdlib/strtointeger_fuzz.cpp
index 197bee01d3a3..3ffe5c261d09 100644
--- a/libc/fuzzing/stdlib/strtointeger_fuzz.cpp
+++ b/libc/fuzzing/stdlib/strtointeger_fuzz.cpp
@@ -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();