[NFC] Move FirOpBuilder, ExtendedValue and tools into lib/Optimizer/Builder

Many FIR related tools and helpers are not accessible in
lib/Optimizer/Transform because they are part of lib/Lower library
even though they only operate on FIR and MLIR data structures.

Most of these tools are using the FirOpBuilder. Move this class into
Optimizer/Builder/FirOpBuilder.h. Change FirOpBuilder namespace to
fir.
Similarly, the fir::ExtendedValue is a key data structure in all
helpers. Move it under Optimizer/Builder/BoxValue.h. Its namespace was
already fir. Split its implementation from Lower/SymbolMap.cpp into
a new Optimzer/Builder/BoxValue.cpp file.

The FirOpBuilder implementation depends on ComplexExpr.h,
CharacterExpr.h, DoLoopHelper.h, and Allocatable.h.

- Split Allocatable.h into Lower/Allocatable.h (that contains the API to
  lower allocation/association on front end data structure) and
  Optimizer/Builder/MutableBox.h (that contains the tools to work with
  MutableBoxValue)

- Move CharacterExpr.h to Optimizer/Builder/Character.h. Implement a
  small genMin locally in Character.cpp to break the dependency with
  lib/Lower/intrinsicCall.cpp.
- Move ComplexExpr.h to Optimizer/Builder/Complex.h. ComplexExpr.cpp
  depended on lib/Lower/ConvertType.cpp to convert a kind to a real
  type. Add a getRealType(kind) helper to FirOpBuilder using the kindMap
  instead.
- Move DoLoopHelper.h to Optimizer/Builder/DoLoopHelper.h.

Apart from the ExtendedValue and FirOpBuilder classes that are directly under
fir namespace, all moved functions are placed under the fir::factory
namespace since they generate big chunks of FIR to implement Fortran
pattern.

The lib/Optimizer/Builder files are added to a new libFIROpBuilder
library.

With all this, FirOpBuilder and related tools is available in
lib/Optimizer and no new dependency is brought into lib/Optimizer.

Author: jeanPerier

flang/docs/tutorials/addingIntrinsics.md

@@ -320,14 +320,14 @@ it can be deallocated after the statement.
 The implementation of the runtime call in lowering looks like:
 
 ```c++
-void Fortran::lower::genTrim(Fortran::lower::FirOpBuilder &builder,
+void Fortran::lower::genTrim(fir::FirOpBuilder &builder,
                              mlir::Location loc, mlir::Value resultBox,
                              mlir::Value stringBox) {
   auto trimFunc = getRuntimeFunc<mkRTKey(Trim)>(loc, builder);
   auto fTy = trimFunc.getType();
-  auto sourceFile = Fortran::lower::locationToFilename(builder, loc);
+  auto sourceFile = fir::factory::locationToFilename(builder, loc);
   auto sourceLine =
-      Fortran::lower::locationToLineNo(builder, loc, fTy.getInput(3));
+      fir::factory::locationToLineNo(builder, loc, fTy.getInput(3));
 
   llvm::SmallVector<mlir::Value> args;
   args.emplace_back(builder.createConvert(loc, fTy.getInput(0), resultBox));

flang/include/flang/Lower/AbstractConverter.h

@@ -15,13 +15,14 @@
 
 #include "flang/Common/Fortran.h"
 #include "flang/Lower/PFTDefs.h"
-#include "flang/Lower/Support/BoxValue.h"
+#include "flang/Optimizer/Builder/BoxValue.h"
 #include "mlir/IR/BuiltinOps.h"
 #include "llvm/ADT/ArrayRef.h"
 
 namespace fir {
 class KindMapping;
-}
+class FirOpBuilder;
+} // namespace fir
 namespace Fortran {
 namespace common {
 template <typename>
@@ -50,7 +51,6 @@ struct Variable;
 
 using SomeExpr = Fortran::evaluate::Expr<Fortran::evaluate::SomeType>;
 using SymbolRef = Fortran::common::Reference<const Fortran::semantics::Symbol>;
-class FirOpBuilder;
 class StatementContext;
 
 //===----------------------------------------------------------------------===//
@@ -87,9 +87,10 @@ class AbstractConverter {
   /// Get the code defined by a label
   virtual pft::Evaluation *lookupLabel(pft::Label label) = 0;
 
-  /// For a give symbol which is host-associated, create a clone using parameters from
-  /// the host-associated symbol.
-  virtual bool createHostAssociateVarClone(const Fortran::semantics::Symbol &sym) = 0;
+  /// For a give symbol which is host-associated, create a clone using
+  /// parameters from the host-associated symbol.
+  virtual bool
+  createHostAssociateVarClone(const Fortran::semantics::Symbol &sym) = 0;
 
   //===--------------------------------------------------------------------===//
   // Expressions
@@ -178,7 +179,7 @@ class AbstractConverter {
   //===--------------------------------------------------------------------===//
 
   /// Get the OpBuilder
-  virtual FirOpBuilder &getFirOpBuilder() = 0;
+  virtual fir::FirOpBuilder &getFirOpBuilder() = 0;
   /// Get the ModuleOp
   virtual mlir::ModuleOp &getModuleOp() = 0;
   /// Get the MLIRContext

flang/include/flang/Lower/Allocatable.h

@@ -10,18 +10,19 @@
 //
 //===----------------------------------------------------------------------===//
 
+#include "flang/Optimizer/Builder/MutableBox.h"
 #include "llvm/ADT/StringRef.h"
 
 namespace mlir {
 class Value;
 class ValueRange;
-class Type;
 class Location;
 } // namespace mlir
 
 namespace fir {
 class MutableBoxValue;
 class ExtendedValue;
+class FirOpBuilder;
 } // namespace fir
 
 namespace Fortran::parser {
@@ -38,24 +39,12 @@ struct SomeType;
 namespace Fortran::lower {
 struct SymbolBox;
 class AbstractConverter;
-class FirOpBuilder;
 class StatementContext;
 
 namespace pft {
 struct Variable;
 }
 
-/// Create a fir.box of type \p boxType that can be used to initialize an
-/// allocatable variable. Initialization of such variable has to be done at the
-/// beginning of the variable lifetime by storing the created box in the memory
-/// for the variable box.
-/// \p nonDeferredParams must provide the non deferred length parameters so that
-/// they can already be placed in the unallocated box (inquiries about these
-/// parameters are legal even in unallocated state).
-mlir::Value createUnallocatedBox(Fortran::lower::FirOpBuilder &builder,
-                                 mlir::Location loc, mlir::Type boxType,
-                                 mlir::ValueRange nonDeferredParams);
-
 /// Lower an allocate statement to fir.
 void genAllocateStmt(Fortran::lower::AbstractConverter &,
                      const Fortran::parser::AllocateStmt &, mlir::Location);
@@ -73,31 +62,6 @@ fir::MutableBoxValue createMutableBox(Fortran::lower::AbstractConverter &,
                                       mlir::Value boxAddr,
                                       mlir::ValueRange nonDeferredParams);
 
-/// Create a MutableBoxValue for a temporary allocatable.
-/// The created MutableBoxValue wraps a fir.ref<fir.box<fir.heap<type>>> and is
-/// initialized to unallocated/diassociated status. An optional name can be
-/// given to the created !fir.ref<fir.box>.
-fir::MutableBoxValue createTempMutableBox(Fortran::lower::FirOpBuilder &,
-                                          mlir::Location, mlir::Type type,
-                                          llvm::StringRef name = {});
-
-/// Read all mutable properties into a normal symbol box.
-/// It is OK to call this on unassociated/unallocated boxes but any use of the
-/// resulting values will be undefined (only the base address will be guaranteed
-/// to be null).
-Fortran::lower::SymbolBox genMutableBoxRead(Fortran::lower::FirOpBuilder &,
-                                            mlir::Location,
-                                            const fir::MutableBoxValue &,
-                                            bool mayBePolymorphic = true);
-
-/// Update a MutableBoxValue to describe entity \p source (that must be in
-/// memory). If \lbounds is not empty, it is used to defined the MutableBoxValue
-/// lower bounds, otherwise, the lower bounds from \p source are used.
-void associateMutableBox(Fortran::lower::FirOpBuilder &, mlir::Location,
-                         const fir::MutableBoxValue &,
-                         const fir::ExtendedValue &source,
-                         mlir::ValueRange lbounds);
-
 /// Update a MutableBoxValue to describe the entity designated by the expression
 /// \p source. This version takes care of \p source lowering.
 /// If \lbounds is not empty, it is used to defined the MutableBoxValue
@@ -108,60 +72,4 @@ void associateMutableBox(
     const Fortran::evaluate::Expr<Fortran::evaluate::SomeType> &source,
     mlir::ValueRange lbounds, Fortran::lower::StatementContext &);
 
-/// Update a MutableBoxValue to describe entity \p source (that must be in
-/// memory) with a new array layout given by \p lbounds and \p ubounds.
-/// \p source must be known to be contiguous at compile time, or it must have
-/// rank 1 (constraint from Fortran 2018 standard 10.2.2.3 point 9).
-void associateMutableBoxWithRemap(Fortran::lower::FirOpBuilder &,
-                                  mlir::Location, const fir::MutableBoxValue &,
-                                  const fir::ExtendedValue &source,
-                                  mlir::ValueRange lbounds,
-                                  mlir::ValueRange ubounds);
-
-/// Set the association status of a MutableBoxValue to
-/// disassociated/unallocated. Nothing is done with the entity that was
-/// previously associated/allocated. The function generates code that sets the
-/// address field of the MutableBoxValue to zero.
-void disassociateMutableBox(Fortran::lower::FirOpBuilder &, mlir::Location,
-                            const fir::MutableBoxValue &);
-
-/// Generate code to conditionally reallocate a MutableBoxValue with a new
-/// shape, lower bounds, and length parameters if it is unallocated or if its
-/// current shape or deferred  length parameters do not match the provided ones.
-/// Lower bounds are only used if the entity needs to be allocated, otherwise,
-/// the MutableBoxValue will keep its current lower bounds.
-/// If the MutableBoxValue is an array, the provided shape can be empty, in
-/// which case the MutableBoxValue must already be allocated at runtime and its
-/// shape and lower bounds will be kept. If \p shape is empty, only a length
-/// parameter mismatch can trigger a reallocation. See Fortran 10.2.1.3 point 3
-/// that this function is implementing for more details. The polymorphic
-/// requirements are not yet covered by this function.
-void genReallocIfNeeded(Fortran::lower::FirOpBuilder &, mlir::Location,
-                        const fir::MutableBoxValue &, mlir::ValueRange lbounds,
-                        mlir::ValueRange shape, mlir::ValueRange lengthParams);
-
-/// Returns the fir.ref<fir.box<T>> of a MutableBoxValue filled with the current
-/// association / allocation properties. If the fir.ref<fir.box> already exists
-/// and is-up to date, this is a no-op, otherwise, code will be generated to
-/// fill the it.
-mlir::Value getMutableIRBox(Fortran::lower::FirOpBuilder &, mlir::Location,
-                            const fir::MutableBoxValue &);
-
-/// When the MutableBoxValue was passed as a fir.ref<fir.box> to a call that may
-/// have modified it, update the MutableBoxValue according to the
-/// fir.ref<fir.box> value.
-void syncMutableBoxFromIRBox(Fortran::lower::FirOpBuilder &, mlir::Location,
-                             const fir::MutableBoxValue &);
-
-/// Generate allocation or association status test and returns the resulting
-/// i1. This is testing this for a valid/non-null base address value.
-mlir::Value genIsAllocatedOrAssociatedTest(Fortran::lower::FirOpBuilder &,
-                                           mlir::Location,
-                                           const fir::MutableBoxValue &);
-
-/// Finalize a mutable box if it is allocated or associated. This includes both
-/// calling the finalizer, if any, and deallocating the storage.
-void genFinalization(Fortran::lower::FirOpBuilder &, mlir::Location,
-                     const fir::MutableBoxValue &);
-
 } // namespace Fortran::lower

flang/include/flang/Lower/CharacterRuntime.h

@@ -13,11 +13,11 @@
 
 namespace fir {
 class ExtendedValue;
-}
+class FirOpBuilder;
+} // namespace fir
 
 namespace Fortran {
 namespace lower {
-class FirOpBuilder;
 
 /// Generate a call to the ADJUSTL runtime.
 /// This calls the simple runtime entry point that then calls into the more
@@ -27,10 +27,8 @@ class FirOpBuilder;
 /// result.  \p StringBox must be a fir.box describing the adjustl string
 /// argument. Note that the \p genAdjust() helper is called to do the majority
 /// of the lowering work.
-void genAdjustL(Fortran::lower::FirOpBuilder &builder,
-                mlir::Location loc,
-                mlir::Value resultBox,
-                mlir::Value stringBox);
+void genAdjustL(fir::FirOpBuilder &builder, mlir::Location loc,
+                mlir::Value resultBox, mlir::Value stringBox);
 
 /// Generate a call to the ADJUSTR runtime.
 /// This calls the simple runtime entry point that then calls into the more
@@ -40,26 +38,22 @@ void genAdjustL(Fortran::lower::FirOpBuilder &builder,
 /// result.  \p StringBox must be a fir.box describing the adjustr string
 /// argument. Note that the \p genAdjust() helper is called to do the majority
 /// of the lowering work.
-void genAdjustR(Fortran::lower::FirOpBuilder &builder,
-                mlir::Location loc,
-                mlir::Value resultBox,
-                mlir::Value stringBox);
+void genAdjustR(fir::FirOpBuilder &builder, mlir::Location loc,
+                mlir::Value resultBox, mlir::Value stringBox);
 
 /// Generate a call to the ADJUST[L|R] runtime.
 ///
 /// \p resultBox must be an unallocated allocatable used for the temporary
 /// result.  \p StringBox must be a fir.box describing the adjustr string
 /// argument.  The \p adjustFunc should be a mlir::FuncOp for the appropriate
 /// runtime entry function.
-void genAdjust(Fortran::lower::FirOpBuilder &builder,
-               mlir::Location loc,
-               mlir::Value resultBox,
-               mlir::Value stringBox,
+void genAdjust(fir::FirOpBuilder &builder, mlir::Location loc,
+               mlir::Value resultBox, mlir::Value stringBox,
                mlir::FuncOp &adjustFunc);
 
 /// Generate call to a character comparison for two ssa-values of type
 /// `boxchar`.
-mlir::Value genCharCompare(FirOpBuilder &builder, mlir::Location loc,
+mlir::Value genCharCompare(fir::FirOpBuilder &builder, mlir::Location loc,
                            mlir::CmpIPredicate cmp,
                            const fir::ExtendedValue &lhs,
                            const fir::ExtendedValue &rhs);
@@ -68,23 +62,23 @@ mlir::Value genCharCompare(FirOpBuilder &builder, mlir::Location loc,
 /// are 4 arguments, 2 for the lhs and 2 for the rhs. Each CHARACTER must pass a
 /// reference to its buffer (`ref<char<K>>`) and its LEN type parameter (some
 /// integral type).
-mlir::Value genCharCompare(FirOpBuilder &builder, mlir::Location loc,
+mlir::Value genCharCompare(fir::FirOpBuilder &builder, mlir::Location loc,
                            mlir::CmpIPredicate cmp, mlir::Value lhsBuff,
                            mlir::Value lhsLen, mlir::Value rhsBuff,
                            mlir::Value rhsLen);
 
 /// Generate call to INDEX runtime.
 /// This calls the simple runtime entry points based on the KIND of the string.
 /// No descriptors are used.
-mlir::Value genIndex(FirOpBuilder &builder, mlir::Location loc, int kind,
+mlir::Value genIndex(fir::FirOpBuilder &builder, mlir::Location loc, int kind,
                      mlir::Value stringBase, mlir::Value stringLen,
                      mlir::Value substringBase, mlir::Value substringLen,
                      mlir::Value back);
 
 /// Generate call to INDEX runtime.
 /// This calls the descriptor based runtime call implementation for the index
 /// intrinsic.
-void genIndexDescriptor(FirOpBuilder &builder, mlir::Location loc,
+void genIndexDescriptor(fir::FirOpBuilder &builder, mlir::Location loc,
                         mlir::Value resultBox, mlir::Value stringBox,
                         mlir::Value substringBox, mlir::Value backOpt,
                         mlir::Value kind);
@@ -94,45 +88,45 @@ void genIndexDescriptor(FirOpBuilder &builder, mlir::Location loc,
 ///   result. \p stringBox must be a fir.box describing repeat string argument.
 ///   \p ncopies must be a value representing the number of copies.
 /// The runtime will always allocate the resultBox.
-void genRepeat(Fortran::lower::FirOpBuilder &builder, mlir::Location loc,
+void genRepeat(fir::FirOpBuilder &builder, mlir::Location loc,
                mlir::Value resultBox, mlir::Value stringBox,
                mlir::Value ncopies);
 
 /// Generate call to trim runtime.
 ///   \p resultBox must be an unallocated allocatable used for the temporary
 ///   result. \p stringBox must be a fir.box describing trim string argument.
 /// The runtime will always allocate the resultBox.
-void genTrim(Fortran::lower::FirOpBuilder &builder, mlir::Location loc,
+void genTrim(fir::FirOpBuilder &builder, mlir::Location loc,
              mlir::Value resultBox, mlir::Value stringBox);
 
 /// Generate call to scan runtime.
 /// This calls the descriptor based runtime call implementation of the scan
 /// intrinsics.
-void genScanDescriptor(Fortran::lower::FirOpBuilder &builder,
-                       mlir::Location loc, mlir::Value resultBox,
-                       mlir::Value stringBox, mlir::Value setBox,
-                       mlir::Value backBox, mlir::Value kind);
+void genScanDescriptor(fir::FirOpBuilder &builder, mlir::Location loc,
+                       mlir::Value resultBox, mlir::Value stringBox,
+                       mlir::Value setBox, mlir::Value backBox,
+                       mlir::Value kind);
 
 /// Generate call to the scan runtime routine that is specialized on
 /// \param kind.
 /// The \param kind represents the kind of the elements in the strings.
-mlir::Value genScan(Fortran::lower::FirOpBuilder &builder, mlir::Location loc,
-                    int kind, mlir::Value stringBase, mlir::Value stringLen,
+mlir::Value genScan(fir::FirOpBuilder &builder, mlir::Location loc, int kind,
+                    mlir::Value stringBase, mlir::Value stringLen,
                     mlir::Value setBase, mlir::Value setLen, mlir::Value back);
 
 /// Generate call to verify runtime.
 /// This calls the descriptor based runtime call implementation of the scan
 /// intrinsics.
-void genVerifyDescriptor(Fortran::lower::FirOpBuilder &builder,
-                         mlir::Location loc, mlir::Value resultBox,
-                         mlir::Value stringBox, mlir::Value setBox,
-                         mlir::Value backBox, mlir::Value kind);
+void genVerifyDescriptor(fir::FirOpBuilder &builder, mlir::Location loc,
+                         mlir::Value resultBox, mlir::Value stringBox,
+                         mlir::Value setBox, mlir::Value backBox,
+                         mlir::Value kind);
 
 /// Generate call to the verify runtime routine that is specialized on
 /// \param kind.
 /// The \param kind represents the kind of the elements in the strings.
-mlir::Value genVerify(Fortran::lower::FirOpBuilder &builder, mlir::Location loc,
-                      int kind, mlir::Value stringBase, mlir::Value stringLen,
+mlir::Value genVerify(fir::FirOpBuilder &builder, mlir::Location loc, int kind,
+                      mlir::Value stringBase, mlir::Value stringLen,
                       mlir::Value setBase, mlir::Value setLen,
                       mlir::Value back);
 

flang/include/flang/Lower/Coarray.h

@@ -10,7 +10,7 @@
 #define FORTRAN_LOWER_COARRAY_H
 
 #include "flang/Lower/AbstractConverter.h"
-#include "flang/Lower/Support/BoxValue.h"
+#include "flang/Optimizer/Builder/BoxValue.h"
 
 namespace Fortran {
 

flang/include/flang/Lower/ConvertExpr.h

@@ -18,7 +18,7 @@
 #define FORTRAN_LOWER_CONVERTEXPR_H
 
 #include "flang/Evaluate/shape.h"
-#include "flang/Lower/Support/BoxValue.h"
+#include "flang/Optimizer/Builder/BoxValue.h"
 
 namespace mlir {
 class Location;