WIP: preserve original implementation in case when libm can't provide cexp functions

Author: nurmukhametov

libcxx/CMakeLists.txt

@@ -749,6 +749,7 @@ config_define(${LIBCXX_ENABLE_UNICODE} _LIBCPP_HAS_UNICODE)
 config_define(${LIBCXX_ENABLE_WIDE_CHARACTERS} _LIBCPP_HAS_WIDE_CHARACTERS)
 config_define(${LIBCXX_ENABLE_TIME_ZONE_DATABASE} _LIBCPP_HAS_TIME_ZONE_DATABASE)
 config_define(${LIBCXX_ENABLE_VENDOR_AVAILABILITY_ANNOTATIONS} _LIBCPP_HAS_VENDOR_AVAILABILITY_ANNOTATIONS)
+config_define_if(C_SUPPORTS_C99_COMPLEX _LIBCPP_HAS_C99_COMPLEX)
 
 # TODO: Remove in LLVM 21. We're leaving an error to make this fail explicitly.
 if (LIBCXX_ENABLE_ASSERTIONS)

libcxx/cmake/config-ix.cmake

@@ -103,6 +103,31 @@ endif()
 
 check_symbol_exists(__PICOLIBC__ "string.h" PICOLIBC)
 
+# Check for the existence of <complex.h> complex math functions.
+# This is necessary even though libcxx uses the builtin versions
+# of these functions, because if the builtin cannot be used, a reference
+# to the library function is emitted. Using compiler builtins for these
+# functions requires corresponding C99 library functions to be present.
+
+cmake_push_check_state()
+list(APPEND CMAKE_REQUIRED_LIBRARIES m)
+check_c_source_compiles("
+#include <complex.h>
+typedef __complex__ float float_type;
+typedef __complex__ double double_type;
+typedef __complex__ long double ld_type;
+volatile float_type tmpf;
+volatile double_type tmpd;
+volatile ld_type tmpld;
+int main(void) {
+  tmpf = cexpf(tmpf);
+  tmpd = cexp(tmpd);
+  tmpld = cexpl(tmpld);
+  return 0;
+}
+" C_SUPPORTS_C99_COMPLEX)
+cmake_pop_check_state()
+
 # Check libraries
 if(WIN32 AND NOT MINGW)
   # TODO(compnerd) do we want to support an emulation layer that allows for the

libcxx/include/__config_site.in

@@ -32,6 +32,7 @@
 #cmakedefine01 _LIBCPP_HAS_WIDE_CHARACTERS
 #cmakedefine01 _LIBCPP_HAS_TIME_ZONE_DATABASE
 #cmakedefine01 _LIBCPP_INSTRUMENTED_WITH_ASAN
+#cmakedefine01 _LIBCPP_HAS_C99_COMPLEX
 
 // PSTL backends
 #cmakedefine _LIBCPP_PSTL_BACKEND_SERIAL

libcxx/include/complex

@@ -1074,6 +1074,7 @@ _LIBCPP_HIDE_FROM_ABI complex<_Tp> sqrt(const complex<_Tp>& __x) {
 
 // exp
 
+#if _LIBCPP_HAS_C99_COMPLEX
 _LIBCPP_HIDE_FROM_ABI inline _Complex float __cexp(_Complex float __v) { return __builtin_cexpf(__v); }
 _LIBCPP_HIDE_FROM_ABI inline _Complex double __cexp(_Complex double __v) { return __builtin_cexp(__v); }
 _LIBCPP_HIDE_FROM_ABI inline _Complex long double __cexp(_Complex long double __v) { return __builtin_cexpl(__v); }
@@ -1082,6 +1083,31 @@ template <class _Tp>
 _LIBCPP_HIDE_FROM_ABI complex<_Tp> exp(const complex<_Tp>& __x) {
   return complex<_Tp>(__from_builtin_tag(), std::__cexp(__x.__builtin()));
 }
+#else
+template <class _Tp>
+_LIBCPP_HIDE_FROM_ABI complex<_Tp> exp(const complex<_Tp>& __x) {
+  _Tp __i = __x.imag();
+  if (__i == 0) {
+    return complex<_Tp>(std::exp(__x.real()), std::copysign(_Tp(0), __x.imag()));
+  }
+  if (std::isinf(__x.real())) {
+    if (__x.real() < _Tp(0)) {
+      if (!std::isfinite(__i))
+        __i = _Tp(1);
+    } else if (__i == 0 || !std::isfinite(__i)) {
+      if (std::isinf(__i))
+        __i = _Tp(NAN);
+      return complex<_Tp>(__x.real(), __i);
+    }
+  }
+  if (std::isinf(__e)) {
+    _Tp __e2 = std::exp(__x.real() * _Tp(0.5));
+    return complex<_Tp>(__e2 * std::cos(__i) * __e2, __e2 * std::sin(__i) * __e2);
+  }
+  _Tp __e = std::exp(__x.real());
+  return complex<_Tp>(__e * std::cos(__i), __e * std::sin(__i));
+}
+#endif
 
 // pow