[flang] Handle logical constant value for quiet in STOP stmt

[clementval]

Summary

This patch handles the quiet argument in the STOP statement. It adds
ability to lower LOGICAL constant.

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

Co-authored-by: Jean Perier <[e-mail]>

[kiranchandramohan]

LGTM. Have a Nit comment.

flang/lib/Lower/Runtime.cpp

82

Nit: remove auto.

[PeteSteinfeld]

All looks good.

[clementval]

Remove auto

flang/lib/Lower/ConvertExpr.cpp

public:
   template <int KIND>
   mlir::Value genIntegerConstant(mlir::MLIRContext *context,
                                  std::int64_t value) {
     mlir::Type type =
         converter.genType(Fortran::common::TypeCategory::Integer, KIND);
     return builder.createIntegerConstant(getLoc(), type, value);
   }
 
+  /// Generate a logical/boolean constant of `value`
+  mlir::Value genBoolConstant(bool value) {
+    return builder.createBool(getLoc(), value);
+  }
+
   ExtValue genval(Fortran::semantics::SymbolRef sym) {
     TODO(getLoc(), "genval SymbolRef");
   }
 
   ExtValue genval(const Fortran::evaluate::BOZLiteralConstant &) {
     TODO(getLoc(), "genval BOZ");
   }
 
#define GENBIN(GenBinEvOp, GenBinTyCat, GenBinFirOp)                           \
   /// 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) {
       return genIntegerConstant<KIND>(builder.getContext(), value.ToInt64());
     } else if constexpr (TC == Fortran::common::TypeCategory::Logical) {
-      TODO(getLoc(), "genval bool constant");
+      return genBoolConstant(value.IsTrue());
     } else if constexpr (TC == Fortran::common::TypeCategory::Real) {
       TODO(getLoc(), "genval real constant");
     } else if constexpr (TC == Fortran::common::TypeCategory::Complex) {
       TODO(getLoc(), "genval complex constant");
     } else /*constexpr*/ {
       llvm_unreachable("unhandled constant");
     }
   }

flang/lib/Lower/Runtime.cpp

void Fortran::lower::genStopStatement(
 
   // Second operand indicates ERROR STOP
   bool isError = std::get<Fortran::parser::StopStmt::Kind>(stmt.t) ==
                  Fortran::parser::StopStmt::Kind::ErrorStop;
   operands.push_back(builder.createIntegerConstant(
       loc, calleeType.getInput(operands.size()), isError));
 
   // Third operand indicates QUIET (default to false).
-  if (std::get<std::optional<Fortran::parser::ScalarLogicalExpr>>(stmt.t)) {
-    TODO(loc, "STOP third operand not lowered yet");
+  if (const auto &quiet =
+          std::get<std::optional<Fortran::parser::ScalarLogicalExpr>>(stmt.t)) {
+    const SomeExpr *expr = Fortran::semantics::GetExpr(*quiet);
+    assert(expr && "failed getting typed expression");
+    mlir::Value q = fir::getBase(converter.genExprValue(*expr));
+    operands.push_back(
+        builder.createConvert(loc, calleeType.getInput(operands.size()), q));
   } else {
     operands.push_back(builder.createIntegerConstant(
         loc, calleeType.getInput(operands.size()), 0));
   }
 
   builder.create<fir::CallOp>(loc, callee, operands);
   genUnreachable(builder, loc);
 }

flang/test/Lower/stop-statement.f90

 ! CHECK-LABEL stop_code
 subroutine stop_code()
   stop 42
  ! CHECK-DAG: %[[c42:.*]] = arith.constant 42 : i32
  ! CHECK-DAG: %[[false:.*]] = arith.constant false
  ! CHECK: fir.call @_Fortran{{.*}}StopStatement(%[[c42]], %[[false]], %[[false]])
  ! CHECK-NEXT: fir.unreachable
 end subroutine
+
+! CHECK-LABEL stop_quiet_constant
+subroutine stop_quiet_constant()
+  stop, quiet = .true.
+ ! CHECK-DAG: %[[true:.*]] = arith.constant true
+ ! CHECK-DAG: %[[false:.*]] = arith.constant false
+ ! CHECK-DAG: %[[c0:.*]] = arith.constant 0 : i32
+ ! CHECK: fir.call @_Fortran{{.*}}StopStatement(%[[c0]], %[[false]], %[[true]])
+ ! CHECK-NEXT: fir.unreachable
+end subroutine