[flang][NFC] Remove obsolete FIRBuilder and BoxValue

[clementval]

Summary

This patch removes some files made obsolete by newer version
of them available in the Optimizer directory.
flang/include/flang/Lower/FIRBuilder.h and flang/lib/Lower/FIRBuilder.cpp are
removed and replace by the newer version present in
flang/include/flang/Optimizer/Builder/FIRBuilder.h and
flang/lib/Optimizer/Builder/FIRBuilder.cpp.
flang/include/flang/Lower/Support/BoxValue.h and flang/lib/Lower/ConvertExpr.cpp are removed and replace by the newer
version present in flang/include/flang/Optimizer/Builder/BoxValue.h

This patch is a preparation to be able to upstream the lowering from
fir-dev.

[kiranchandramohan]

LGTM. Looks like an NFC change to me.

[kiranchandramohan]

Can changes to OpenMP.cpp, OpenACC.cpp and Coarray.cpp also be included in this change?

[kiranchandramohan]

In D118404#3278631, @kiranchandramohan wrote:

Can changes to OpenMP.cpp, OpenACC.cpp and Coarray.cpp also be included in this change?

Sorry, my bad, I realise that the changes there are only clang-format changes.

[clementval]

In D118404#3278626, @kiranchandramohan wrote:

LGTM. Looks like an NFC change to me.

Yes it is. I'll add NFC in the commit message. Thanks for the review!

[jeanPerier]

LGTM

flang/include/flang/Lower/AbstractConverter.h

 //===-- Lower/AbstractConverter.h -------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef FORTRAN_LOWER_ABSTRACTCONVERTER_H
 #define FORTRAN_LOWER_ABSTRACTCONVERTER_H
 
 #include "flang/Common/Fortran.h"
 #include "mlir/IR/BuiltinOps.h"
 
+namespace fir {
+class KindMapping;
+class FirOpBuilder;
+} // namespace fir
+
 namespace Fortran {
 namespace common {
 template <typename>
 class Reference;
 }
 namespace evaluate {
 struct DataRef;
 template <typename>

 
 namespace lower {
 namespace pft {
 struct Variable;
 }
 
 using SomeExpr = Fortran::evaluate::Expr<Fortran::evaluate::SomeType>;
 using SymbolRef = Fortran::common::Reference<const Fortran::semantics::Symbol>;
-class FirOpBuilder;
 
 //===----------------------------------------------------------------------===//
 // AbstractConverter interface
 //===----------------------------------------------------------------------===//
 
 /// The abstract interface for converter implementations to lower Fortran
 /// front-end fragments such as expressions, types, etc. to the FIR dialect of
 /// MLIR.
public:
   /// Generate the location as converted from a CharBlock
   virtual mlir::Location genLocation(const Fortran::parser::CharBlock &) = 0;
 
   //===--------------------------------------------------------------------===//
   // FIR/MLIR
   //===--------------------------------------------------------------------===//
 
   /// Get the OpBuilder
-  virtual Fortran::lower::FirOpBuilder &getFirOpBuilder() = 0;
+  virtual fir::FirOpBuilder &getFirOpBuilder() = 0;
   /// Get the ModuleOp
   virtual mlir::ModuleOp &getModuleOp() = 0;
   /// Get the MLIRContext
   virtual mlir::MLIRContext &getMLIRContext() = 0;
   /// Unique a symbol
   virtual std::string mangleName(const Fortran::semantics::Symbol &) = 0;
   /// Unique a compiler generated identifier. A short prefix should be provided
   /// to hint at the origin of the identifier.

flang/include/flang/Lower/Bridge.h

 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef FORTRAN_LOWER_BRIDGE_H
 #define FORTRAN_LOWER_BRIDGE_H
 
 #include "flang/Common/Fortran.h"
 #include "flang/Lower/AbstractConverter.h"
+#include "flang/Optimizer/Builder/FIRBuilder.h"
 #include "flang/Optimizer/Support/KindMapping.h"
 #include "mlir/IR/BuiltinOps.h"
 
 namespace Fortran {
 namespace common {
 class IntrinsicTypeDefaultKinds;
 } // namespace common
 namespace evaluate {

flang/include/flang/Lower/CharacterExpr.h

 //===-- Lower/CharacterExpr.h -- lowering of characters ---------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef FORTRAN_LOWER_CHARACTEREXPR_H
 #define FORTRAN_LOWER_CHARACTEREXPR_H
 
-#include "flang/Lower/FIRBuilder.h"
-#include "flang/Lower/Support/BoxValue.h"
+#include "flang/Optimizer/Builder/BoxValue.h"
+#include "flang/Optimizer/Builder/FIRBuilder.h"
 
 namespace Fortran::lower {
 
 /// Helper to facilitate lowering of CHARACTER in FIR.
 class CharacterExprHelper {
 public:
   /// Constructor.
-  explicit CharacterExprHelper(FirOpBuilder &builder, mlir::Location loc)
+  explicit CharacterExprHelper(fir::FirOpBuilder &builder, mlir::Location loc)
       : builder{builder}, loc{loc} {}
   CharacterExprHelper(const CharacterExprHelper &) = delete;
 
   /// Unless otherwise stated, all mlir::Value inputs of these pseudo-fir ops
   /// must be of type:
   /// - fir.boxchar<kind> (dynamic length character),
   /// - fir.ref<fir.array<len x fir.char<kind>>> (character with compile time
   ///      constant length),
fir::CharBoxValue createConcatenate(const fir::CharBoxValue &lhs,
                                       const fir::CharBoxValue &rhs);
   fir::CharBoxValue createSubstring(const fir::CharBoxValue &str,
                                     llvm::ArrayRef<mlir::Value> bounds);
   mlir::Value createLenTrim(const fir::CharBoxValue &str);
   mlir::Value createTemp(mlir::Type type, int len);
   mlir::Value createBlankConstantCode(fir::CharacterType type);
 
 private:
-  FirOpBuilder &builder;
+  fir::FirOpBuilder &builder;
   mlir::Location loc;
 };
 
 } // namespace Fortran::lower
 
 #endif // FORTRAN_LOWER_CHARACTEREXPR_H

flang/include/flang/Lower/Coarray.h

 //===-- Lower/Coarray.h -- image related lowering ---------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef FORTRAN_LOWER_COARRAY_H
 #define FORTRAN_LOWER_COARRAY_H
 
 #include "flang/Lower/AbstractConverter.h"
-#include "flang/Lower/Support/BoxValue.h"
+#include "flang/Optimizer/Builder/BoxValue.h"
 
 namespace Fortran {
 
 namespace parser {
 struct ChangeTeamConstruct;
 struct ChangeTeamStmt;
 struct EndChangeTeamStmt;
 struct FormTeamStmt;

flang/include/flang/Lower/ComplexExpr.h

 //===-- Lower/ComplexExpr.h -- lowering of complex values -------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef FORTRAN_LOWER_COMPLEXEXPR_H
 #define FORTRAN_LOWER_COMPLEXEXPR_H
 
-#include "flang/Lower/FIRBuilder.h"
+#include "flang/Optimizer/Builder/FIRBuilder.h"
 
 namespace Fortran::lower {
 
 /// Helper to facilitate lowering of COMPLEX manipulations in FIR.
 class ComplexExprHelper {
 public:
-  explicit ComplexExprHelper(FirOpBuilder &builder, mlir::Location loc)
+  explicit ComplexExprHelper(fir::FirOpBuilder &builder, mlir::Location loc)
       : builder(builder), loc(loc) {}
   ComplexExprHelper(const ComplexExprHelper &) = delete;
 
   // The values of part enum members are meaningful for
   // InsertValueOp and ExtractValueOp so they are explicit.
   enum class Part { Real = 0, Imag = 1 };
 
   /// Type helper. Determine the type. Do not create MLIR operations.
protected:
 
   template <Part partId>
   mlir::Value createPartId() {
     return builder.createIntegerConstant(loc, builder.getIndexType(),
                                          static_cast<int>(partId));
   }
 
 private:
-  FirOpBuilder &builder;
+  fir::FirOpBuilder &builder;
   mlir::Location loc;
 };
 
 } // namespace Fortran::lower
 
 #endif // FORTRAN_LOWER_COMPLEXEXPR_H

flang/include/flang/Lower/DoLoopHelper.h

 //===-- Lower/DoLoopHelper.h -- gen fir.do_loop ops -------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef FORTRAN_LOWER_DOLOOPHELPER_H
 #define FORTRAN_LOWER_DOLOOPHELPER_H
 
-#include "flang/Lower/FIRBuilder.h"
+#include "flang/Optimizer/Builder/FIRBuilder.h"
 
 namespace Fortran::lower {
 
 /// Helper to build fir.do_loop Ops.
 class DoLoopHelper {
 public:
-  explicit DoLoopHelper(FirOpBuilder &builder, mlir::Location loc)
+  explicit DoLoopHelper(fir::FirOpBuilder &builder, mlir::Location loc)
       : builder(builder), loc(loc) {}
   DoLoopHelper(const DoLoopHelper &) = delete;
 
   /// Type of a callback to generate the loop body.
-  using BodyGenerator = std::function<void(FirOpBuilder &, mlir::Value)>;
+  using BodyGenerator = std::function<void(fir::FirOpBuilder &, mlir::Value)>;
 
   /// Build loop [\p lb, \p ub] with step \p step.
   /// If \p step is an empty value, 1 is used for the step.
   void createLoop(mlir::Value lb, mlir::Value ub, mlir::Value step,
                   const BodyGenerator &bodyGenerator);
 
   /// Build loop [\p lb,  \p ub] with step 1.
   void createLoop(mlir::Value lb, mlir::Value ub,
                   const BodyGenerator &bodyGenerator);
 
   /// Build loop [0, \p count) with step 1.
   void createLoop(mlir::Value count, const BodyGenerator &bodyGenerator);
 
 private:
-  FirOpBuilder &builder;
+  fir::FirOpBuilder &builder;
   mlir::Location loc;
 };
 
 } // namespace Fortran::lower
 
 #endif // FORTRAN_LOWER_DOLOOPHELPER_H

flang/include/flang/Lower/FIRBuilder.h

-//===-- Lower/FirBuilder.h -- FIR operation builder -------------*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-//
-// Builder routines for constructing the FIR dialect of MLIR. As FIR is a
-// dialect of MLIR, it makes extensive use of MLIR interfaces and MLIR's coding
-// style (https://mlir.llvm.org/getting_started/DeveloperGuide/) is used in this
-// module.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef FORTRAN_LOWER_FIRBUILDER_H
-#define FORTRAN_LOWER_FIRBUILDER_H
-
-#include "flang/Common/reference.h"
-#include "flang/Optimizer/Dialect/FIROps.h"
-#include "flang/Optimizer/Dialect/FIRType.h"
-#include "flang/Optimizer/Support/KindMapping.h"
-#include "mlir/IR/Builders.h"
-#include "mlir/IR/BuiltinOps.h"
-#include "llvm/ADT/DenseMap.h"
-#include "llvm/ADT/Optional.h"
-
-namespace Fortran::lower {
-class AbstractConverter;
-class BoxValue;
-
-//===----------------------------------------------------------------------===//
-// FirOpBuilder
-//===----------------------------------------------------------------------===//
-
-/// Extends the MLIR OpBuilder to provide methods for building common FIR
-/// patterns.
-class FirOpBuilder : public mlir::OpBuilder {
-public:
-  explicit FirOpBuilder(mlir::Operation *op, const fir::KindMapping &kindMap)
-      : OpBuilder{op}, kindMap{kindMap} {}
-
-  /// Get the current Region of the insertion point.
-  mlir::Region &getRegion() { return *getBlock()->getParent(); }
-
-  /// Get the current Module
-  mlir::ModuleOp getModule() {
-    return getRegion().getParentOfType<mlir::ModuleOp>();
-  }
-
-  /// Get the current Function
-  mlir::FuncOp getFunction() {
-    return getRegion().getParentOfType<mlir::FuncOp>();
-  }
-
-  /// Get a reference to the kind map.
-  const fir::KindMapping &getKindMap() { return kindMap; }
-
-  /// The LHS and RHS are not always in agreement in terms of
-  /// type. In some cases, the disagreement is between COMPLEX and other scalar
-  /// types. In that case, the conversion must insert/extract out of a COMPLEX
-  /// value to have the proper semantics and be strongly typed.
-  mlir::Value convertWithSemantics(mlir::Location loc, mlir::Type toTy,
-                                   mlir::Value val);
-
-  /// Get the entry block of the current Function
-  mlir::Block *getEntryBlock() { return &getFunction().front(); }
-
-  /// Safely create a reference type to the type `eleTy`.
-  mlir::Type getRefType(mlir::Type eleTy);
-
-  /// Create a null constant of type RefType and value 0. Need to pass in the
-  /// Location information.
-  mlir::Value createNullConstant(mlir::Location loc);
-
-  /// Create an integer constant of type \p type and value \p i.
-  mlir::Value createIntegerConstant(mlir::Location loc, mlir::Type integerType,
-                                    std::int64_t i);
-
-  mlir::Value createRealConstant(mlir::Location loc, mlir::Type realType,
-                                 const llvm::APFloat &val);
-  /// Create a real constant of type \p realType with a value zero.
-  mlir::Value createRealZeroConstant(mlir::Location loc, mlir::Type realType);
-
-  /// Create a slot for a local on the stack. Besides the variable's type and
-  /// shape, it may be given name or target attributes.
-  mlir::Value allocateLocal(mlir::Location loc, mlir::Type ty,
-                            llvm::StringRef nm,
-                            llvm::ArrayRef<mlir::Value> shape,
-                            bool asTarget = false);
-
-  /// Create a temporary. A temp is allocated using `fir.alloca` and can be read
-  /// and written using `fir.load` and `fir.store`, resp.  The temporary can be
-  /// given a name via a front-end `Symbol` or a `StringRef`.
-  mlir::Value createTemporary(mlir::Location loc, mlir::Type type,
-                              llvm::StringRef name = {},
-                              llvm::ArrayRef<mlir::Value> shape = {});
-
-  /// Create an unnamed and untracked temporary on the stack.
-  mlir::Value createTemporary(mlir::Location loc, mlir::Type type,
-                              llvm::ArrayRef<mlir::Value> shape) {
-    return createTemporary(loc, type, llvm::StringRef{}, shape);
-  }
-
-  /// Create a global value.
-  fir::GlobalOp createGlobal(mlir::Location loc, mlir::Type type,
-                             llvm::StringRef name,
-                             mlir::StringAttr linkage = {},
-                             mlir::Attribute value = {}, bool isConst = false);
-
-  fir::GlobalOp createGlobal(mlir::Location loc, mlir::Type type,
-                             llvm::StringRef name, bool isConst,
-                             std::function<void(FirOpBuilder &)> bodyBuilder,
-                             mlir::StringAttr linkage = {});
-
-  /// Create a global constant (read-only) value.
-  fir::GlobalOp createGlobalConstant(mlir::Location loc, mlir::Type type,
-                                     llvm::StringRef name,
-                                     mlir::StringAttr linkage = {},
-                                     mlir::Attribute value = {}) {
-    return createGlobal(loc, type, name, linkage, value, /*isConst=*/true);
-  }
-
-  fir::GlobalOp
-  createGlobalConstant(mlir::Location loc, mlir::Type type,
-                       llvm::StringRef name,
-                       std::function<void(FirOpBuilder &)> bodyBuilder,
-                       mlir::StringAttr linkage = {}) {
-    return createGlobal(loc, type, name, /*isConst=*/true, bodyBuilder,
-                        linkage);
-  }
-
-  /// Convert a StringRef string into a fir::StringLitOp.
-  fir::StringLitOp createStringLit(mlir::Location loc, mlir::Type eleTy,
-                                   llvm::StringRef string);
-
-  /// Get a function by name. If the function exists in the current module, it
-  /// is returned. Otherwise, a null FuncOp is returned.
-  mlir::FuncOp getNamedFunction(llvm::StringRef name) {
-    return getNamedFunction(getModule(), name);
-  }
-
-  static mlir::FuncOp getNamedFunction(mlir::ModuleOp module,
-                                       llvm::StringRef name);
-
-  fir::GlobalOp getNamedGlobal(llvm::StringRef name) {
-    return getNamedGlobal(getModule(), name);
-  }
-
-  static fir::GlobalOp getNamedGlobal(mlir::ModuleOp module,
-                                      llvm::StringRef name);
-
-  /// Lazy creation of fir.convert op.
-  mlir::Value createConvert(mlir::Location loc, mlir::Type toTy,
-                            mlir::Value val);
-
-  /// Create a new FuncOp. If the function may have already been created, use
-  /// `addNamedFunction` instead.
-  mlir::FuncOp createFunction(mlir::Location loc, llvm::StringRef name,
-                              mlir::FunctionType ty) {
-    return createFunction(loc, getModule(), name, ty);
-  }
-
-  static mlir::FuncOp createFunction(mlir::Location loc, mlir::ModuleOp module,
-                                     llvm::StringRef name,
-                                     mlir::FunctionType ty);
-
-  /// Determine if the named function is already in the module. Return the
-  /// instance if found, otherwise add a new named function to the module.
-  mlir::FuncOp addNamedFunction(mlir::Location loc, llvm::StringRef name,
-                                mlir::FunctionType ty) {
-    if (auto func = getNamedFunction(name))
-      return func;
-    return createFunction(loc, name, ty);
-  }
-
-  static mlir::FuncOp addNamedFunction(mlir::Location loc,
-                                       mlir::ModuleOp module,
-                                       llvm::StringRef name,
-                                       mlir::FunctionType ty) {
-    if (auto func = getNamedFunction(module, name))
-      return func;
-    return createFunction(loc, module, name, ty);
-  }
-
-  /// Cast the input value to IndexType.
-  mlir::Value convertToIndexType(mlir::Location loc, mlir::Value val) {
-    return createConvert(loc, getIndexType(), val);
-  }
-
-private:
-  const fir::KindMapping &kindMap;
-};
-
-} // namespace Fortran::lower
-
-#endif // FORTRAN_LOWER_FIRBUILDER_H

flang/include/flang/Lower/IntrinsicCall.h

 //===-- Lower/IntrinsicCall.h -- lowering of intrinsics ---------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef FORTRAN_LOWER_INTRINSICCALL_H
 #define FORTRAN_LOWER_INTRINSICCALL_H
 
-#include "flang/Lower/FIRBuilder.h"
+#include "flang/Optimizer/Builder/FIRBuilder.h"
 
 namespace fir {
 class ExtendedValue;
 }
 
 namespace Fortran::lower {
 
 // TODO: Expose interface to get specific intrinsic function address.
 // TODO: Handle intrinsic subroutine.
 // TODO: Intrinsics that do not require their arguments to be defined
 //   (e.g shape inquiries) might not fit in the current interface that
 //   requires mlir::Value to be provided.
 // TODO: Error handling interface ?
 // TODO: Implementation is incomplete. Many intrinsics to tbd.
 
 /// Helper for building calls to intrinsic functions in the runtime support
 /// libraries.
 
 /// Generate the FIR+MLIR operations for the generic intrinsic \p name
 /// with arguments \p args and expected result type \p resultType.
 /// Returned mlir::Value is the returned Fortran intrinsic value.
-fir::ExtendedValue genIntrinsicCall(FirOpBuilder &, mlir::Location,
+fir::ExtendedValue genIntrinsicCall(fir::FirOpBuilder &, mlir::Location,
                                     llvm::StringRef name, mlir::Type resultType,
                                     llvm::ArrayRef<fir::ExtendedValue> args);
 
 /// Get SymbolRefAttr of runtime (or wrapper function containing inlined
 // implementation) of an unrestricted intrinsic (defined by its signature
 // and generic name)
 mlir::SymbolRefAttr
-getUnrestrictedIntrinsicSymbolRefAttr(FirOpBuilder &, mlir::Location,
+getUnrestrictedIntrinsicSymbolRefAttr(fir::FirOpBuilder &, mlir::Location,
                                       llvm::StringRef name,
                                       mlir::FunctionType signature);
 
 //===--------------------------------------------------------------------===//
 // Direct access to intrinsics that may be used by lowering outside
 // of intrinsic call lowering.
 //===--------------------------------------------------------------------===//
 
 /// Generate maximum. There must be at least one argument and all arguments
 /// must have the same type.
-mlir::Value genMax(FirOpBuilder &, mlir::Location,
+mlir::Value genMax(fir::FirOpBuilder &, mlir::Location,
                    llvm::ArrayRef<mlir::Value> args);
 
 /// Generate minimum. Same constraints as genMax.
-mlir::Value genMin(FirOpBuilder &, mlir::Location,
+mlir::Value genMin(fir::FirOpBuilder &, mlir::Location,
                    llvm::ArrayRef<mlir::Value> args);
 
 /// Generate power function x**y with given the expected
 /// result type.
-mlir::Value genPow(FirOpBuilder &, mlir::Location, mlir::Type resultType,
+mlir::Value genPow(fir::FirOpBuilder &, mlir::Location, mlir::Type resultType,
                    mlir::Value x, mlir::Value y);
 
 } // namespace Fortran::lower
 
 #endif // FORTRAN_LOWER_INTRINSICCALL_H

flang/include/flang/Lower/Support/BoxValue.h

-//===-- Lower/Support/BoxValue.h -- internal box values ---------*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LOWER_SUPPORT_BOXVALUE_H
-#define LOWER_SUPPORT_BOXVALUE_H
-
-#include "mlir/IR/Value.h"
-#include "llvm/ADT/SmallVector.h"
-#include "llvm/Support/Compiler.h"
-#include "llvm/Support/raw_ostream.h"
-#include <utility>
-#include <variant>
-
-namespace fir {
-class CharBoxValue;
-class ArrayBoxValue;
-class CharArrayBoxValue;
-class BoxValue;
-class ProcBoxValue;
-
-llvm::raw_ostream &operator<<(llvm::raw_ostream &, const CharBoxValue &);
-llvm::raw_ostream &operator<<(llvm::raw_ostream &, const ArrayBoxValue &);
-llvm::raw_ostream &operator<<(llvm::raw_ostream &, const CharArrayBoxValue &);
-llvm::raw_ostream &operator<<(llvm::raw_ostream &, const BoxValue &);
-llvm::raw_ostream &operator<<(llvm::raw_ostream &, const ProcBoxValue &);
-
-//===----------------------------------------------------------------------===//
-//
-// Boxed values
-//
-// Define a set of containers used internally by the lowering bridge to keep
-// track of extended values associated with a Fortran subexpression. These
-// associations are maintained during the construction of FIR.
-//
-//===----------------------------------------------------------------------===//
-
-/// Most expressions of intrinsic type can be passed unboxed. Their properties
-/// are known statically.
-using UnboxedValue = mlir::Value;
-
-/// Abstract base class.
-class AbstractBox {
-public:
-  AbstractBox() = delete;
-  AbstractBox(mlir::Value addr) : addr{addr} {}
-  mlir::Value getAddr() const { return addr; }
-
-protected:
-  mlir::Value addr;
-};
-
-/// Expressions of CHARACTER type have an associated, possibly dynamic LEN
-/// value.
-class CharBoxValue : public AbstractBox {
-public:
-  CharBoxValue(mlir::Value addr, mlir::Value len)
-      : AbstractBox{addr}, len{len} {}
-
-  CharBoxValue clone(mlir::Value newBase) const { return {newBase, len}; }
-
-  mlir::Value getLen() const { return len; }
-  mlir::Value getBuffer() const { return getAddr(); }
-
-  friend llvm::raw_ostream &operator<<(llvm::raw_ostream &,
-                                       const CharBoxValue &);
-  LLVM_DUMP_METHOD void dump() const { llvm::errs() << *this; }
-
-protected:
-  mlir::Value len;
-};
-
-/// Abstract base class.
-/// Expressions of type array have at minimum a shape. These expressions may
-/// have lbound attributes (dynamic values) that affect the interpretation of
-/// indexing expressions.
-class AbstractArrayBox {
-public:
-  AbstractArrayBox() = default;
-  AbstractArrayBox(llvm::ArrayRef<mlir::Value> extents,
-                   llvm::ArrayRef<mlir::Value> lbounds)
-      : extents{extents.begin(), extents.end()}, lbounds{lbounds.begin(),
-                                                         lbounds.end()} {}
-
-  // Every array has extents that describe its shape.
-  const llvm::SmallVectorImpl<mlir::Value> &getExtents() const {
-    return extents;
-  }
-
-  // An array expression may have user-defined lower bound values.
-  // If this vector is empty, the default in all dimensions in `1`.
-  const llvm::SmallVectorImpl<mlir::Value> &getLBounds() const {
-    return lbounds;
-  }
-
-  bool lboundsAllOne() const { return lbounds.empty(); }
-
-protected:
-  llvm::SmallVector<mlir::Value, 4> extents;
-  llvm::SmallVector<mlir::Value, 4> lbounds;
-};
-
-/// Expressions with rank > 0 have extents. They may also have lbounds that are
-/// not 1.
-class ArrayBoxValue : public AbstractBox, public AbstractArrayBox {
-public:
-  ArrayBoxValue(mlir::Value addr, llvm::ArrayRef<mlir::Value> extents,
-                llvm::ArrayRef<mlir::Value> lbounds = {})
-      : AbstractBox{addr}, AbstractArrayBox{extents, lbounds} {}
-
-  ArrayBoxValue clone(mlir::Value newBase) const {
-    return {newBase, extents, lbounds};
-  }
-
-  friend llvm::raw_ostream &operator<<(llvm::raw_ostream &,
-                                       const ArrayBoxValue &);
-  LLVM_DUMP_METHOD void dump() const { operator<<(llvm::errs(), *this); }
-};
-
-/// Expressions of type CHARACTER and with rank > 0.
-class CharArrayBoxValue : public CharBoxValue, public AbstractArrayBox {
-public:
-  CharArrayBoxValue(mlir::Value addr, mlir::Value len,
-                    llvm::ArrayRef<mlir::Value> extents,
-                    llvm::ArrayRef<mlir::Value> lbounds = {})
-      : CharBoxValue{addr, len}, AbstractArrayBox{extents, lbounds} {}
-
-  CharArrayBoxValue clone(mlir::Value newBase) const {
-    return {newBase, len, extents, lbounds};
-  }
-
-  friend llvm::raw_ostream &operator<<(llvm::raw_ostream &,
-                                       const CharArrayBoxValue &);
-  LLVM_DUMP_METHOD void dump() const { operator<<(llvm::errs(), *this); }
-};
-
-/// Expressions that are procedure POINTERs may need a set of references to
-/// variables in the host scope.
-class ProcBoxValue : public AbstractBox {
-public:
-  ProcBoxValue(mlir::Value addr, mlir::Value context)
-      : AbstractBox{addr}, hostContext{context} {}
-
-  ProcBoxValue clone(mlir::Value newBase) const {
-    return {newBase, hostContext};
-  }
-
-  mlir::Value getHostContext() const { return hostContext; }
-
-  friend llvm::raw_ostream &operator<<(llvm::raw_ostream &,
-                                       const ProcBoxValue &);
-  LLVM_DUMP_METHOD void dump() const { operator<<(llvm::errs(), *this); }
-
-protected:
-  mlir::Value hostContext;
-};
-
-/// In the generalized form, a boxed value can have a dynamic size, be an array
-/// with dynamic extents and lbounds, and take dynamic type parameters.
-class BoxValue : public AbstractBox, public AbstractArrayBox {
-public:
-  BoxValue(mlir::Value addr) : AbstractBox{addr}, AbstractArrayBox{} {}
-  BoxValue(mlir::Value addr, mlir::Value len)
-      : AbstractBox{addr}, AbstractArrayBox{}, len{len} {}
-  BoxValue(mlir::Value addr, llvm::ArrayRef<mlir::Value> extents,
-           llvm::ArrayRef<mlir::Value> lbounds = {})
-      : AbstractBox{addr}, AbstractArrayBox{extents, lbounds} {}
-  BoxValue(mlir::Value addr, mlir::Value len,
-           llvm::ArrayRef<mlir::Value> params,
-           llvm::ArrayRef<mlir::Value> extents,
-           llvm::ArrayRef<mlir::Value> lbounds = {})
-      : AbstractBox{addr}, AbstractArrayBox{extents, lbounds}, len{len},
-        params{params.begin(), params.end()} {}
-
-  BoxValue clone(mlir::Value newBase) const {
-    return {newBase, len, params, extents, lbounds};
-  }
-
-  mlir::Value getLen() const { return len; }
-  const llvm::SmallVectorImpl<mlir::Value> &getLenTypeParams() const {
-    return params;
-  }
-
-  friend llvm::raw_ostream &operator<<(llvm::raw_ostream &, const BoxValue &);
-  LLVM_DUMP_METHOD void dump() const { operator<<(llvm::errs(), *this); }
-
-protected:
-  mlir::Value len;
-  llvm::SmallVector<mlir::Value, 2> params;
-};
-
-/// Used for triple notation (array slices)
-using RangeBoxValue = std::tuple<mlir::Value, mlir::Value, mlir::Value>;
-
-class ExtendedValue;
-
-mlir::Value getBase(const ExtendedValue &exv);
-llvm::raw_ostream &operator<<(llvm::raw_ostream &, const ExtendedValue &);
-ExtendedValue substBase(const ExtendedValue &exv, mlir::Value base);
-
-/// An extended value is a box of values pertaining to a discrete entity. It is
-/// used in lowering to track all the runtime values related to an entity. For
-/// example, an entity may have an address in memory that contains its value(s)
-/// as well as various attribute values that describe the shape and starting
-/// indices if it is an array entity.
-class ExtendedValue {
-public:
-  template <typename A>
-  constexpr ExtendedValue(A &&box) : box{std::forward<A>(box)} {}
-
-  constexpr const CharBoxValue *getCharBox() const {
-    return std::get_if<CharBoxValue>(&box);
-  }
-
-  constexpr const UnboxedValue *getUnboxed() const {
-    return std::get_if<UnboxedValue>(&box);
-  }
-
-  /// LLVM style debugging of extended values
-  LLVM_DUMP_METHOD void dump() const { llvm::errs() << *this << '\n'; }
-
-  friend llvm::raw_ostream &operator<<(llvm::raw_ostream &,
-                                       const ExtendedValue &);
-  friend mlir::Value getBase(const ExtendedValue &exv);
-  friend ExtendedValue substBase(const ExtendedValue &exv, mlir::Value base);
-
-private:
-  std::variant<UnboxedValue, CharBoxValue, ArrayBoxValue, CharArrayBoxValue,
-               BoxValue, ProcBoxValue>
-      box;
-};
-} // namespace fir
-
-#endif // LOWER_SUPPORT_BOXVALUE_H

flang/include/flang/Optimizer/Builder/Character.h

 #include "flang/Optimizer/Builder/FIRBuilder.h"
 
 namespace fir::factory {
 
 /// Helper to facilitate lowering of CHARACTER in FIR.
 class CharacterExprHelper {
 public:
   /// Constructor.
-  explicit CharacterExprHelper(FirOpBuilder &builder, mlir::Location loc)
+  explicit CharacterExprHelper(fir::FirOpBuilder &builder, mlir::Location loc)
       : builder{builder}, loc{loc} {}
   CharacterExprHelper(const CharacterExprHelper &) = delete;
 
   /// Copy the \p count first characters of \p src into \p dest.
   /// \p count can have any integer type.
   void createCopy(const fir::CharBoxValue &dest, const fir::CharBoxValue &src,
                   mlir::Value count);
 

flang/lib/Lower/CMakeLists.txt

 get_property(dialect_libs GLOBAL PROPERTY MLIR_DIALECT_LIBS)
 
 add_flang_library(FortranLower
   CharacterExpr.cpp
   CharacterRuntime.cpp
   Coarray.cpp
   ComplexExpr.cpp
   ConvertType.cpp
-  ConvertExpr.cpp
   DoLoopHelper.cpp
-  FIRBuilder.cpp
   IntrinsicCall.cpp
   IO.cpp
   Mangler.cpp
   OpenACC.cpp
   OpenMP.cpp
   PFTBuilder.cpp
 
   DEPENDS

flang/lib/Lower/CharacterExpr.cpp

auto addr = builder.create<fir::CoordinateOp>(loc, getReferenceType(str),
                                                 str.getBuffer(), index);
   builder.create<fir::StoreOp>(loc, c, addr);
 }
 
 void Fortran::lower::CharacterExprHelper::createCopy(
     const fir::CharBoxValue &dest, const fir::CharBoxValue &src,
     mlir::Value count) {
   Fortran::lower::DoLoopHelper{builder, loc}.createLoop(
-      count, [&](Fortran::lower::FirOpBuilder &, mlir::Value index) {
+      count, [&](fir::FirOpBuilder &, mlir::Value index) {
         auto charVal = createLoadCharAt(src, index);
         createStoreCharAt(dest, index, charVal);
       });
 }
 
 void Fortran::lower::CharacterExprHelper::createPadding(
     const fir::CharBoxValue &str, mlir::Value lower, mlir::Value upper) {
   auto blank = createBlankConstant(getCharacterType(str));
   // Always create the loop, if upper < lower, no iteration will be
   // executed.
   Fortran::lower::DoLoopHelper{builder, loc}.createLoop(
-      lower, upper, [&](Fortran::lower::FirOpBuilder &, mlir::Value index) {
+      lower, upper, [&](fir::FirOpBuilder &, mlir::Value index) {
         createStoreCharAt(str, index, blank);
       });
 }
 
 fir::CharBoxValue
 Fortran::lower::CharacterExprHelper::createTemp(mlir::Type type,
                                                 mlir::Value len) {
   assert(type.isa<fir::CharacterType>() && "expected fir character type");
   llvm::SmallVector<mlir::Value, 3> sizes{len};
-  auto ref = builder.allocateLocal(loc, type, llvm::StringRef{}, sizes);
+  auto ref = builder.allocateLocal(loc, type, "", ".chrtmp",
+                                   /*shape=*/llvm::None, sizes);
   return {ref, len};
 }
 
 // Simple length one character assignment without loops.
 void Fortran::lower::CharacterExprHelper::createLengthOneAssign(
     const fir::CharBoxValue &lhs, const fir::CharBoxValue &rhs) {
   auto addr = lhs.getBuffer();
   auto val = rhs.getBuffer();
fir::CharBoxValue Fortran::lower::CharacterExprHelper::createConcatenate(
   auto temp = createTemp(getCharacterType(rhs), len);
   createCopy(temp, lhs, lhs.getLen());
   auto one = builder.createIntegerConstant(loc, len.getType(), 1);
   auto upperBound = builder.create<mlir::arith::SubIOp>(loc, len, one);
   auto lhsLen =
       builder.createConvert(loc, builder.getIndexType(), lhs.getLen());
   Fortran::lower::DoLoopHelper{builder, loc}.createLoop(
       lhs.getLen(), upperBound, one,
-      [&](Fortran::lower::FirOpBuilder &bldr, mlir::Value index) {
+      [&](fir::FirOpBuilder &bldr, mlir::Value index) {
         auto rhsIndex = bldr.create<mlir::arith::SubIOp>(loc, index, lhsLen);
         auto charVal = createLoadCharAt(rhs, rhsIndex);
         createStoreCharAt(temp, index, charVal);
       });
   return temp;
 }
 
 fir::CharBoxValue Fortran::lower::CharacterExprHelper::createSubstring(

flang/lib/Lower/CharacterRuntime.cpp

 //===-- CharacterRuntime.cpp -- runtime for CHARACTER type entities -------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "flang/Lower/CharacterRuntime.h"
 #include "RTBuilder.h"
 #include "flang/Lower/Bridge.h"
 #include "flang/Lower/CharacterExpr.h"
-#include "flang/Lower/FIRBuilder.h"
+#include "flang/Optimizer/Builder/FIRBuilder.h"
 #include "flang/Runtime/character.h"
 #include "mlir/Dialect/StandardOps/IR/Ops.h"
 
 using namespace Fortran::runtime;
 
 #define NAMIFY_HELPER(X) #X
 #define NAMIFY(X) NAMIFY_HELPER(IONAME(X))
 #define mkRTKey(X) mkKey(RTNAME(X))

 
 inline int64_t getLength(mlir::Type argTy) {
   return argTy.cast<fir::SequenceType>().getShape()[0];
 }
 
 /// Get (or generate) the MLIR FuncOp for a given runtime function.
 template <typename E>
 static mlir::FuncOp getRuntimeFunc(mlir::Location loc,
-                                   Fortran::lower::FirOpBuilder &builder) {
+                                   fir::FirOpBuilder &builder) {
   auto name = getName<E>();
   auto func = builder.getNamedFunction(name);
   if (func)
     return func;
   auto funTy = getTypeModel<E>()(builder.getContext());
   func = builder.createFunction(loc, name, funTy);
   func->setAttr("fir.runtime", builder.getUnitAttr());
   return func;

flang/lib/Lower/Coarray.cpp

 //===-- Coarray.cpp -------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 ///
 /// Implementation of the lowering of image related constructs and expressions.
 /// Fortran images can form teams, communicate via coarrays, etc.
 ///
 //===----------------------------------------------------------------------===//
 
 #include "flang/Lower/Coarray.h"
 #include "SymbolMap.h"
 #include "flang/Lower/AbstractConverter.h"
-#include "flang/Lower/FIRBuilder.h"
+#include "flang/Optimizer/Builder/FIRBuilder.h"
 #include "flang/Parser/parse-tree.h"
 #include "flang/Semantics/expression.h"
 
 #undef TODO
 #define TODO(MSG)                                                              \
   {                                                                            \
     mlir::emitError(converter.getCurrentLocation(), "not yet implemented")     \
         << MSG;                                                                \

flang/lib/Lower/ConvertExpr.cpp

-//===-- ConvertExpr.cpp ---------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#include "flang/Common/idioms.h"
-#include "flang/Lower/IntrinsicCall.h"
-#include "flang/Lower/Support/BoxValue.h"
-
-mlir::Value fir::getBase(const fir::ExtendedValue &ex) {
-  return std::visit(Fortran::common::visitors{
-                        [](const fir::UnboxedValue &x) { return x; },
-                        [](const auto &x) { return x.getAddr(); },
-                    },
-                    ex.box);
-}
-
-llvm::raw_ostream &fir::operator<<(llvm::raw_ostream &os,
-                                   const fir::CharBoxValue &box) {
-  os << "boxchar { addr: " << box.getAddr() << ", len: " << box.getLen()
-     << " }";
-  return os;
-}
-
-llvm::raw_ostream &fir::operator<<(llvm::raw_ostream &os,
-                                   const fir::ArrayBoxValue &box) {
-  os << "boxarray { addr: " << box.getAddr();
-  if (box.getLBounds().size()) {
-    os << ", lbounds: [";
-    llvm::interleaveComma(box.getLBounds(), os);
-    os << "]";
-  } else {
-    os << ", lbounds: all-ones";
-  }
-  os << ", shape: [";
-  llvm::interleaveComma(box.getExtents(), os);
-  os << "]}";
-  return os;
-}
-
-llvm::raw_ostream &fir::operator<<(llvm::raw_ostream &os,
-                                   const fir::CharArrayBoxValue &box) {
-  os << "boxchararray { addr: " << box.getAddr() << ", len : " << box.getLen();
-  if (box.getLBounds().size()) {
-    os << ", lbounds: [";
-    llvm::interleaveComma(box.getLBounds(), os);
-    os << "]";
-  } else {
-    os << " lbounds: all-ones";
-  }
-  os << ", shape: [";
-  llvm::interleaveComma(box.getExtents(), os);
-  os << "]}";
-  return os;
-}
-
-llvm::raw_ostream &fir::operator<<(llvm::raw_ostream &os,
-                                   const fir::BoxValue &box) {
-  os << "box { addr: " << box.getAddr();
-  if (box.getLen())
-    os << ", size: " << box.getLen();
-  if (box.params.size()) {
-    os << ", type params: [";
-    llvm::interleaveComma(box.params, os);
-    os << "]";
-  }
-  if (box.getLBounds().size()) {
-    os << ", lbounds: [";
-    llvm::interleaveComma(box.getLBounds(), os);
-    os << "]";
-  }
-  if (box.getExtents().size()) {
-    os << ", shape: [";
-    llvm::interleaveComma(box.getExtents(), os);
-    os << "]";
-  }
-  os << "}";
-  return os;
-}
-
-llvm::raw_ostream &fir::operator<<(llvm::raw_ostream &os,
-                                   const fir::ProcBoxValue &box) {
-  os << "boxproc: { addr: " << box.getAddr() << ", context: " << box.hostContext
-     << "}";
-  return os;
-}
-
-llvm::raw_ostream &fir::operator<<(llvm::raw_ostream &os,
-                                   const fir::ExtendedValue &ex) {
-  std::visit([&](const auto &value) { os << value; }, ex.box);
-  return os;
-}

flang/lib/Lower/FIRBuilder.cpp

-//===-- FIRBuilder.cpp ----------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#include "flang/Lower/FIRBuilder.h"
-#include "SymbolMap.h"
-#include "flang/Lower/Bridge.h"
-#include "flang/Lower/ComplexExpr.h"
-#include "flang/Lower/ConvertType.h"
-#include "flang/Optimizer/Dialect/FIROpsSupport.h"
-#include "flang/Semantics/symbol.h"
-#include "llvm/Support/ErrorHandling.h"
-
-mlir::FuncOp Fortran::lower::FirOpBuilder::createFunction(
-    mlir::Location loc, mlir::ModuleOp module, llvm::StringRef name,
-    mlir::FunctionType ty) {
-  return fir::createFuncOp(loc, module, name, ty);
-}
-
-mlir::FuncOp
-Fortran::lower::FirOpBuilder::getNamedFunction(mlir::ModuleOp modOp,
-                                               llvm::StringRef name) {
-  return modOp.lookupSymbol<mlir::FuncOp>(name);
-}
-
-fir::GlobalOp
-Fortran::lower::FirOpBuilder::getNamedGlobal(mlir::ModuleOp modOp,
-                                             llvm::StringRef name) {
-  return modOp.lookupSymbol<fir::GlobalOp>(name);
-}
-
-mlir::Type Fortran::lower::FirOpBuilder::getRefType(mlir::Type eleTy) {
-  assert(!eleTy.isa<fir::ReferenceType>());
-  return fir::ReferenceType::get(eleTy);
-}
-
-mlir::Value
-Fortran::lower::FirOpBuilder::createNullConstant(mlir::Location loc) {
-  auto indexType = getIndexType();
-  auto zero = createIntegerConstant(loc, indexType, 0);
-  auto noneRefType = getRefType(getNoneType());
-  return createConvert(loc, noneRefType, zero);
-}
-
-mlir::Value Fortran::lower::FirOpBuilder::createIntegerConstant(
-    mlir::Location loc, mlir::Type ty, std::int64_t cst) {
-  return create<mlir::arith::ConstantOp>(loc, ty, getIntegerAttr(ty, cst));
-}
-
-mlir::Value Fortran::lower::FirOpBuilder::createRealConstant(
-    mlir::Location loc, mlir::Type realType, const llvm::APFloat &val) {
-  return create<mlir::arith::ConstantOp>(loc, realType,
-                                         getFloatAttr(realType, val));
-}
-
-mlir::Value
-Fortran::lower::FirOpBuilder::createRealZeroConstant(mlir::Location loc,
-                                                     mlir::Type realType) {
-  mlir::Attribute attr;
-  if (auto firType = realType.dyn_cast<fir::RealType>()) {
-    attr = getFloatAttr(
-        realType,
-        llvm::APFloat(kindMap.getFloatSemantics(firType.getFKind()), 0));
-  } else { // mlir::FloatType.
-    attr = getZeroAttr(realType);
-  }
-  return create<mlir::arith::ConstantOp>(loc, realType, attr);
-}
-
-mlir::Value Fortran::lower::FirOpBuilder::allocateLocal(
-    mlir::Location loc, mlir::Type ty, llvm::StringRef nm,
-    llvm::ArrayRef<mlir::Value> shape, bool asTarget) {
-  llvm::SmallVector<mlir::Value, 8> indices;
-  auto idxTy = getIndexType();
-  llvm::for_each(shape, [&](mlir::Value sh) {
-    indices.push_back(createConvert(loc, idxTy, sh));
-  });
-  llvm::SmallVector<mlir::NamedAttribute, 2> attrs;
-  if (asTarget)
-    attrs.emplace_back(mlir::StringAttr::get(getContext(), "target"),
-                       getUnitAttr());
-  return create<fir::AllocaOp>(loc, ty, nm, llvm::None, indices, attrs);
-}
-
-/// Create a temporary variable on the stack. Anonymous temporaries have no
-/// `name` value.
-mlir::Value Fortran::lower::FirOpBuilder::createTemporary(
-    mlir::Location loc, mlir::Type type, llvm::StringRef name,
-    llvm::ArrayRef<mlir::Value> shape) {
-  auto insPt = saveInsertionPoint();
-  if (shape.empty())
-    setInsertionPointToStart(getEntryBlock());
-  else
-    setInsertionPointAfter(shape.back().getDefiningOp());
-  assert(!type.isa<fir::ReferenceType>() && "cannot be a reference");
-  auto ae = create<fir::AllocaOp>(loc, type, name, llvm::None, shape);
-  restoreInsertionPoint(insPt);
-  return ae;
-}
-
-/// Create a global variable in the (read-only) data section. A global variable
-/// must have a unique name to identify and reference it.
-fir::GlobalOp Fortran::lower::FirOpBuilder::createGlobal(
-    mlir::Location loc, mlir::Type type, llvm::StringRef name,
-    mlir::StringAttr linkage, mlir::Attribute value, bool isConst) {
-  auto module = getModule();
-  auto insertPt = saveInsertionPoint();
-  if (auto glob = module.lookupSymbol<fir::GlobalOp>(name))
-    return glob;
-  setInsertionPoint(module.getBody()->getTerminator());
-  auto glob = create<fir::GlobalOp>(loc, name, isConst, type, value, linkage);
-  restoreInsertionPoint(insertPt);
-  return glob;
-}
-
-fir::GlobalOp Fortran::lower::FirOpBuilder::createGlobal(
-    mlir::Location loc, mlir::Type type, llvm::StringRef name, bool isConst,
-    std::function<void(FirOpBuilder &)> bodyBuilder, mlir::StringAttr linkage) {
-  auto module = getModule();
-  auto insertPt = saveInsertionPoint();
-  if (auto glob = module.lookupSymbol<fir::GlobalOp>(name))
-    return glob;
-  setInsertionPoint(module.getBody()->getTerminator());
-  auto glob = create<fir::GlobalOp>(loc, name, isConst, type, mlir::Attribute{},
-                                    linkage);
-  auto &region = glob.getRegion();
-  region.push_back(new mlir::Block);
-  auto &block = glob.getRegion().back();
-  setInsertionPointToStart(&block);
-  bodyBuilder(*this);
-  restoreInsertionPoint(insertPt);
-  return glob;
-}
-
-mlir::Value Fortran::lower::FirOpBuilder::convertWithSemantics(
-    mlir::Location loc, mlir::Type toTy, mlir::Value val) {
-  assert(toTy && "store location must be typed");
-  auto fromTy = val.getType();
-  if (fromTy == toTy)
-    return val;
-  // FIXME: add a fir::is_integer() test
-  ComplexExprHelper helper{*this, loc};
-  if ((fir::isa_real(fromTy) || fromTy.isSignlessInteger()) &&
-      fir::isa_complex(toTy)) {
-    // imaginary part is zero
-    auto eleTy = helper.getComplexPartType(toTy);
-    auto cast = createConvert(loc, eleTy, val);
-    llvm::APFloat zero{
-        kindMap.getFloatSemantics(toTy.cast<fir::ComplexType>().getFKind()), 0};
-    auto imag = createRealConstant(loc, eleTy, zero);
-    return helper.createComplex(toTy, cast, imag);
-  }
-  // FIXME: add a fir::is_integer() test
-  if (fir::isa_complex(fromTy) &&
-      (toTy.isSignlessInteger() || fir::isa_real(toTy))) {
-    // drop the imaginary part
-    auto rp = helper.extractComplexPart(val, /*isImagPart=*/false);
-    return createConvert(loc, toTy, rp);
-  }
-  return createConvert(loc, toTy, val);
-}
-
-mlir::Value Fortran::lower::FirOpBuilder::createConvert(mlir::Location loc,
-                                                        mlir::Type toTy,
-                                                        mlir::Value val) {
-  if (val.getType() != toTy)
-    return create<fir::ConvertOp>(loc, toTy, val);
-  return val;
-}
-
-fir::StringLitOp Fortran::lower::FirOpBuilder::createStringLit(
-    mlir::Location loc, mlir::Type eleTy, llvm::StringRef data) {
-  auto strAttr = mlir::StringAttr::get(getContext(), data);
-  auto valTag = mlir::StringAttr::get(getContext(), fir::StringLitOp::value());
-  mlir::NamedAttribute dataAttr(valTag, strAttr);
-  auto sizeTag = mlir::StringAttr::get(getContext(), fir::StringLitOp::size());
-  mlir::NamedAttribute sizeAttr(sizeTag, getI64IntegerAttr(data.size()));
-  llvm::SmallVector<mlir::NamedAttribute, 2> attrs{dataAttr, sizeAttr};
-  auto arrTy =
-      fir::SequenceType::get(fir::SequenceType::Shape(1, data.size()), eleTy);
-  return create<fir::StringLitOp>(loc, llvm::ArrayRef<mlir::Type>{arrTy},
-                                  llvm::None, attrs);
-}

flang/lib/Lower/IO.cpp

 //===-- IO.cpp -- I/O statement lowering ----------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "flang/Lower/IO.h"
 #include "RTBuilder.h"
 #include "flang/Lower/Bridge.h"
 #include "flang/Lower/CharacterExpr.h"
 #include "flang/Lower/ComplexExpr.h"
-#include "flang/Lower/FIRBuilder.h"
 #include "flang/Lower/PFTBuilder.h"
 #include "flang/Lower/Runtime.h"
 #include "flang/Lower/Utils.h"
+#include "flang/Optimizer/Builder/FIRBuilder.h"
 #include "flang/Parser/parse-tree.h"
 #include "flang/Runtime/io-api.h"
 #include "flang/Semantics/tools.h"
 #include "mlir/Dialect/StandardOps/IR/Ops.h"
 
 #define TODO() llvm_unreachable("not yet implemented")
 
 using namespace Fortran::runtime::io;

 
 inline int64_t getLength(mlir::Type argTy) {
   return argTy.cast<fir::SequenceType>().getShape()[0];
 }
 
 /// Get (or generate) the MLIR FuncOp for a given IO runtime function.
 template <typename E>
 static mlir::FuncOp getIORuntimeFunc(mlir::Location loc,
-                                     Fortran::lower::FirOpBuilder &builder) {
+                                     fir::FirOpBuilder &builder) {
   auto name = getName<E>();
   auto func = builder.getNamedFunction(name);
   if (func)
     return func;
   auto funTy = getTypeModel<E>()(builder.getContext());
   func = builder.createFunction(loc, name, funTy);
   func->setAttr("fir.runtime", builder.getUnitAttr());
   func->setAttr("fir.io", builder.getUnitAttr());
static mlir::Value genEndIO(Fortran::lower::AbstractConverter &converter,
   return csi.hasTransferConditionSpecifier() ? call.getResult(0)
                                              : mlir::Value{};
 }
 
 /// Make the next call in the IO statement conditional on runtime result `ok`.
 /// If a call returns `ok==false`, further suboperation calls for an I/O
 /// statement will be skipped.  This may generate branch heavy, deeply nested
 /// conditionals for I/O statements with a large number of suboperations.
-static void makeNextConditionalOn(Fortran::lower::FirOpBuilder &builder,
+static void makeNextConditionalOn(fir::FirOpBuilder &builder,
                                   mlir::Location loc,
                                   mlir::OpBuilder::InsertPoint &insertPt,
                                   bool checkResult, mlir::Value ok,
                                   bool inIterWhileLoop = false) {
   if (!checkResult || !ok)
     // Either I/O calls do not need to be checked, or the next I/O call is the
     // first potentially fallable call.
     return;

 
 template <typename D>
 static void genIoLoop(Fortran::lower::AbstractConverter &converter,
                       mlir::Value cookie, const D &ioImpliedDo,
                       bool checkResult, mlir::Value &ok, bool inIterWhileLoop);
 
 /// Get the OutputXyz routine to output a value of the given type.
 static mlir::FuncOp getOutputFunc(mlir::Location loc,
-                                  Fortran::lower::FirOpBuilder &builder,
-                                  mlir::Type type) {
+                                  fir::FirOpBuilder &builder, mlir::Type type) {
   if (auto ty = type.dyn_cast<mlir::IntegerType>())
     return ty.getWidth() == 1
                ? getIORuntimeFunc<mkIOKey(OutputLogical)>(loc, builder)
                : getIORuntimeFunc<mkIOKey(OutputInteger64)>(loc, builder);
   if (auto ty = type.dyn_cast<mlir::FloatType>())
     return ty.getWidth() <= 32
                ? getIORuntimeFunc<mkIOKey(OutputReal32)>(loc, builder)
                : getIORuntimeFunc<mkIOKey(OutputReal64)>(loc, builder);
if (helper.isCharacter(itemType)) {
       outputFuncArgs.push_back(itemValue);
     }
     ok = builder.create<mlir::CallOp>(loc, outputFunc, outputFuncArgs)
              .getResult(0);
   }
 }
 
 /// Get the InputXyz routine to input a value of the given type.
-static mlir::FuncOp getInputFunc(mlir::Location loc,
-                                 Fortran::lower::FirOpBuilder &builder,
+static mlir::FuncOp getInputFunc(mlir::Location loc, fir::FirOpBuilder &builder,
                                  mlir::Type type) {
   if (auto ty = type.dyn_cast<mlir::IntegerType>())
     return ty.getWidth() == 1
                ? getIORuntimeFunc<mkIOKey(InputLogical)>(loc, builder)
                : getIORuntimeFunc<mkIOKey(InputInteger)>(loc, builder);
   if (auto ty = type.dyn_cast<mlir::FloatType>())
     return ty.getWidth() <= 32
                ? getIORuntimeFunc<mkIOKey(InputReal32)>(loc, builder)
static void genIoLoop(Fortran::lower::AbstractConverter &converter,
   ok = iterWhileOp.getResult(0);
   builder.restoreInsertionPoint(parentInsertPt);
 }
 
 //===----------------------------------------------------------------------===//
 // Default argument generation.
 //===----------------------------------------------------------------------===//
 
-static mlir::Value getDefaultFilename(Fortran::lower::FirOpBuilder &builder,
+static mlir::Value getDefaultFilename(fir::FirOpBuilder &builder,
                                       mlir::Location loc, mlir::Type toType) {
   mlir::Value null = builder.create<mlir::arith::ConstantOp>(
       loc, builder.getI64IntegerAttr(0));
   return builder.createConvert(loc, toType, null);
 }
 
-static mlir::Value getDefaultLineNo(Fortran::lower::FirOpBuilder &builder,
+static mlir::Value getDefaultLineNo(fir::FirOpBuilder &builder,
                                     mlir::Location loc, mlir::Type toType) {
   return builder.create<mlir::arith::ConstantOp>(
       loc, builder.getIntegerAttr(toType, 0));
 }
 
-static mlir::Value getDefaultScratch(Fortran::lower::FirOpBuilder &builder,
+static mlir::Value getDefaultScratch(fir::FirOpBuilder &builder,
                                      mlir::Location loc, mlir::Type toType) {
   mlir::Value null = builder.create<mlir::arith::ConstantOp>(
       loc, builder.getI64IntegerAttr(0));
   return builder.createConvert(loc, toType, null);
 }
 
-static mlir::Value getDefaultScratchLen(Fortran::lower::FirOpBuilder &builder,
+static mlir::Value getDefaultScratchLen(fir::FirOpBuilder &builder,
                                         mlir::Location loc, mlir::Type toType) {
   return builder.create<mlir::arith::ConstantOp>(
       loc, builder.getIntegerAttr(toType, 0));
 }
 
 /// Lower a string literal. Many arguments to the runtime are conveyed as
 /// Fortran CHARACTER literals.
 template <typename A>

 /// this information to lowering.
 static std::tuple<mlir::Value, mlir::Value, mlir::Value>
 lowerSourceTextAsStringLit(Fortran::lower::AbstractConverter &converter,
                            mlir::Location loc, llvm::StringRef text,
                            mlir::Type strTy, mlir::Type lenTy) {
   text = text.drop_front(text.find('('));
   text = text.take_front(text.rfind(')') + 1);
   auto &builder = converter.getFirOpBuilder();
-  auto lit = builder.createStringLit(
-      loc, /*FIXME*/ fir::CharacterType::get(builder.getContext(), 1, 1), text);
+  auto lit = builder.createStringLitOp(loc, text);
   auto data =
       Fortran::lower::CharacterExprHelper{builder, loc}.materializeCharacter(
           lit);
   auto buff = builder.createConvert(loc, strTy, data.first);
   auto len = builder.createConvert(loc, lenTy, data.second);
   return {buff, len, mlir::Value{}};
 }
 

 //   - formatted vs. list vs. unformatted
 //   - synchronous vs. asynchronous
 //   - namelist vs. list
 //   - external vs. internal + default KIND vs. internal + other KIND
 //===----------------------------------------------------------------------===//
 
 // Determine the correct BeginXyz{In|Out}put api to invoke.
 template <bool isInput>
-mlir::FuncOp getBeginDataTransfer(mlir::Location loc, FirOpBuilder &builder,
-                                  bool isFormatted, bool isList, bool isIntern,
-                                  bool isOtherIntern, bool isAsynch,
-                                  bool isNml) {
+mlir::FuncOp
+getBeginDataTransfer(mlir::Location loc, fir::FirOpBuilder &builder,
+                     bool isOtherIntern, bool isAsynch, bool isNml) {
   if constexpr (isInput) {
     if (isAsynch)
       return getIORuntimeFunc<mkIOKey(BeginAsynchronousInput)>(loc, builder);
     if (isFormatted) {
       if (isIntern) {
         if (isOtherIntern) {
           if (isList || isNml)
             return getIORuntimeFunc<mkIOKey(BeginInternalArrayListInput)>(

flang/lib/Lower/IntrinsicCall.cpp

 //===----------------------------------------------------------------------===//
 
 #include "flang/Lower/IntrinsicCall.h"
 #include "RTBuilder.h"
 #include "flang/Common/static-multimap-view.h"
 #include "flang/Lower/CharacterExpr.h"
 #include "flang/Lower/ComplexExpr.h"
 #include "flang/Lower/ConvertType.h"
-#include "flang/Lower/FIRBuilder.h"
 #include "flang/Lower/Mangler.h"
 #include "flang/Lower/Runtime.h"
+#include "flang/Optimizer/Builder/FIRBuilder.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/ErrorHandling.h"
 #include <algorithm>
 #include <string_view>
 #include <utility>
 
 #define PGMATH_DECLARE
 #include "flang/Evaluate/pgmath.h.inc"
enum class ExtremumBehavior {
   // LLVM/MLIR do not provide ways to observe this aspect, so it is not
   // possible to implement it without some target dependent runtime.
 };
 
 // TODO error handling -> return a code or directly emit messages ?
 struct IntrinsicLibrary {
 
   // Constructors.
-  explicit IntrinsicLibrary(Fortran::lower::FirOpBuilder &builder,
-                            mlir::Location loc)
+  explicit IntrinsicLibrary(fir::FirOpBuilder &builder, mlir::Location loc)
       : builder{builder}, loc{loc} {}
   IntrinsicLibrary() = delete;
   IntrinsicLibrary(const IntrinsicLibrary &) = delete;
 
   /// Generate FIR for call to Fortran intrinsic \p name with arguments \p arg
   /// and expected result type \p resultType.
   fir::ExtendedValue genIntrinsicCall(llvm::StringRef name,
                                       mlir::Type resultType,
                                       llvm::ArrayRef<fir::ExtendedValue> arg);
 
   /// Search a runtime function that is associated to the generic intrinsic name
   /// and whose signature matches the intrinsic arguments and result types.
   /// If no such runtime function is found but a runtime function associated
   /// with the Fortran generic exists and has the same number of arguments,
   /// conversions will be inserted before and/or after the call. This is to
   /// mainly to allow 16 bits float support even-though little or no math
   /// runtime is currently available for it.
   mlir::Value genRuntimeCall(llvm::StringRef name, mlir::Type,
                              llvm::ArrayRef<mlir::Value>);
 
-  using RuntimeCallGenerator =
-      std::function<mlir::Value(Fortran::lower::FirOpBuilder &, mlir::Location,
-                                llvm::ArrayRef<mlir::Value>)>;
+  using RuntimeCallGenerator = std::function<mlir::Value(
+      fir::FirOpBuilder &, mlir::Location, llvm::ArrayRef<mlir::Value>)>;
   RuntimeCallGenerator
   getRuntimeCallGenerator(llvm::StringRef name,
                           mlir::FunctionType soughtFuncType);
 
   mlir::Value genAbs(mlir::Type, llvm::ArrayRef<mlir::Value>);
   mlir::Value genAimag(mlir::Type, llvm::ArrayRef<mlir::Value>);
   mlir::Value genAint(mlir::Type, llvm::ArrayRef<mlir::Value>);
   mlir::Value genAnint(mlir::Type, llvm::ArrayRef<mlir::Value>);
mlir::Value invokeGenerator(ExtendedGenerator generator,
                               llvm::ArrayRef<mlir::Value> args);
 
   /// Get pointer to unrestricted intrinsic. Generate the related unrestricted
   /// intrinsic if it is not defined yet.
   mlir::SymbolRefAttr
   getUnrestrictedIntrinsicSymbolRefAttr(llvm::StringRef name,
                                         mlir::FunctionType signature);
 
-  Fortran::lower::FirOpBuilder &builder;
+  fir::FirOpBuilder &builder;
   mlir::Location loc;
 };
 
 /// Table that drives the fir generation depending on the intrinsic.
 /// one to one mapping with Fortran arguments. If no mapping is
 /// defined here for a generic intrinsic, genRuntimeCall will be called
 /// to look for a match in the runtime a emit a call.
 struct IntrinsicHandler {
private:
   };
 
   std::array<int, dataSize> conversions{/* zero init*/};
   bool infinite{false}; // When forbidden conversion or wrong argument number
 };
 
 /// Build mlir::FuncOp from runtime symbol description and add
 /// fir.runtime attribute.
-static mlir::FuncOp getFuncOp(mlir::Location loc,
-                              Fortran::lower::FirOpBuilder &builder,
+static mlir::FuncOp getFuncOp(mlir::Location loc, fir::FirOpBuilder &builder,
                               const RuntimeFunction &runtime) {
   auto function = builder.addNamedFunction(
       loc, runtime.symbol, runtime.typeGenerator(builder.getContext()));
   function->setAttr("fir.runtime", builder.getUnitAttr());
   return function;
 }
 
 /// Select runtime function that has the smallest distance to the intrinsic
 /// function type and that will not imply narrowing arguments or extending the
 /// result.
 /// If nothing is found, the mlir::FuncOp will contain a nullptr.
 mlir::FuncOp searchFunctionInLibrary(
-    mlir::Location loc, Fortran::lower::FirOpBuilder &builder,
+    mlir::Location loc, fir::FirOpBuilder &builder,
     const Fortran::common::StaticMultimapView<RuntimeFunction> &lib,
     llvm::StringRef name, mlir::FunctionType funcType,
     const RuntimeFunction **bestNearMatch,
     FunctionDistance &bestMatchDistance) {
   auto range = lib.equal_range(name);
   for (auto iter{range.first}; iter != range.second && iter; ++iter) {
     const auto &impl = *iter;
     auto implType = impl.typeGenerator(builder.getContext());
mlir::FuncOp searchFunctionInLibrary(
   return {};
 }
 
 /// Search runtime for the best runtime function given an intrinsic name
 /// and interface. The interface may not be a perfect match in which case
 /// the caller is responsible to insert argument and return value conversions.
 /// If nothing is found, the mlir::FuncOp will contain a nullptr.
 static mlir::FuncOp getRuntimeFunction(mlir::Location loc,
-                                       Fortran::lower::FirOpBuilder &builder,
+                                       fir::FirOpBuilder &builder,
                                        llvm::StringRef name,
                                        mlir::FunctionType funcType) {
   const RuntimeFunction *bestNearMatch = nullptr;
   FunctionDistance bestMatchDistance{};
   mlir::FuncOp match;
   using RtMap = Fortran::common::StaticMultimapView<RuntimeFunction>;
   static constexpr RtMap pgmathF(pgmathFast);
   static_assert(pgmathF.Verify() && "map must be sorted");
if (bestNearMatch != nullptr) {
     assert(!bestMatchDistance.isLosingPrecision() &&
            "runtime selection loses precision");
     return getFuncOp(loc, builder, *bestNearMatch);
   }
   return {};
 }
 
 /// Helpers to get function type from arguments and result type.
-static mlir::FunctionType
-getFunctionType(mlir::Type resultType, llvm::ArrayRef<mlir::Value> arguments,
-                Fortran::lower::FirOpBuilder &builder) {
+static mlir::FunctionType getFunctionType(mlir::Type resultType,
+                                          llvm::ArrayRef<mlir::Value> arguments,
+                                          fir::FirOpBuilder &builder) {
   llvm::SmallVector<mlir::Type, 2> argumentTypes;
   for (auto &arg : arguments)
     argumentTypes.push_back(arg.getType());
   return mlir::FunctionType::get(builder.getModule().getContext(),
                                  argumentTypes, resultType);
 }
 
 /// fir::ExtendedValue to mlir::Value translation layer
 
-fir::ExtendedValue toExtendedValue(mlir::Value val,
-                                   Fortran::lower::FirOpBuilder &builder,
+fir::ExtendedValue toExtendedValue(mlir::Value val, fir::FirOpBuilder &builder,
                                    mlir::Location loc) {
   assert(val && "optional unhandled here");
   auto type = val.getType();
   auto base = val;
   auto indexType = builder.getIndexType();
   llvm::SmallVector<mlir::Value, 2> extents;
 
   Fortran::lower::CharacterExprHelper charHelper{builder, loc};
if (auto arrayType = type.dyn_cast<fir::SequenceType>()) {
     mlir::emitError(loc, "descriptor or derived type not yet handled");
   }
 
   if (!extents.empty())
     return fir::ArrayBoxValue{base, extents};
   return base;
 }
 
-mlir::Value toValue(const fir::ExtendedValue &val,
-                    Fortran::lower::FirOpBuilder &builder, mlir::Location loc) {
+mlir::Value toValue(const fir::ExtendedValue &val, fir::FirOpBuilder &builder,
+                    mlir::Location loc) {
   if (auto charBox = val.getCharBox()) {
     auto buffer = charBox->getBuffer();
     if (buffer.getType().isa<fir::BoxCharType>())
       return buffer;
     return Fortran::lower::CharacterExprHelper{builder, loc}.createEmboxChar(
         buffer, charBox->getLen());
   }
 
if (!function) {
     // First time this wrapper is needed, build it.
     function = builder.createFunction(loc, wrapperName, funcType);
     function->setAttr("fir.intrinsic", builder.getUnitAttr());
     function.addEntryBlock();
 
     // Create local context to emit code into the newly created function
     // This new function is not linked to a source file location, only
     // its calls will be.
-    auto localBuilder = std::make_unique<Fortran::lower::FirOpBuilder>(
-        function, builder.getKindMap());
+    auto localBuilder =
+        std::make_unique<fir::FirOpBuilder>(function, builder.getKindMap());
     localBuilder->setInsertionPointToStart(&function.front());
     // Location of code inside wrapper of the wrapper is independent from
     // the location of the intrinsic call.
     auto localLoc = localBuilder->getUnknownLoc();
     llvm::SmallVector<mlir::Value, 2> localArguments;
     for (mlir::BlockArgument bArg : function.front().getArguments()) {
       auto refType = bArg.getType().dyn_cast<fir::ReferenceType>();
       if (loadRefArguments && refType) {
if (!funcOp) {
     exit(1);
   }
 
   mlir::FunctionType actualFuncType = funcOp.getType();
   assert(actualFuncType.getNumResults() == soughtFuncType.getNumResults() &&
          actualFuncType.getNumInputs() == soughtFuncType.getNumInputs() &&
          actualFuncType.getNumResults() == 1 && "Bad intrinsic match");
 
-  return [funcOp, actualFuncType, soughtFuncType](
-             Fortran::lower::FirOpBuilder &builder, mlir::Location loc,
+  return [funcOp, actualFuncType,
+          soughtFuncType](fir::FirOpBuilder &builder, mlir::Location loc,
                           llvm::ArrayRef<mlir::Value> args) {
     llvm::SmallVector<mlir::Value, 2> convertedArguments;
     for (const auto &pair : llvm::zip(actualFuncType.getInputs(), args))
       convertedArguments.push_back(
           builder.createConvert(loc, std::get<0>(pair), std::get<1>(pair)));
     auto call = builder.create<mlir::CallOp>(loc, funcOp, convertedArguments);
     mlir::Type soughtType = soughtFuncType.getResult(0);
     return builder.createConvert(loc, soughtType, call.getResult(0));
   };
mlir::Value IntrinsicLibrary::genSign(mlir::Type resultType,
   auto cmp = builder.create<mlir::arith::CmpFOp>(
       loc, mlir::arith::CmpFPredicate::OLT, args[1], zero);
   return builder.create<mlir::SelectOp>(loc, cmp, neg, abs);
 }
 
 // Compare two FIR values and return boolean result as i1.
 template <Extremum extremum, ExtremumBehavior behavior>
 static mlir::Value createExtremumCompare(mlir::Location loc,
-                                         Fortran::lower::FirOpBuilder &builder,
+                                         fir::FirOpBuilder &builder,
                                          mlir::Value left, mlir::Value right) {
   static constexpr auto integerPredicate =
       extremum == Extremum::Max ? mlir::arith::CmpIPredicate::sgt
                                 : mlir::arith::CmpIPredicate::slt;
   static constexpr auto orderedCmp = extremum == Extremum::Max
                                          ? mlir::arith::CmpFPredicate::OGT
                                          : mlir::arith::CmpFPredicate::OLT;
   auto type = left.getType();
mlir::Value IntrinsicLibrary::genExtremum(mlir::Type,
   return result;
 }
 
 //===----------------------------------------------------------------------===//
 // Public intrinsic call helpers
 //===----------------------------------------------------------------------===//
 
 fir::ExtendedValue
-Fortran::lower::genIntrinsicCall(Fortran::lower::FirOpBuilder &builder,
-                                 mlir::Location loc, llvm::StringRef name,
-                                 mlir::Type resultType,
+Fortran::lower::genIntrinsicCall(fir::FirOpBuilder &builder, mlir::Location loc,
+                                 llvm::StringRef name, mlir::Type resultType,
                                  llvm::ArrayRef<fir::ExtendedValue> args) {
   return IntrinsicLibrary{builder, loc}.genIntrinsicCall(name, resultType,
                                                          args);
 }
 
-mlir::Value Fortran::lower::genMax(Fortran::lower::FirOpBuilder &builder,
+mlir::Value Fortran::lower::genMax(fir::FirOpBuilder &builder,
                                    mlir::Location loc,
                                    llvm::ArrayRef<mlir::Value> args) {
   assert(args.size() > 0 && "max requires at least one argument");
   return IntrinsicLibrary{builder, loc}
       .genExtremum<Extremum::Max, ExtremumBehavior::MinMaxss>(args[0].getType(),
                                                               args);
 }
 
-mlir::Value Fortran::lower::genMin(Fortran::lower::FirOpBuilder &builder,
+mlir::Value Fortran::lower::genMin(fir::FirOpBuilder &builder,
                                    mlir::Location loc,
                                    llvm::ArrayRef<mlir::Value> args) {
   assert(args.size() > 0 && "min requires at least one argument");
   return IntrinsicLibrary{builder, loc}
       .genExtremum<Extremum::Min, ExtremumBehavior::MinMaxss>(args[0].getType(),
                                                               args);
 }
 
-mlir::Value Fortran::lower::genPow(Fortran::lower::FirOpBuilder &builder,
+mlir::Value Fortran::lower::genPow(fir::FirOpBuilder &builder,
                                    mlir::Location loc, mlir::Type type,
                                    mlir::Value x, mlir::Value y) {
   return IntrinsicLibrary{builder, loc}.genRuntimeCall("pow", type, {x, y});
 }
 
 mlir::SymbolRefAttr Fortran::lower::getUnrestrictedIntrinsicSymbolRefAttr(
-    Fortran::lower::FirOpBuilder &builder, mlir::Location loc,
-    llvm::StringRef name, mlir::FunctionType signature) {
+    fir::FirOpBuilder &builder, mlir::Location loc, llvm::StringRef name,
+    mlir::FunctionType signature) {
   return IntrinsicLibrary{builder, loc}.getUnrestrictedIntrinsicSymbolRefAttr(
       name, signature);
 }

flang/lib/Lower/OpenACC.cpp

 //===-- OpenACC.cpp -- OpenACC directive lowering -------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // Coding style: https://mlir.llvm.org/getting_started/DeveloperGuide/
 //
 //===----------------------------------------------------------------------===//
 
 #include "flang/Lower/OpenACC.h"
 #include "flang/Common/idioms.h"
 #include "flang/Lower/Bridge.h"
-#include "flang/Lower/FIRBuilder.h"
 #include "flang/Lower/PFTBuilder.h"
-#include "flang/Lower/Support/BoxValue.h"
 #include "flang/Lower/Todo.h"
+#include "flang/Optimizer/Builder/BoxValue.h"
+#include "flang/Optimizer/Builder/FIRBuilder.h"
 #include "flang/Parser/parse-tree.h"
 #include "flang/Semantics/tools.h"
 #include "mlir/Dialect/OpenACC/OpenACC.h"
 #include "llvm/Frontend/OpenACC/ACC.h.inc"
 
 static const Fortran::parser::Name *
 getDesignatorNameIfDataRef(const Fortran::parser::Designator &designator) {
   const auto *dataRef{std::get_if<Fortran::parser::DataRef>(&designator.u)};
if (clauseOperand) {
     operands.push_back(clauseOperand);
     operandSegments.push_back(1);
   } else {
     operandSegments.push_back(0);
   }
 }
 
 template <typename Op, typename Terminator>
-static Op createRegionOp(Fortran::lower::FirOpBuilder &builder,
-                         mlir::Location loc,
+static Op createRegionOp(fir::FirOpBuilder &builder, mlir::Location loc,
                          const SmallVectorImpl<Value> &operands,
                          const SmallVectorImpl<int32_t> &operandSegments) {
   llvm::ArrayRef<mlir::Type> argTy;
   Op op = builder.create<Op>(loc, argTy, operands);
   builder.createBlock(&op.getRegion());
   auto &block = op.getRegion().back();
   builder.setInsertionPointToStart(&block);
   builder.create<Terminator>(loc);
 
   op->setAttr(Op::getOperandSegmentSizeAttr(),
               builder.getI32VectorAttr(operandSegments));
 
   // Place the insertion point to the start of the first block.
   builder.setInsertionPointToStart(&block);
 
   return op;
 }
 
 template <typename Op>
-static Op createSimpleOp(Fortran::lower::FirOpBuilder &builder,
-                         mlir::Location loc,
+static Op createSimpleOp(fir::FirOpBuilder &builder, mlir::Location loc,
                          const SmallVectorImpl<Value> &operands,
                          const SmallVectorImpl<int32_t> &operandSegments) {
   llvm::ArrayRef<mlir::Type> argTy;
   Op op = builder.create<Op>(loc, argTy, operands);
   op->setAttr(Op::getOperandSegmentSizeAttr(),
               builder.getI32VectorAttr(operandSegments));
   return op;
 }

flang/lib/Lower/OpenMP.cpp

 //===-- OpenMP.cpp -- Open MP directive lowering --------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // Coding style: https://mlir.llvm.org/getting_started/DeveloperGuide/
 //
 //===----------------------------------------------------------------------===//
 
 #include "flang/Lower/OpenMP.h"
 #include "flang/Common/idioms.h"
 #include "flang/Lower/Bridge.h"
-#include "flang/Lower/FIRBuilder.h"
 #include "flang/Lower/PFTBuilder.h"
-#include "flang/Lower/Support/BoxValue.h"
 #include "flang/Lower/Todo.h"
+#include "flang/Optimizer/Builder/BoxValue.h"
+#include "flang/Optimizer/Builder/FIRBuilder.h"
 #include "flang/Parser/parse-tree.h"
 #include "flang/Semantics/tools.h"
 #include "mlir/Dialect/OpenMP/OpenMPDialect.h"
 #include "llvm/Frontend/OpenMP/OMPConstants.h"
 
 static const Fortran::parser::Name *
 getDesignatorNameIfDataRef(const Fortran::parser::Designator &designator) {
   const auto *dataRef = std::get_if<Fortran::parser::DataRef>(&designator.u);
std::visit(
               const auto variable = converter.getSymbolAddress(*name.symbol);
               operands.push_back(variable);
             }},
         ompObject.u);
   }
 }
 
 template <typename Op>
-static void createBodyOfOp(Op &op, Fortran::lower::FirOpBuilder &firOpBuilder,
+static void createBodyOfOp(Op &op, fir::FirOpBuilder &firOpBuilder,
                            mlir::Location &loc) {
   firOpBuilder.createBlock(&op.getRegion());
   auto &block = op.getRegion().back();
   firOpBuilder.setInsertionPointToStart(&block);
   // Ensure the block is well-formed.
   firOpBuilder.create<mlir::omp::TerminatorOp>(loc);
   // Reset the insertion point to the start of the first block.
   firOpBuilder.setInsertionPointToStart(&block);

flang/lib/Lower/SymbolMap.h

 //===-- SymbolMap.h -- lowering internal symbol map -------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef FORTRAN_LOWER_SYMBOLMAP_H
 #define FORTRAN_LOWER_SYMBOLMAP_H
 
 #include "flang/Common/idioms.h"
 #include "flang/Common/reference.h"
-#include "flang/Lower/Support/BoxValue.h"
+#include "flang/Optimizer/Builder/BoxValue.h"
 #include "flang/Optimizer/Dialect/FIRType.h"
 #include "flang/Semantics/symbol.h"
 #include "mlir/IR/Value.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/Support/Compiler.h"
public:
   void addCharSymbolWithBounds(semantics::SymbolRef sym, mlir::Value value,
                                mlir::Value len,
                                llvm::ArrayRef<mlir::Value> extents,
                                llvm::ArrayRef<mlir::Value> lbounds,
                                bool force = false) {
     makeSym(sym, SymbolBox::CharFullDim(value, len, extents, lbounds), force);
   }
 
-  /// Generalized derived type mapping.
-  void addDerivedSymbol(semantics::SymbolRef sym, mlir::Value value,
-                        mlir::Value size, llvm::ArrayRef<mlir::Value> extents,
-                        llvm::ArrayRef<mlir::Value> lbounds,
-                        llvm::ArrayRef<mlir::Value> params,
-                        bool force = false) {
-    makeSym(sym, SymbolBox::Derived(value, size, params, extents, lbounds),
-            force);
-  }
-
   /// Find `symbol` and return its value if it appears in the current mappings.
   SymbolBox lookupSymbol(semantics::SymbolRef sym) {
     auto iter = symbolMap.find(&*sym);
     return (iter == symbolMap.end()) ? SymbolBox() : iter->second;
   }
 
   /// Remove `sym` from the map.
   void erase(semantics::SymbolRef sym) { symbolMap.erase(&*sym); }