[flang-commits] [flang] [flang][AIX] Handle more trig functions with complex argument to have consistent results in folding (PR #124203)

[via flang-commits]

github-actions[bot] wrote:

<!--LLVM CODE FORMAT COMMENT: {clang-format}-->


:warning: C/C++ code formatter, clang-format found issues in your code. :warning:

<details>
<summary>
You can test this locally with the following command:
</summary>

``````````bash
git-clang-format --diff 4294fe173e9696a4c090857fa0766cd44c1964dc e032bfd3b62f1f1c241fc0822d1e2185b1f34d2d --extensions cpp -- flang/lib/Evaluate/intrinsics-library.cpp
``````````

</details>

<details>
<summary>
View the diff from clang-format here.
</summary>

``````````diff
diff --git a/flang/lib/Evaluate/intrinsics-library.cpp b/flang/lib/Evaluate/intrinsics-library.cpp
index 60bb2785c7..9c483771fa 100644
--- a/flang/lib/Evaluate/intrinsics-library.cpp
+++ b/flang/lib/Evaluate/intrinsics-library.cpp
@@ -336,27 +336,26 @@ template <typename T, typename TA> static std::complex<T> CToCpp(const TA &x) {
 using FTypeCmplxFlt = _Complex float (*)(_Complex float);
 using FTypeCmplxDble = _Complex double (*)(_Complex double);
 template <typename T>
-using FTypeStdCmplx = std::complex<T> (*)(const std::complex<T>&);
+using FTypeStdCmplx = std::complex<T> (*)(const std::complex<T> &);
 
 std::map<trigFunc, std::tuple<FTypeCmplxFlt, FTypeCmplxDble>> mapLibmTrigFunc{
     {Cacos, {&cacosf, &cacos}}, {Cacosh, {&cacoshf, &cacosh}},
     {Casin, {&casinf, &casin}}, {Casinh, {&casinhf, &casinh}},
     {Catan, {&catanf, &catan}}, {Catanh, {&catanhf, &catanh}},
     {Ccos, {&ccosf, &ccos}}, {Ccosh, {&ccoshf, &ccosh}},
-    {Cexp, {&cexpf, &cexp}}, {Clog, {&clogf, &__clog}},
-    {Csin, {&csinf, &csin}}, {Csinh, {&csinhf, &csinh}},
-    {Csqrt, {&csqrtf, &csqrt}}, {Ctan, {&ctanf, &ctan}},
-    {Ctanh, {&ctanhf, &ctanh}}};
+    {Cexp, {&cexpf, &cexp}}, {Clog, {&clogf, &__clog}}, {Csin, {&csinf, &csin}},
+    {Csinh, {&csinhf, &csinh}}, {Csqrt, {&csqrtf, &csqrt}},
+    {Ctan, {&ctanf, &ctan}}, {Ctanh, {&ctanhf, &ctanh}}};
 
 template <trigFunc TF, typename HostT>
 std::complex<HostT> LibmTrigFunc(const std::complex<HostT> &x) {
   if constexpr (std::is_same_v<HostT, float>) {
-    float _Complex r{
-      std::get<FTypeCmplxFlt>(mapLibmTrigFunc[TF])(CppToC<float _Complex, float>(x))};
+    float _Complex r{std::get<FTypeCmplxFlt>(mapLibmTrigFunc[TF])(
+        CppToC<float _Complex, float>(x))};
     return CToCpp<float, float _Complex>(r);
   } else if constexpr (std::is_same_v<HostT, double>) {
-    double _Complex r{
-      std::get<FTypeCmplxDble>(mapLibmTrigFunc[TF])(CppToC<double _Complex, double>(x))};
+    double _Complex r{std::get<FTypeCmplxDble>(mapLibmTrigFunc[TF])(
+        CppToC<double _Complex, double>(x))};
     return CToCpp<double, double _Complex>(r);
   }
   DIE("bad complex component type");
@@ -417,16 +416,16 @@ template <trigFunc TF> struct X {
 // Helpers to map complex std::pow whose resolution in F2{std::pow} is
 // ambiguous as of clang++ 20.
 template <typename HostT>
-static std::complex<HostT> StdPowF2(const std::complex<HostT> &x,
-                                    const std::complex<HostT> &y) {
+static std::complex<HostT> StdPowF2(
+    const std::complex<HostT> &x, const std::complex<HostT> &y) {
 #ifdef _AIX
   if constexpr (std::is_same_v<HostT, float>) {
-    float _Complex r{cpowf(CppToC<float _Complex, float>(x),
-                           CppToC<float _Complex, float>(y))};
+    float _Complex r{cpowf(
+        CppToC<float _Complex, float>(x), CppToC<float _Complex, float>(y))};
     return CToCpp<float, float _Complex>(r);
   } else if constexpr (std::is_same_v<HostT, double>) {
     double _Complex r{cpow(CppToC<double _Complex, double>(x),
-                           CppToC<double _Complex, double>(y))};
+        CppToC<double _Complex, double>(y))};
     return CToCpp<double, double _Complex>(r);
   }
 #else
@@ -435,18 +434,18 @@ static std::complex<HostT> StdPowF2(const std::complex<HostT> &x,
 }
 
 template <typename HostT>
-static std::complex<HostT> StdPowF2A(const HostT &x,
-                                     const std::complex<HostT> &y) {
+static std::complex<HostT> StdPowF2A(
+    const HostT &x, const std::complex<HostT> &y) {
 #ifdef _AIX
   constexpr HostT zero{0.0};
   std::complex<HostT> z(x, zero);
   if constexpr (std::is_same_v<HostT, float>) {
-    float _Complex r{cpowf(CppToC<float _Complex, float>(z),
-                           CppToC<float _Complex, float>(y))};
+    float _Complex r{cpowf(
+        CppToC<float _Complex, float>(z), CppToC<float _Complex, float>(y))};
     return CToCpp<float, float _Complex>(r);
   } else if constexpr (std::is_same_v<HostT, double>) {
     double _Complex r{cpow(CppToC<double _Complex, double>(z),
-                           CppToC<double _Complex, double>(y))};
+        CppToC<double _Complex, double>(y))};
     return CToCpp<double, double _Complex>(r);
   }
 #else
@@ -455,18 +454,18 @@ static std::complex<HostT> StdPowF2A(const HostT &x,
 }
 
 template <typename HostT>
-static std::complex<HostT> StdPowF2B(const std::complex<HostT> &x,
-                                     const HostT &y) {
+static std::complex<HostT> StdPowF2B(
+    const std::complex<HostT> &x, const HostT &y) {
 #ifdef _AIX
   constexpr HostT zero{0.0};
   std::complex<HostT> z(y, zero);
   if constexpr (std::is_same_v<HostT, float>) {
-    float _Complex r{cpowf(CppToC<float _Complex, float>(x),
-                           CppToC<float _Complex, float>(z))};
+    float _Complex r{cpowf(
+        CppToC<float _Complex, float>(x), CppToC<float _Complex, float>(z))};
     return CToCpp<float, float _Complex>(r);
   } else if constexpr (std::is_same_v<HostT, double>) {
     double _Complex r{cpow(CppToC<double _Complex, double>(x),
-                           CppToC<double _Complex, double>(z))};
+        CppToC<double _Complex, double>(z))};
     return CToCpp<double, double _Complex>(r);
   }
 #else

``````````

</details>


https://github.com/llvm/llvm-project/pull/124203