[flang] Introduce option to lower expression to HLFIR

[jeanPerier]

Summary

Preliminary work on HLFIR. Introduce option that will allow testing
lowering via HLFIR until this is ready to replace the current expression
lowering.

See https://reviews.llvm.org/D134285 for more context about the plan.

[clementval]

LGTM. Good to see this work getting started!

flang/include/flang/Lower/AbstractConverter.h

131

Is this change related?

[jeanPerier]

flang/include/flang/Lower/AbstractConverter.h

131

Yes, I renamed the argument name in the override definition in lib/Lower/Bridge.cpp, so it seemed more consistent to also changed it in the abstract declaration.

[DavidTruby]

Good to see HLFIR getting going! Do you have a plan to support this in the flang-new driver as well as bbc?

[PeteSteinfeld]

It looks to me like references to the data member lowerToHighLevelFIR should be made consistent.

flang/include/flang/Lower/LoweringOptions.h

29

Shouldn't this be bool rather than unsigned?

[tschuett]

In D135959#3858896, @PeteSteinfeld wrote:

It looks to me like references to the data member lowerToHighLevelFIR should be made consistent.

flang/include/flang/Lower/LoweringOptions.h

29

IIRC, MSVC does not like mixed bitfields.

[jeanPerier]

In D135959#3858615, @DavidTruby wrote:

Good to see HLFIR getting going! Do you have a plan to support this in the flang-new driver as well as bbc?

Yes, when there is some end-to-end support for this new path, I will add a way to control the option in flang-new too.

In D135959#3858896, @PeteSteinfeld wrote:

It looks to me like references to the data member lowerToHighLevelFIR should be made consistent.

The members LoweringOptions were previously added as bit-fields (https://en.cppreference.com/w/cpp/language/bit_field), so making the new one a bool would be inconsistent.

flang/include/flang/Lower/AbstractConverter.h

public:
   //===--------------------------------------------------------------------===//
 
   /// Generate the address of the location holding the expression, \p expr.
   /// If \p expr is a Designator that is not compile time contiguous, the
   /// address returned is the one of a contiguous temporary storage holding the
   /// expression value. The clean-up for this temporary is added to \p context.
   virtual fir::ExtendedValue genExprAddr(const SomeExpr &expr,
                                          StatementContext &context,
-                                         mlir::Location *loc = nullptr) = 0;
+                                         mlir::Location *locPtr = nullptr) = 0;
 
   /// Generate the address of the location holding the expression, \p expr.
   fir::ExtendedValue genExprAddr(mlir::Location loc, const SomeExpr *expr,
                                  StatementContext &stmtCtx) {
     return genExprAddr(*expr, stmtCtx, &loc);
   }
   fir::ExtendedValue genExprAddr(mlir::Location loc, const SomeExpr &expr,
                                  StatementContext &stmtCtx) {
     return genExprAddr(expr, stmtCtx, &loc);
   }
 
   /// Generate the computations of the expression to produce a value.
   virtual fir::ExtendedValue genExprValue(const SomeExpr &expr,
                                           StatementContext &context,
-                                          mlir::Location *loc = nullptr) = 0;
+                                          mlir::Location *locPtr = nullptr) = 0;
 
   /// Generate the computations of the expression, \p expr, to produce a value.
   fir::ExtendedValue genExprValue(mlir::Location loc, const SomeExpr *expr,
                                   StatementContext &stmtCtx) {
     return genExprValue(*expr, stmtCtx, &loc);
   }
   fir::ExtendedValue genExprValue(mlir::Location loc, const SomeExpr &expr,
                                   StatementContext &stmtCtx) {

flang/include/flang/Lower/LoweringOptions.h

 
 class LoweringOptions {
   /// If true, lower transpose without a runtime call.
   unsigned optimizeTranspose : 1;
 
   /// If true, enable polymorphic type lowering feature. Off by default.
   unsigned polymorphicTypeImpl : 1;
 
+  /// If true, lower to High level FIR before lowering to FIR.
+  /// Off by default until fully ready.
+  unsigned lowerToHighLevelFIR : 1;
+
 public:
-  LoweringOptions() : optimizeTranspose(true), polymorphicTypeImpl(false) {}
+  LoweringOptions()
+      : optimizeTranspose(true), polymorphicTypeImpl(false),
+        lowerToHighLevelFIR(false) {}
 
   bool getOptimizeTranspose() const { return optimizeTranspose; }
   LoweringOptions &setOptimizeTranspose(bool v) {
     optimizeTranspose = v;
     return *this;
   }
 
   bool isPolymorphicTypeImplEnabled() const { return polymorphicTypeImpl; }
   LoweringOptions &setPolymorphicTypeImpl(bool v) {
     polymorphicTypeImpl = v;
     return *this;
   }
+
+  bool getLowerToHighLevelFIR() const { return lowerToHighLevelFIR; }
+  LoweringOptions &setLowerToHighLevelFIR(bool v) {
+    lowerToHighLevelFIR = v;
+    return *this;
+  }
 };
 
 } // namespace Fortran::lower
 
 #endif // FLANG_LOWER_LOWERINGOPTIONS_H

flang/lib/Lower/Bridge.cpp

lookupLabel(Fortran::lower::pft::Label label) override final {
     Fortran::lower::pft::FunctionLikeUnit &owningProc =
         *getEval().getOwningProcedure();
     auto iter = owningProc.labelEvaluationMap.find(label);
     if (iter == owningProc.labelEvaluationMap.end())
       return nullptr;
     return iter->second;
   }
 
-  fir::ExtendedValue genExprAddr(const Fortran::lower::SomeExpr &expr,
-                                 Fortran::lower::StatementContext &context,
-                                 mlir::Location *loc = nullptr) override final {
-    return Fortran::lower::createSomeExtendedAddress(
-        loc ? *loc : toLocation(), *this, expr, localSymbols, context);
+  fir::ExtendedValue
+  genExprAddr(const Fortran::lower::SomeExpr &expr,
+              mlir::Location *locPtr = nullptr) override final {
+    mlir::Location loc = locPtr ? *locPtr : toLocation();
+    if (bridge.getLoweringOptions().getLowerToHighLevelFIR())
+      TODO(loc, "lower expr to HLFIR address");
+    return Fortran::lower::createSomeExtendedAddress(loc, *this, expr,
+                                                     localSymbols, context);
   }
   fir::ExtendedValue
   genExprValue(const Fortran::lower::SomeExpr &expr,
                Fortran::lower::StatementContext &context,
-               mlir::Location *loc = nullptr) override final {
-    return Fortran::lower::createSomeExtendedExpression(
-        loc ? *loc : toLocation(), *this, expr, localSymbols, context);
+               mlir::Location *locPtr = nullptr) override final {
+    mlir::Location loc = locPtr ? *locPtr : toLocation();
+    if (bridge.getLoweringOptions().getLowerToHighLevelFIR())
+      TODO(loc, "lower expr to HLFIR value");
+    return Fortran::lower::createSomeExtendedExpression(loc, *this, expr,
+                                                        localSymbols, context);
   }
 
   fir::ExtendedValue
   genExprBox(mlir::Location loc, const Fortran::lower::SomeExpr &expr,
              Fortran::lower::StatementContext &stmtCtx) override final {
+    if (bridge.getLoweringOptions().getLowerToHighLevelFIR())
+      TODO(loc, "lower expr to HLFIR box");
     return Fortran::lower::createBoxValue(loc, *this, expr, localSymbols,
                                           stmtCtx);
   }
 
   Fortran::evaluate::FoldingContext &getFoldingContext() override final {
     return foldingContext;
   }
 

flang/test/Lower/HLFIR/expr-addr.f90

+! Test lowering of of expressions as address
+! RUN: %not_todo_cmd bbc -emit-fir -hlfir -o - %s 2>&1 | FileCheck %s
+
+subroutine foo(x)
+  integer :: x
+  ! CHECK: not yet implemented: lower expr to HLFIR address
+  read (*,*) x
+end subroutine

flang/test/Lower/HLFIR/expr-box.f90

+! Test lowering of of expressions as fir.box
+! RUN: %not_todo_cmd bbc -emit-fir -hlfir -o - %s 2>&1 | FileCheck %s
+
+subroutine foo(x)
+  integer :: x(:)
+  ! CHECK: not yet implemented: lower expr to HLFIR box
+  print *, x 
+end subroutine

flang/test/Lower/HLFIR/expr-value.f90

+! Test lowering of of expressions as values
+! RUN: %not_todo_cmd bbc -emit-fir -hlfir -o - %s 2>&1 | FileCheck %s
+
+subroutine foo()
+  ! CHECK: not yet implemented: lower expr to HLFIR value
+  print *, 42 
+end subroutine

flang/tools/bbc/bbc.cpp

static llvm::cl::opt<bool> enableOpenACC("fopenacc",
                                          llvm::cl::desc("enable openacc"),
                                          llvm::cl::init(false));
 
 static llvm::cl::opt<bool> enablePolymorphic(
     "polymorphic-type",
     llvm::cl::desc("enable polymorphic type lowering (experimental)"),
     llvm::cl::init(false));
 
+static llvm::cl::opt<bool> useHLFIR("hlfir",
+                                    llvm::cl::desc("Lower to high level FIR"),
+                                    llvm::cl::init(false));
+
 #define FLANG_EXCLUDE_CODEGEN
 #include "flang/Tools/CLOptions.inc"
 
 //===----------------------------------------------------------------------===//
 
 using ProgramName = std::string;
 
 // Print the module without the "module { ... }" wrapper.
static mlir::LogicalResult convertFortranSourceToMLIR(
   mlir::MLIRContext ctx(registry);
   fir::support::loadNonCodegenDialects(ctx);
   auto &defKinds = semanticsContext.defaultKinds();
   fir::KindMapping kindMap(
       &ctx, llvm::ArrayRef<fir::KindTy>{fir::fromDefaultKinds(defKinds)});
   // Use default lowering options for bbc.
   Fortran::lower::LoweringOptions loweringOptions{};
   loweringOptions.setPolymorphicTypeImpl(enablePolymorphic);
+  loweringOptions.setLowerToHighLevelFIR(useHLFIR);
   auto burnside = Fortran::lower::LoweringBridge::create(
       ctx, semanticsContext, defKinds, semanticsContext.intrinsics(),
       semanticsContext.targetCharacteristics(), parsing.allCooked(), "",
       kindMap, loweringOptions, {});
   burnside.lower(parseTree, semanticsContext);
   mlir::ModuleOp mlirModule = burnside.getModule();
   std::error_code ec;
   std::string outputName = outputFilename;