[libc++] Use libm implementations in exp for complex numbers

Replace the custom implementation with calls to compiler builtins, which
delegate to libm implementations. This also improves accuracy, as
demonstrated by the added test.

Author: nurmukhametov

libcxx/include/complex

@@ -1074,24 +1074,13 @@ _LIBCPP_HIDE_FROM_ABI complex<_Tp> sqrt(const complex<_Tp>& __x) {
 
 // exp
 
+_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); }
+
 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);
-    }
-  }
-  _Tp __e = std::exp(__x.real());
-  return complex<_Tp>(__e * std::cos(__i), __e * std::sin(__i));
+  return complex<_Tp>(__from_builtin_tag(), std::__cexp(__x.__builtin()));
 }
 
 // pow

libcxx/test/libcxx/numerics/complex.number/exp.pass.cpp

@@ -0,0 +1,40 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// <complex>
+
+// template<class T>
+//   complex<T>
+//   exp(const complex<T>& x);
+
+#include <complex>
+#include <cassert>
+#include <cmath>
+
+#include "test_macros.h"
+
+template <class T>
+void test_overflow_case() {
+  typedef std::complex<T> C;
+
+  // In this case, the overflow of exp(real_part) is compensated when
+  // sin(imag_part) is close to zero, resulting in a finite imaginary part.
+  C z(T(90.0238094), T(5.900613e-39));
+  C result = std::exp(z);
+
+  assert(std::isinf(result.real()));
+  assert(result.real() > 0);
+
+  assert(std::isfinite(result.imag()));
+  assert(std::abs(result.imag() - T(7.3746)) < T(1.0));
+}
+
+int main(int, char**) {
+  test_overflow_case<float>();
+  return 0;
+}