[flang] Lower evaluate::Extremum

[jeanPerier]

Summary

Update BinaryOp<T>::gen so that const T& is threaded and some
operation knowledge that is not encoded by the type T or the arguments
can be used. For Extremum, it is the order (Greater or Lesser) that is
required, but this will also be required for evaluate::Relational.

[clementval]

LGTM

flang/lib/Lower/ConvertExprToHLFIR.cpp

 
 //===--------------------------------------------------------------------===//
 // Binary Operation implementation
 //===--------------------------------------------------------------------===//
 
 template <typename T>
 struct BinaryOp {
   static hlfir::EntityWithAttributes gen(mlir::Location loc,
-                                         fir::FirOpBuilder &builder,
+                                         fir::FirOpBuilder &builder, const T &,
                                          hlfir::Entity lhs, hlfir::Entity rhs) {
     TODO(loc, "binary op implementation in HLFIR");
   }
 };
 
 #undef GENBIN
 #define GENBIN(GenBinEvOp, GenBinTyCat, GenBinFirOp)                           \
   template <int KIND>                                                          \
   struct BinaryOp<Fortran::evaluate::GenBinEvOp<Fortran::evaluate::Type<       \
       Fortran::common::TypeCategory::GenBinTyCat, KIND>>> {                    \
+    using Op = Fortran::evaluate::GenBinEvOp<Fortran::evaluate::Type<          \
+        Fortran::common::TypeCategory::GenBinTyCat, KIND>>;                    \
     static hlfir::EntityWithAttributes gen(mlir::Location loc,                 \
                                            fir::FirOpBuilder &builder,         \
-                                           hlfir::Entity lhs,                  \
+                                           const Op &, hlfir::Entity lhs,      \
                                            hlfir::Entity rhs) {                \
       return hlfir::EntityWithAttributes{                                      \
           builder.create<GenBinFirOp>(loc, lhs, rhs)};                         \
     }                                                                          \
   };
 
 GENBIN(Add, Integer, mlir::arith::AddIOp)
 GENBIN(Add, Real, mlir::arith::AddFOp)
 GENBIN(Add, Complex, fir::AddcOp)
 GENBIN(Subtract, Integer, mlir::arith::SubIOp)
 GENBIN(Subtract, Real, mlir::arith::SubFOp)
 GENBIN(Subtract, Complex, fir::SubcOp)
 GENBIN(Multiply, Integer, mlir::arith::MulIOp)
 GENBIN(Multiply, Real, mlir::arith::MulFOp)
 GENBIN(Multiply, Complex, fir::MulcOp)
 GENBIN(Divide, Integer, mlir::arith::DivSIOp)
 GENBIN(Divide, Real, mlir::arith::DivFOp)
 GENBIN(Divide, Complex, fir::DivcOp)
 
 template <Fortran::common::TypeCategory TC, int KIND>
 struct BinaryOp<Fortran::evaluate::Power<Fortran::evaluate::Type<TC, KIND>>> {
+  using Op = Fortran::evaluate::Power<Fortran::evaluate::Type<TC, KIND>>;
   static hlfir::EntityWithAttributes gen(mlir::Location loc,
                                          fir::FirOpBuilder &builder,
-                                         hlfir::Entity lhs, hlfir::Entity rhs) {
+                                         const Op &op, hlfir::Entity lhs,
+                                         hlfir::Entity rhs) {
     mlir::Type ty = Fortran::lower::getFIRType(builder.getContext(), TC, KIND,
                                                /*params=*/llvm::None);
     return hlfir::EntityWithAttributes{
         Fortran::lower::genPow(builder, loc, ty, lhs, rhs)};
   }
 };
 
 template <Fortran::common::TypeCategory TC, int KIND>
 struct BinaryOp<
     Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<TC, KIND>>> {
+  using Op =
+      Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<TC, KIND>>;
   static hlfir::EntityWithAttributes gen(mlir::Location loc,
                                          fir::FirOpBuilder &builder,
-                                         hlfir::Entity lhs, hlfir::Entity rhs) {
+                                         const Op &op, hlfir::Entity lhs,
+                                         hlfir::Entity rhs) {
     mlir::Type ty = Fortran::lower::getFIRType(builder.getContext(), TC, KIND,
                                                /*params=*/llvm::None);
     return hlfir::EntityWithAttributes{
         Fortran::lower::genPow(builder, loc, ty, lhs, rhs)};
   }
 };
 
+template <Fortran::common::TypeCategory TC, int KIND>
+struct BinaryOp<
+    Fortran::evaluate::Extremum<Fortran::evaluate::Type<TC, KIND>>> {
+  using Op = Fortran::evaluate::Extremum<Fortran::evaluate::Type<TC, KIND>>;
+  static hlfir::EntityWithAttributes gen(mlir::Location loc,
+                                         fir::FirOpBuilder &builder,
+                                         const Op &op, hlfir::Entity lhs,
+                                         hlfir::Entity rhs) {
+    // evaluate::Extremum is only created by the front-end when building
+    // compiler generated expressions (like when folding LEN() or shape/bounds
+    // inquiries). MIN and MAX are represented as evaluate::ProcedureRef and are
+    // not going through here. So far the frontend does not generate character
+    // Extremum so there is no way to test it.
+    if constexpr (TC == Fortran::common::TypeCategory::Character) {
+      fir::emitFatalError(loc, "Fortran::evaluate::Extremum are unexpected");
+    }
+    llvm::SmallVector<mlir::Value, 2> args{lhs, rhs};
+    fir::ExtendedValue res = op.ordering == Fortran::evaluate::Ordering::Greater
+                                 ? Fortran::lower::genMax(builder, loc, args)
+                                 : Fortran::lower::genMin(builder, loc, args);
+    return hlfir::EntityWithAttributes{fir::getBase(res)};
+  }
+};
+
 /// Lower Expr to HLFIR.
 class HlfirBuilder {
 public:
   HlfirBuilder(mlir::Location loc, Fortran::lower::AbstractConverter &converter,
                Fortran::lower::SymMap &symMap,
                Fortran::lower::StatementContext &stmtCtx)
       : converter{converter}, symMap{symMap}, stmtCtx{stmtCtx}, loc{loc} {}
 
private:
   hlfir::EntityWithAttributes
   gen(const Fortran::evaluate::Operation<D, R, LO, RO> &op) {
     auto &builder = getBuilder();
     mlir::Location loc = getLoc();
     if (op.Rank() != 0)
       TODO(loc, "elemental operations in HLFIR");
     auto left = hlfir::loadTrivialScalar(loc, builder, gen(op.left()));
     auto right = hlfir::loadTrivialScalar(loc, builder, gen(op.right()));
-    return BinaryOp<D>::gen(loc, builder, left, right);
+    return BinaryOp<D>::gen(loc, builder, op.derived(), left, right);
   }
 
   template <int KIND>
   hlfir::EntityWithAttributes gen(const Fortran::evaluate::Concat<KIND> &op) {
     auto lhs = gen(op.left());
     auto rhs = gen(op.right());
     llvm::SmallVector<mlir::Value> lengths;
     auto &builder = getBuilder();

flang/test/Lower/HLFIR/binary-ops.f90

subroutine complex_to_int_power(x, y, z)
   x = y**z
 end subroutine
 ! CHECK-LABEL: func.func @_QPcomplex_to_int_power(
 ! CHECK:  %[[VAL_4:.*]]:2 = hlfir.declare %{{.*}}y"} : (!fir.ref<!fir.complex<4>>) -> (!fir.ref<!fir.complex<4>>, !fir.ref<!fir.complex<4>>)
 ! CHECK:  %[[VAL_5:.*]]:2 = hlfir.declare %{{.*}}z"} : (!fir.ref<i32>) -> (!fir.ref<i32>, !fir.ref<i32>)
 ! CHECK:  %[[VAL_6:.*]] = fir.load %[[VAL_4]]#0 : !fir.ref<!fir.complex<4>>
 ! CHECK:  %[[VAL_7:.*]] = fir.load %[[VAL_5]]#0 : !fir.ref<i32>
 ! CHECK:  %[[VAL_8:.*]] = fir.call @_FortranAcpowi(%[[VAL_6]], %[[VAL_7]]) fastmath<contract> : (!fir.complex<4>, i32) -> !fir.complex<4>
+
+subroutine extremum(c, n, l)
+  integer(8), intent(in) :: l
+  integer(8) :: n
+  character(l) :: c
+  ! evaluate::Extremum is created by semantics while analyzing LEN().
+  n = len(c, 8)
+end subroutine
+! CHECK-LABEL: func.func @_QPextremum(
+! CHECK:  hlfir.declare {{.*}}c
+! CHECK:  %[[VAL_11:.*]] = arith.constant 0 : i64
+! CHECK:  %[[VAL_12:.*]] = fir.load %{{.*}} : !fir.ref<i64>
+! CHECK:  %[[VAL_13:.*]] = arith.cmpi sgt, %[[VAL_11]], %[[VAL_12]] : i64
+! CHECK:  arith.select %[[VAL_13]], %[[VAL_11]], %[[VAL_12]] : i64