Add SWIFT_STDLIB_HAS_LOCALE CMake to build stdlib without locale.h and locale based float parsing (#40405)

Author: kubamracek

cmake/modules/StandaloneOverlay.cmake

@@ -92,6 +92,10 @@ set(SWIFT_DARWIN_MODULE_ARCHS "" CACHE STRING
 targets on Darwin platforms. These targets are in addition to the full \
 library targets.")
 
+option(SWIFT_STDLIB_HAS_LOCALE
+       "Build stdlib assuming the platform has locale support."
+       TRUE)
+
 # -----------------------------------------------------------------------------
 # Constants
 

stdlib/CMakeLists.txt

@@ -62,6 +62,14 @@ else()
   set(SWIFT_STDLIB_SUPPORTS_BACKTRACE_REPORTING_default TRUE)
 endif()
 
+if("${SWIFT_HOST_VARIANT_SDK}" MATCHES "CYGWIN")
+  set(SWIFT_STDLIB_HAS_LOCALE_default FALSE)
+elseif("${SWIFT_HOST_VARIANT_SDK}" MATCHES "HAIKU")
+  set(SWIFT_STDLIB_HAS_LOCALE_default FALSE)
+else()
+  set(SWIFT_STDLIB_HAS_LOCALE_default TRUE)
+endif()
+
 if("${SWIFT_HOST_VARIANT_SDK}" IN_LIST SWIFT_DARWIN_PLATFORMS)
   set(SWIFT_STDLIB_HAS_ASL_default TRUE)
 else()
@@ -122,6 +130,10 @@ option(SWIFT_STDLIB_HAS_ENVIRON
        "Build stdlib assuming the platform supports environment variables."
        TRUE)
 
+option(SWIFT_STDLIB_HAS_LOCALE
+       "Build stdlib assuming the platform has locale support."
+       "${SWIFT_STDLIB_HAS_LOCALE_default}")
+
 option(SWIFT_STDLIB_SINGLE_THREADED_RUNTIME
        "Build the standard libraries assuming that they will be used in an environment with only a single thread."
        FALSE)

stdlib/cmake/modules/AddSwiftStdlib.cmake

@@ -344,6 +344,10 @@ function(_add_target_variant_c_compile_flags)
     list(APPEND result "-DSWIFT_STDLIB_HAS_ENVIRON")
   endif()
 
+  if(SWIFT_STDLIB_HAS_LOCALE)
+    list(APPEND result "-DSWIFT_STDLIB_HAS_LOCALE")
+  endif()
+
   if(SWIFT_STDLIB_SINGLE_THREADED_RUNTIME)
     list(APPEND result "-DSWIFT_STDLIB_SINGLE_THREADED_RUNTIME")
   endif()

stdlib/public/stubs/Stubs.cpp

@@ -25,16 +25,18 @@
 // Avoid defining macro max(), min() which conflict with std::max(), std::min()
 #define NOMINMAX
 #include <windows.h>
-#else
-#if !defined(__HAIKU__) && !defined(__wasi__)
+#else // defined(_WIN32)
+#if __has_include(<sys/errno.h>)
 #include <sys/errno.h>
 #else
 #include <errno.h>
 #endif
+#if __has_include(<sys/resource.h>)
 #include <sys/resource.h>
 #endif
+#endif // else defined(_WIN32)
+
 #include <climits>
-#include <clocale>
 #include <cmath>
 #include <cstdarg>
 #include <cstdint>
@@ -44,14 +46,17 @@
 #if defined(__CYGWIN__) || defined(__HAIKU__)
 #include <sstream>
 #endif
-#if defined(__OpenBSD__) || defined(__ANDROID__) || defined(__linux__) || defined(__wasi__) || defined(_WIN32)
-#include <locale.h>
+
+#if SWIFT_STDLIB_HAS_LOCALE
+#include <clocale>
+#if __has_include(<xlocale.h>)
+#include <xlocale.h>
+#endif
 #if defined(_WIN32)
 #define locale_t _locale_t
 #endif
-#else
-#include <xlocale.h>
-#endif
+#endif // SWIFT_STDLIB_HAS_LOCALE
+
 #include <limits>
 #include <thread>
 
@@ -138,14 +143,13 @@ uint64_t swift_uint64ToString(char *Buffer, intptr_t BufferLength,
                             /*Negative=*/false);
 }
 
+#if SWIFT_STDLIB_HAS_LOCALE
 #if defined(__APPLE__) || defined(__FreeBSD__) || defined(__ANDROID__)
 static inline locale_t getCLocale() {
   // On these platforms convenience functions from xlocale.h interpret nullptr
   // as C locale.
   return nullptr;
 }
-#elif defined(__CYGWIN__) || defined(__HAIKU__)
-// In Cygwin, getCLocale() is not used.
 #elif defined(_WIN32)
 static _locale_t makeCLocale() {
   _locale_t CLocale = _create_locale(LC_ALL, "C");
@@ -171,6 +175,7 @@ static locale_t getCLocale() {
   return SWIFT_LAZY_CONSTANT(makeCLocale());
 }
 #endif
+#endif // SWIFT_STDLIB_HAS_LOCALE
 
 // TODO: replace this with a float16 implementation instead of calling _float.
 // Argument type will have to stay float, though; only the formatting changes.
@@ -312,6 +317,8 @@ T _swift_strto(const char *nptr, char **endptr) {
 }
 #endif
 
+#if SWIFT_STDLIB_HAS_LOCALE
+
 #if defined(__OpenBSD__) || defined(_WIN32) || defined(__CYGWIN__) || defined(__HAIKU__)
 #define NEED_SWIFT_STRTOD_L
 #define strtod_l swift_strtod_l
@@ -333,6 +340,8 @@ T _swift_strto(const char *nptr, char **endptr) {
 #endif
 #endif
 
+#endif // SWIFT_STDLIB_HAS_LOCALE
+
 #if defined(NEED_SWIFT_STRTOD_L)
 static double swift_strtod_l(const char *nptr, char **endptr, locale_t loc) {
 #if defined(_WIN32)
@@ -387,44 +396,63 @@ static inline void _swift_set_errno(int to) {
 // We can't return Float80, but we can receive a pointer to one, so
 // switch the return type and the out parameter on strtold.
 template <typename T>
+#if SWIFT_STDLIB_HAS_LOCALE
 static const char *_swift_stdlib_strtoX_clocale_impl(
-    const char * nptr, T* outResult, T huge,
-    T (*posixImpl)(const char *, char **, locale_t)
-) {
+    const char *nptr, T *outResult, T huge,
+    T (*posixImpl)(const char *, char **, locale_t))
+#else
+static const char *_swift_stdlib_strtoX_impl(
+    const char *nptr, T *outResult,
+    T (*posixImpl)(const char *, char **))
+#endif
+{
   if (swift_stringIsSignalingNaN(nptr)) {
     // TODO: ensure that the returned sNaN bit pattern matches that of sNaNs
     // produced by Swift.
     *outResult = std::numeric_limits<T>::signaling_NaN();
     return nptr + std::strlen(nptr);
   }
-  
+
   char *EndPtr;
   _swift_set_errno(0);
+#if SWIFT_STDLIB_HAS_LOCALE
   const auto result = posixImpl(nptr, &EndPtr, getCLocale());
+#else
+  const auto result = posixImpl(nptr, &EndPtr);
+#endif
   *outResult = result;
   return EndPtr;
 }
-    
-const char *_swift_stdlib_strtold_clocale(
-  const char * nptr, void *outResult) {
+
+const char *_swift_stdlib_strtold_clocale(const char *nptr, void *outResult) {
+#if SWIFT_STDLIB_HAS_LOCALE
   return _swift_stdlib_strtoX_clocale_impl(
-    nptr, static_cast<long double*>(outResult), HUGE_VALL, strtold_l);
+      nptr, static_cast<long double *>(outResult), HUGE_VALL, strtold_l);
+#else
+  return _swift_stdlib_strtoX_impl(
+      nptr, static_cast<long double *>(outResult), strtold);
+#endif
 }
 
-const char *_swift_stdlib_strtod_clocale(
-    const char * nptr, double *outResult) {
-  return _swift_stdlib_strtoX_clocale_impl(
-    nptr, outResult, HUGE_VAL, strtod_l);
+const char *_swift_stdlib_strtod_clocale(const char *nptr, double *outResult) {
+#if SWIFT_STDLIB_HAS_LOCALE
+  return _swift_stdlib_strtoX_clocale_impl(nptr, outResult, HUGE_VAL, strtod_l);
+#else
+  return _swift_stdlib_strtoX_impl(nptr, outResult, strtod);
+#endif
 }
 
-const char *_swift_stdlib_strtof_clocale(
-    const char * nptr, float *outResult) {
-  return _swift_stdlib_strtoX_clocale_impl(
-    nptr, outResult, HUGE_VALF, strtof_l);
+const char *_swift_stdlib_strtof_clocale(const char *nptr, float *outResult) {
+#if SWIFT_STDLIB_HAS_LOCALE
+  return _swift_stdlib_strtoX_clocale_impl(nptr, outResult, HUGE_VALF,
+                                           strtof_l);
+#else
+  return _swift_stdlib_strtoX_impl(nptr, outResult, strtof);
+#endif
 }
 
-const char *_swift_stdlib_strtof16_clocale(
-    const char * nptr, __fp16 *outResult) {
+const char *_swift_stdlib_strtof16_clocale(const char *nptr,
+                                           __fp16 *outResult) {
   float tmp;
   const char *result = _swift_stdlib_strtof_clocale(nptr, &tmp);
   *outResult = tmp;

test/stdlib/PrintFloat.swift.gyb

@@ -3,7 +3,6 @@
 // RUN: %line-directive %t/FloatingPointPrinting.swift -- %target-build-swift %t/FloatingPointPrinting.swift -o %t/main.out
 // RUN: %target-codesign %t/main.out
 // RUN: %line-directive %t/FloatingPointPrinting.swift -- %target-run %t/main.out
-// RUN: %line-directive %t/FloatingPointPrinting.swift -- %target-run %t/main.out --locale ru_RU.UTF-8
 // REQUIRES: executable_test
 
 // rdar://77087867

test/stdlib/PrintFloatLocale.swift.gyb

@@ -0,0 +1,11 @@
+// RUN: %empty-directory(%t)
+// RUN: %gyb %S/PrintFloat.swift.gyb -o %t/FloatingPointPrinting.swift
+// RUN: %line-directive %t/FloatingPointPrinting.swift -- %target-build-swift %t/FloatingPointPrinting.swift -o %t/main.out
+// RUN: %target-codesign %t/main.out
+// RUN: %line-directive %t/FloatingPointPrinting.swift -- %target-run %t/main.out --locale ru_RU.UTF-8
+// REQUIRES: executable_test
+
+// rdar://77087867
+// UNSUPPORTED: CPU=arm64_32 && OS=watchos
+
+// UNSUPPORTED: freestanding

utils/build-presets.ini

@@ -2530,6 +2530,7 @@ swift-stdlib-has-darwin-libmalloc=0
 swift-stdlib-has-asl=0
 swift-stdlib-has-stdin=0
 swift-stdlib-has-environ=0
+swift-stdlib-has-locale=0
 swift-runtime-static-image-inspection=1
 swift-stdlib-single-threaded-runtime=1
 swift-stdlib-os-versioning=0

utils/build-script-impl

@@ -218,6 +218,7 @@ KNOWN_SETTINGS=(
     swift-stdlib-has-asl                          ""                "whether the stdlib can use the asl_log API, defaults to true on Darwin, false otherwise"
     swift-stdlib-has-stdin                        "1"               "whether to build stdlib assuming the platform supports stdin and getline API"
     swift-stdlib-has-environ                      "1"               "whether to build stdlib assuming the platform supports environment variables"
+    swift-stdlib-has-locale                       ""                "whether to build stdlib assuming the platform has locale support"
     swift-stdlib-lto                              ""                "enable LLVM LTO on the stdlib, valid values are empty string (no LTO), 'full' and 'thin'"
     swift-stdlib-enable-prespecialization         ""                "whether stdlib should be built with generic metadata prespecialization enabled, defaults to true on Darwin and Linux, false otherwise"
     swift-stdlib-passthrough-metadata-allocator   "0"               "whether stdlib should be built without a custom implementation of MetadataAllocator, relying on malloc+free instead"
@@ -2147,6 +2148,13 @@ for host in "${ALL_HOSTS[@]}"; do
                     )
                 fi
 
+                if [[ "${SWIFT_STDLIB_HAS_LOCALE}" ]] ; then
+                    cmake_options=(
+                        "${cmake_options[@]}"
+                        -DSWIFT_STDLIB_HAS_LOCALE:BOOL=$(true_false "${SWIFT_STDLIB_HAS_LOCALE}")
+                    )
+                fi
+
                 if [ "${SWIFT_INSTALL_COMPONENTS}" ] ; then
                     cmake_options=(
                         "${cmake_options[@]}"

utils/check_freestanding_dependencies.py

@@ -47,8 +47,8 @@
     "_fputc", "_fputs", "_free", "_funlockfile", "_fwrite", "_malloc",
     "_malloc_size", "_memchr", "_memcmp", "_memcpy", "_memmove", "_memset",
     "_posix_memalign", "_putc", "_read", "_realloc", "_snprintf", "_strchr",
-    "_strcmp", "_strdup", "_strlen", "_strncmp", "_strtod_l", "_strtof_l",
-    "_strtol", "_strtold_l", "_vsnprintf", "_write",
+    "_strcmp", "_strdup", "_strlen", "_strncmp", "_strtod", "_strtof",
+    "_strtol", "_strtold", "_vsnprintf", "_write",
 ] + cxx_dependencies + math_dependencies
 vendor_apple_specific_dependencies = [
     "___stack_chk_fail", "___stack_chk_guard",