[flang] Implement atand intrinsic

[DavidTruby]

Summary

This implements the atand intrinsic by performing a multiplication
by 180/pi to the result of a call to atan inline.

This is a commonly provided extension that is used by OpenRadioss.

[DavidTruby]

flang/lib/Optimizer/Builder/IntrinsicCall.cpp

47

I don't know why my editor keeps inserting these spurious header files.... I'll remove it before uploading the next patch revision

[tblah]

flang/test/Lower/Intrinsics/atand.f90

17

nit: please could you test that fastmath<contract> is added to this floating point arithmetic on the fast build

[vzakhari]

flang/lib/Optimizer/Builder/IntrinsicCall.cpp

43

Please try the shared-libs build before merging. Something like LLVM Support dependency might be need in the CMakeLists.txt

2326

Please add a TODO for complex types.

flang/test/Lower/Intrinsics/atand.f90

16

Could you use llvm::APFloat::divide to constant fold this right away (https://llvm.org/doxygen/classllvm_1_1APFloat.html#a107d394b970c9f03a486a15cdd08f0df)?

[DavidTruby]

Fold constant divide at compile time before MLIR

flang/test/Lower/Intrinsics/atand.f90

17

it seems to be added to the mulf in either case. Is this correct or should I have done something to avoid that?

[tblah]

flang/test/Lower/Intrinsics/atand.f90

17

I'm not entirely sure what the intended semantics of the bbc option are.

I don't suspect your changes would lead to adding fastmath attributes which should not have been there, I was worried that none would be added at all. This seems not to be the case so +1 from me.

[DavidTruby]

ping

[vzakhari]

LGTM

flang/lib/Optimizer/Builder/IntrinsicCall.cpp

 #include "flang/Optimizer/Dialect/FIROpsSupport.h"
 #include "flang/Optimizer/Support/FIRContext.h"
 #include "flang/Optimizer/Support/FatalError.h"
 #include "flang/Optimizer/Support/Utils.h"
 #include "flang/Runtime/entry-names.h"
 #include "mlir/Dialect/Complex/IR/Complex.h"
 #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
 #include "mlir/Dialect/Math/IR/Math.h"
+#include "llvm/ADT/APFloat.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"
+#include "llvm/Support/MathExtras.h"
+#include <mlir/IR/BuiltinTypes.h>
 #include <optional>
 
 #define DEBUG_TYPE "flang-lower-intrinsic"
 
 /// This file implements lowering of Fortran intrinsic procedures and Fortran
 /// intrinsic module procedures.  A call may be inlined with a mix of FIR and
 /// MLIR operations, or as a call to a runtime function or LLVM intrinsic.
 
fir::ExtendedValue genAdjustRtCall(mlir::Type,
                                      llvm::ArrayRef<fir::ExtendedValue>);
   mlir::Value genAimag(mlir::Type, llvm::ArrayRef<mlir::Value>);
   mlir::Value genAint(mlir::Type, llvm::ArrayRef<mlir::Value>);
   fir::ExtendedValue genAll(mlir::Type, llvm::ArrayRef<fir::ExtendedValue>);
   fir::ExtendedValue genAllocated(mlir::Type,
                                   llvm::ArrayRef<fir::ExtendedValue>);
   mlir::Value genAnint(mlir::Type, llvm::ArrayRef<mlir::Value>);
   fir::ExtendedValue genAny(mlir::Type, llvm::ArrayRef<fir::ExtendedValue>);
+  mlir::Value genAtand(mlir::Type, llvm::ArrayRef<mlir::Value>);
   fir::ExtendedValue
       genCommandArgumentCount(mlir::Type, llvm::ArrayRef<fir::ExtendedValue>);
   fir::ExtendedValue genAssociated(mlir::Type,
                                    llvm::ArrayRef<fir::ExtendedValue>);
   fir::ExtendedValue genBesselJn(mlir::Type,
                                  llvm::ArrayRef<fir::ExtendedValue>);
   fir::ExtendedValue genBesselYn(mlir::Type,
                                  llvm::ArrayRef<fir::ExtendedValue>);
static constexpr IntrinsicHandler handlers[]{
     {"any",
      &I::genAny,
      {{{"mask", asAddr}, {"dim", asValue}}},
      /*isElemental=*/false},
     {"associated",
      &I::genAssociated,
      {{{"pointer", asInquired}, {"target", asInquired}}},
      /*isElemental=*/false},
+    {"atand", &I::genAtand},
     {"bessel_jn",
      &I::genBesselJn,
      {{{"n1", asValue}, {"n2", asValue}, {"x", asValue}}},
      /*isElemental=*/false},
     {"bessel_yn",
      &I::genBesselYn,
      {{{"n1", asValue}, {"n2", asValue}, {"x", asValue}}},
      /*isElemental=*/false},
fir::MutableBoxValue resultMutableBox =
       fir::factory::createTempMutableBox(builder, loc, resultArrayType);
   mlir::Value resultIrBox =
       fir::factory::getMutableIRBox(builder, loc, resultMutableBox);
   // Call runtime. The runtime is allocating the result.
   fir::runtime::genAnyDescriptor(builder, loc, resultIrBox, mask, dim);
   return readAndAddCleanUp(resultMutableBox, resultType, "ANY");
 }
 
+mlir::Value IntrinsicLibrary::genAtand(mlir::Type resultType,
+                                       llvm::ArrayRef<mlir::Value> args) {
+  assert(args.size() == 1);
+  mlir::MLIRContext *context = builder.getContext();
+  mlir::FunctionType ftype =
+      mlir::FunctionType::get(context, {resultType}, {args[0].getType()});
+  mlir::Value atan = getRuntimeCallGenerator("atan", ftype)(builder, loc, args);
+  llvm::APFloat lpi = llvm::APFloat(llvm::numbers::pi);
+  mlir::Value dpi =
+      builder.createRealConstant(loc, mlir::FloatType::getF64(context), lpi);
+  mlir::Value pi = builder.createConvert(loc, resultType, dpi);
+  mlir::Value factor = builder.create<mlir::arith::DivFOp>(
+      loc, builder.createRealConstant(loc, resultType, 180), pi);
+  return builder.create<mlir::arith::MulFOp>(loc, atan, factor);
+}
+
 // ASSOCIATED
 fir::ExtendedValue
 IntrinsicLibrary::genAssociated(mlir::Type resultType,
                                 llvm::ArrayRef<fir::ExtendedValue> args) {
   assert(args.size() == 2);
   auto *pointer =
       args[0].match([&](const fir::MutableBoxValue &x) { return &x; },
                     [&](const auto &) -> const fir::MutableBoxValue * {

flang/test/Lower/Intrinsics/atand.f90

+! RUN: bbc -emit-fir %s -o - | FileCheck %s --check-prefixes="CHECK,CHECK-FAST"
+! RUN: bbc --math-runtime=precise -emit-fir %s -o - | FileCheck %s --check-prefixes="CHECK,CHECK-PRECISE"
+! RUN: %flang_fc1 -emit-fir %s -o - | FileCheck %s --check-prefixes="CHECK,CHECK-FAST"
+
+function test_real4(x)
+  real :: x, test_real4
+  test_real4 = atand(x)
+end function
+
+! CHECK-LABEL: @_QPtest_real4
+! CHECK-PRECISE: %[[atan:.*]] = fir.call @atanf({{%[A-Za-z0-9._]+}}) {{.*}}: (f32) -> f32
+! CHECK-FAST: %[[atan:.*]] = math.atan %{{.*}} {{.*}} : f32
+! CHECK: %[[dpi:.*]] = arith.constant 3.1415926535897931 : f64
+! CHECK: %[[pi:.*]] = fir.convert %[[dpi]] : (f64) -> f32
+! CHECK: %[[deg:.*]] = arith.constant 1.800000e+02 : f32
+! CHECK: %[[factor:.*]] = arith.divf %[[deg]], %[[pi]] {{.*}} : f32
+! CHECK: %{{.*}} = arith.mulf %[[atan]], %[[factor]] {{.*}} : f32
+
+function test_real8(x)
+  real(8) :: x, test_real8
+  test_real8 = atand(x)
+end function
+
+! CHECK-LABEL: @_QPtest_real8
+! CHECK-PRECISE: %[[atan:.*]] = fir.call @atan({{%[A-Za-z0-9._]+}}) {{.*}}: (f64) -> f64
+! CHECK-FAST: %[[atan:.*]] = math.atan %{{.*}} {{.*}} : f64
+! CHECK: %[[pi:.*]] = arith.constant 3.1415926535897931 : f64
+! CHECK: %[[deg:.*]] = arith.constant 1.800000e+02 : f64
+! CHECK: %[[factor:.*]] = arith.divf %[[deg]], %[[pi]] {{.*}} : f64
+! CHECK: %{{.*}} = arith.mulf %[[atan]], %[[factor]] {{.*}} : f64