[flang] Lower logical comparison and logical operations

[clementval]

Summary

This handles the lowering of the logical comparison
to arith.cmpi operation. The logical operations .OR., .AND.
and .NOT. are lowered to arith.ori, arith.andi and arith.xori

This patch is part of the upstreaming effort from fir-dev branch.

Depends on D120559

[rovka]

LGTM.

flang/lib/Lower/ConvertExpr.cpp

#define GENBIN(GenBinEvOp, GenBinTyCat, GenBinFirOp)                           \
 
   template <typename A>
   ExtValue genval(const Fortran::evaluate::Parentheses<A> &op) {
     TODO(getLoc(), "genval parentheses<A>");
   }
 
   template <int KIND>
   ExtValue genval(const Fortran::evaluate::Not<KIND> &op) {
-    TODO(getLoc(), "genval Not<KIND>");
+    mlir::Value logical = genunbox(op.left());
+    mlir::Value one = genBoolConstant(true);
+    mlir::Value val =
+        builder.createConvert(getLoc(), builder.getI1Type(), logical);
+    return builder.create<mlir::arith::XOrIOp>(getLoc(), val, one);
   }
 
   template <int KIND>
   ExtValue genval(const Fortran::evaluate::LogicalOperation<KIND> &op) {
-    TODO(getLoc(), "genval LogicalOperation<KIND>");
+    mlir::IntegerType i1Type = builder.getI1Type();
+    mlir::Value slhs = genunbox(op.left());
+    mlir::Value srhs = genunbox(op.right());
+    mlir::Value lhs = builder.createConvert(getLoc(), i1Type, slhs);
+    mlir::Value rhs = builder.createConvert(getLoc(), i1Type, srhs);
+    switch (op.logicalOperator) {
+    case Fortran::evaluate::LogicalOperator::And:
+      return createBinaryOp<mlir::arith::AndIOp>(lhs, rhs);
+    case Fortran::evaluate::LogicalOperator::Or:
+      return createBinaryOp<mlir::arith::OrIOp>(lhs, rhs);
+    case Fortran::evaluate::LogicalOperator::Eqv:
+      return createCompareOp<mlir::arith::CmpIOp>(
+          mlir::arith::CmpIPredicate::eq, lhs, rhs);
+    case Fortran::evaluate::LogicalOperator::Neqv:
+      return createCompareOp<mlir::arith::CmpIOp>(
+          mlir::arith::CmpIPredicate::ne, lhs, rhs);
+    case Fortran::evaluate::LogicalOperator::Not:
+      // lib/evaluate expression for .NOT. is Fortran::evaluate::Not<KIND>.
+      llvm_unreachable(".NOT. is not a binary operator");
+    }
+    llvm_unreachable("unhandled logical operation");
   }
 
   /// Convert a scalar literal constant to IR.
   template <Fortran::common::TypeCategory TC, int KIND>
   ExtValue genScalarLit(
       const Fortran::evaluate::Scalar<Fortran::evaluate::Type<TC, KIND>>
           &value) {
     if constexpr (TC == Fortran::common::TypeCategory::Integer) {

flang/test/Lower/logical-operations.f90

+! RUN: bbc %s -o "-" | FileCheck %s
+
+! Test logical intrinsic operation lowering to fir.
+
+! CHECK-LABEL:eqv0_test
+LOGICAL(1) FUNCTION eqv0_test(x0, x1)
+LOGICAL(1) :: x0
+LOGICAL(1) :: x1
+! CHECK-DAG:[[reg1:%[0-9]+]] = fir.load %arg0
+! CHECK-DAG:[[reg2:%[0-9]+]] = fir.load %arg1
+! CHECK-DAG:[[reg3:%[0-9]+]] = fir.convert [[reg1]] {{.*}} -> i1
+! CHECK-DAG:[[reg4:%[0-9]+]] = fir.convert [[reg2]] {{.*}} -> i1
+! CHECK:[[reg5:%[0-9]+]] = arith.cmpi eq, [[reg3]], [[reg4]]
+! CHECK:fir.convert [[reg5]] {{.*}} -> !fir.logical<1>
+eqv0_test = x0 .EQV. x1
+END FUNCTION
+
+! CHECK-LABEL:neqv1_test
+LOGICAL(1) FUNCTION neqv1_test(x0, x1)
+LOGICAL(1) :: x0
+LOGICAL(1) :: x1
+! CHECK-DAG:[[reg1:%[0-9]+]] = fir.load %arg0
+! CHECK-DAG:[[reg2:%[0-9]+]] = fir.load %arg1
+! CHECK-DAG:[[reg3:%[0-9]+]] = fir.convert [[reg1]] {{.*}} -> i1
+! CHECK-DAG:[[reg4:%[0-9]+]] = fir.convert [[reg2]] {{.*}} -> i1
+! CHECK:[[reg5:%[0-9]+]] = arith.cmpi ne, [[reg3]], [[reg4]]
+! CHECK:fir.convert [[reg5]] {{.*}} -> !fir.logical<1>
+neqv1_test = x0 .NEQV. x1
+END FUNCTION
+
+! CHECK-LABEL:or2_test
+LOGICAL(1) FUNCTION or2_test(x0, x1)
+LOGICAL(1) :: x0
+LOGICAL(1) :: x1
+! CHECK-DAG:[[reg1:%[0-9]+]] = fir.load %arg0
+! CHECK-DAG:[[reg2:%[0-9]+]] = fir.load %arg1
+! CHECK-DAG:[[reg3:%[0-9]+]] = fir.convert [[reg1]] {{.*}} -> i1
+! CHECK-DAG:[[reg4:%[0-9]+]] = fir.convert [[reg2]] {{.*}} -> i1
+! CHECK:[[reg5:%[0-9]+]] = arith.ori [[reg3]], [[reg4]]
+! CHECK:fir.convert [[reg5]] {{.*}} -> !fir.logical<1>
+or2_test = x0 .OR. x1
+END FUNCTION
+
+! CHECK-LABEL:and3_test
+LOGICAL(1) FUNCTION and3_test(x0, x1)
+LOGICAL(1) :: x0
+LOGICAL(1) :: x1
+! CHECK-DAG:[[reg1:%[0-9]+]] = fir.load %arg0
+! CHECK-DAG:[[reg2:%[0-9]+]] = fir.load %arg1
+! CHECK-DAG:[[reg3:%[0-9]+]] = fir.convert [[reg1]] {{.*}} -> i1
+! CHECK-DAG:[[reg4:%[0-9]+]] = fir.convert [[reg2]] {{.*}} -> i1
+! CHECK:[[reg5:%[0-9]+]] = arith.andi [[reg3]], [[reg4]]
+! CHECK:fir.convert [[reg5]] {{.*}} -> !fir.logical<1>
+and3_test = x0 .AND. x1
+END FUNCTION
+
+! CHECK-LABEL:not4_test
+LOGICAL(1) FUNCTION not4_test(x0)
+LOGICAL(1) :: x0
+! CHECK:[[reg1:%[0-9]+]] = fir.load %arg0
+! CHECK:[[reg2:%[0-9]+]] = fir.convert [[reg1]] {{.*}} -> i1
+! CHECK:[[reg3:%[0-9]+]] = arith.xori [[reg2]], %true
+! CHECK:fir.convert [[reg3]] {{.*}} -> !fir.logical<1>
+not4_test = .NOT. x0
+END FUNCTION