| //===-- lib/Evaluate/fold-complex.cpp -------------------------------------===// |
| // |
| // 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 |
| // |
| //===----------------------------------------------------------------------===// |
| |
| #include "fold-implementation.h" |
| #include "fold-matmul.h" |
| #include "fold-reduction.h" |
| |
| namespace Fortran::evaluate { |
| |
| template <int KIND> |
| Expr<Type<TypeCategory::Complex, KIND>> FoldIntrinsicFunction( |
| FoldingContext &context, |
| FunctionRef<Type<TypeCategory::Complex, KIND>> &&funcRef) { |
| using T = Type<TypeCategory::Complex, KIND>; |
| using Part = typename T::Part; |
| ActualArguments &args{funcRef.arguments()}; |
| auto *intrinsic{std::get_if<SpecificIntrinsic>(&funcRef.proc().u)}; |
| CHECK(intrinsic); |
| std::string name{intrinsic->name}; |
| if (name == "acos" || name == "acosh" || name == "asin" || name == "asinh" || |
| name == "atan" || name == "atanh" || name == "cos" || name == "cosh" || |
| name == "exp" || name == "log" || name == "sin" || name == "sinh" || |
| name == "sqrt" || name == "tan" || name == "tanh") { |
| if (auto callable{GetHostRuntimeWrapper<T, T>(name)}) { |
| return FoldElementalIntrinsic<T, T>( |
| context, std::move(funcRef), *callable); |
| } else if (context.languageFeatures().ShouldWarn( |
| common::UsageWarning::FoldingFailure)) { |
| context.messages().Say(common::UsageWarning::FoldingFailure, |
| "%s(complex(kind=%d)) cannot be folded on host"_warn_en_US, name, |
| KIND); |
| } |
| } else if (name == "conjg") { |
| return FoldElementalIntrinsic<T, T>( |
| context, std::move(funcRef), &Scalar<T>::CONJG); |
| } else if (name == "cmplx") { |
| if (args.size() > 0 && args[0].has_value()) { |
| if (auto *x{UnwrapExpr<Expr<SomeComplex>>(args[0])}) { |
| // CMPLX(X [, KIND]) with complex X |
| return Fold(context, ConvertToType<T>(std::move(*x))); |
| } else { |
| if (args.size() >= 2 && args[1].has_value()) { |
| // Do not fold CMPLX with an Y argument that may be absent at runtime |
| // into a complex constructor so that lowering can deal with the |
| // optional aspect (there is no optional aspect with the complex |
| // constructor). |
| if (MayBePassedAsAbsentOptional(*args[1]->UnwrapExpr())) { |
| return Expr<T>{std::move(funcRef)}; |
| } |
| } |
| // CMPLX(X [, Y [, KIND]]) with non-complex X |
| Expr<SomeType> re{std::move(*args[0].value().UnwrapExpr())}; |
| Expr<SomeType> im{args.size() >= 2 && args[1].has_value() |
| ? std::move(*args[1]->UnwrapExpr()) |
| : AsGenericExpr(Constant<Part>{Scalar<Part>{}})}; |
| return Fold(context, |
| Expr<T>{ |
| ComplexConstructor<KIND>{ToReal<KIND>(context, std::move(re)), |
| ToReal<KIND>(context, std::move(im))}}); |
| } |
| } |
| } else if (name == "dot_product") { |
| return FoldDotProduct<T>(context, std::move(funcRef)); |
| } else if (name == "matmul") { |
| return FoldMatmul(context, std::move(funcRef)); |
| } else if (name == "product") { |
| auto one{Scalar<Part>::FromInteger(value::Integer<8>{1}).value}; |
| return FoldProduct<T>(context, std::move(funcRef), Scalar<T>{one}); |
| } else if (name == "sum") { |
| return FoldSum<T>(context, std::move(funcRef)); |
| } |
| return Expr<T>{std::move(funcRef)}; |
| } |
| |
| template <int KIND> |
| Expr<Type<TypeCategory::Complex, KIND>> FoldOperation( |
| FoldingContext &context, ComplexConstructor<KIND> &&x) { |
| if (auto array{ApplyElementwise(context, x)}) { |
| return *array; |
| } |
| using Result = Type<TypeCategory::Complex, KIND>; |
| if (auto folded{OperandsAreConstants(x)}) { |
| return Expr<Result>{ |
| Constant<Result>{Scalar<Result>{folded->first, folded->second}}}; |
| } |
| return Expr<Result>{std::move(x)}; |
| } |
| |
| #ifdef _MSC_VER // disable bogus warning about missing definitions |
| #pragma warning(disable : 4661) |
| #endif |
| FOR_EACH_COMPLEX_KIND(template class ExpressionBase, ) |
| template class ExpressionBase<SomeComplex>; |
| } // namespace Fortran::evaluate |