FIRBuilder.h

//===-- 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_OPTIMIZER_BUILDER_FIRBUILDER_H
#define FORTRAN_OPTIMIZER_BUILDER_FIRBUILDER_H
 
#include "flang/Optimizer/Dialect/FIRBoxUtils.h"
#include "flang/Optimizer/Dialect/FIROps.h"
#include "flang/Optimizer/Dialect/FIROpsSupport.h"
#include "flang/Optimizer/Dialect/FIRType.h"
#include "flang/Optimizer/Dialect/Support/FIRContext.h"
#include "flang/Optimizer/Dialect/Support/KindMapping.h"
#include "flang/Support/FPMaxminBehavior.h"
#include "flang/Support/MathOptionsBase.h"
#include "mlir/IR/Builders.h"
#include "mlir/IR/BuiltinOps.h"
#include "llvm/ADT/DenseMap.h"
#include <optional>
#include <utility>
 
namespace mlir {
class DataLayout;
class SymbolTable;
}
 
namespace fir {
class AbstractArrayBox;
class ExtendedValue;
class MutableBoxValue;
class BoxValue;

constexpr unsigned defaultArrayGlobalAlignment = 64;
inline mlir::Type getIntPtrType(mlir::OpBuilder &builder) {
  // TODO: Delay the need of such type until codegen or find a way to use
  // llvm::DataLayout::getPointerSizeInBits here.
  return builder.getI64Type();
}

mlir::Block *getAllocaBlock(mlir::Region &region);
 
//===----------------------------------------------------------------------===//
// FirOpBuilder
//===----------------------------------------------------------------------===//

class FirOpBuilder : public mlir::OpBuilder, public mlir::OpBuilder::Listener {
public:
  explicit FirOpBuilder(mlir::Operation *op, fir::KindMapping kindMap,
                        mlir::SymbolTable *symbolTable = nullptr)
      : OpBuilder{op, /*listener=*/this}, kindMap{std::move(kindMap)},
        symbolTable{symbolTable} {
    auto fmi = mlir::dyn_cast<mlir::arith::ArithFastMathInterface>(*op);
    if (fmi) {
      // Set the builder with FastMathFlags attached to the operation.
      setFastMathFlags(fmi.getFastMathFlagsAttr().getValue());
    }
  }
  explicit FirOpBuilder(mlir::OpBuilder &builder, fir::KindMapping kindMap,
                        mlir::SymbolTable *symbolTable = nullptr)
      : OpBuilder(builder), OpBuilder::Listener(), kindMap{std::move(kindMap)},
        symbolTable{symbolTable} {
    setListener(this);
  }
  explicit FirOpBuilder(mlir::OpBuilder &builder, mlir::ModuleOp mod)
      : OpBuilder(builder), OpBuilder::Listener(),
        kindMap{getKindMapping(mod)} {
    setListener(this);
  }
  explicit FirOpBuilder(mlir::OpBuilder &builder, fir::KindMapping kindMap,
                        mlir::Operation *op)
      : OpBuilder(builder), OpBuilder::Listener(), kindMap{std::move(kindMap)} {
    setListener(this);
    auto fmi = mlir::dyn_cast<mlir::arith::ArithFastMathInterface>(*op);
    if (fmi) {
      // Set the builder with FastMathFlags attached to the operation.
      setFastMathFlags(fmi.getFastMathFlagsAttr().getValue());
    }
  }
  FirOpBuilder(mlir::OpBuilder &builder, mlir::Operation *op)
      : FirOpBuilder(builder, fir::getKindMapping(op), op) {}
 
  // The listener self-reference has to be updated in case of copy-construction.
  FirOpBuilder(const FirOpBuilder &other)
      : OpBuilder(other), OpBuilder::Listener(), kindMap{other.kindMap},
        fastMathFlags{other.fastMathFlags},
        integerOverflowFlags{other.integerOverflowFlags},
        symbolTable{other.symbolTable} {
    setListener(this);
  }
 
  FirOpBuilder(FirOpBuilder &&other)
      : OpBuilder(other), OpBuilder::Listener(),
        kindMap{std::move(other.kindMap)}, fastMathFlags{other.fastMathFlags},
        integerOverflowFlags{other.integerOverflowFlags},
        symbolTable{other.symbolTable} {
    setListener(this);
  }

  mlir::Region &getRegion() { return *getBlock()->getParent(); }

  mlir::ModuleOp getModule() {
    return getRegion().getParentOfType<mlir::ModuleOp>();
  }

  mlir::func::FuncOp getFunction() {
    return getRegion().getParentOfType<mlir::func::FuncOp>();
  }

  const fir::KindMapping &getKindMap() { return kindMap; }

  mlir::SymbolTable *getMLIRSymbolTable() { return symbolTable; }

  [[maybe_unused]] mlir::IntegerType getDefaultIntegerType() {
    return getIntegerType(
        getKindMap().getIntegerBitsize(getKindMap().defaultIntegerKind()));
  }

  mlir::Value convertWithSemantics(mlir::Location loc, mlir::Type toTy,
                                   mlir::Value val,
                                   bool allowCharacterConversion = false,
                                   bool allowRebox = false);

  mlir::Block *getEntryBlock() { return &getFunction().front(); }

  mlir::Block *getAllocaBlock();

  mlir::Type getRefType(mlir::Type eleTy, bool isVolatile = false);

  mlir::Type getVarLenSeqTy(mlir::Type eleTy, unsigned rank = 1);

  mlir::Type getCharacterLengthType() { return getIndexType(); }

  mlir::Type getIntPtrType() { return fir::getIntPtrType(*this); }

  mlir::SymbolRefAttr getSymbolRefAttr(llvm::StringRef str) {
    return mlir::SymbolRefAttr::get(getContext(), str);
  }

  mlir::Type getRealType(int kind);
 
  fir::BoxProcType getBoxProcType(mlir::FunctionType funcTy) {
    return fir::BoxProcType::get(getContext(), funcTy);
  }

  mlir::Value createNullConstant(mlir::Location loc, mlir::Type ptrType = {});

  mlir::Value createIntegerConstant(mlir::Location loc, mlir::Type integerType,
                                    std::int64_t i);

  mlir::Value createAllOnesInteger(mlir::Location loc, mlir::Type integerType);

  mlir::Value createMinusOneInteger(mlir::Location loc,
                                    mlir::Type integerType) {
    return createAllOnesInteger(loc, integerType);
  }

  mlir::Value createRealConstant(mlir::Location loc, mlir::Type realType,
                                 llvm::APFloat::integerPart val);

  mlir::Value createRealConstant(mlir::Location loc, mlir::Type realType,
                                 const llvm::APFloat &val);

  mlir::Value createRealZeroConstant(mlir::Location loc, mlir::Type realType) {
    return createRealConstant(loc, realType, 0u);
  }

  mlir::Value createRealOneConstant(mlir::Location loc, mlir::Type realType) {
    return createRealConstant(loc, realType, 1u);
  }

  mlir::Value allocateLocal(mlir::Location loc, mlir::Type ty,
                            llvm::StringRef uniqName, llvm::StringRef name,
                            bool pinned, llvm::ArrayRef<mlir::Value> shape,
                            llvm::ArrayRef<mlir::Value> lenParams,
                            bool asTarget = false);
  mlir::Value allocateLocal(mlir::Location loc, mlir::Type ty,
                            llvm::StringRef uniqName, llvm::StringRef name,
                            llvm::ArrayRef<mlir::Value> shape,
                            llvm::ArrayRef<mlir::Value> lenParams,
                            bool asTarget = false);

  mlir::ArrayAttr create2DI64ArrayAttr(
      llvm::SmallVectorImpl<llvm::SmallVector<int64_t>> &intData);

  mlir::Value createTemporaryAlloc(
      mlir::Location loc, mlir::Type type, llvm::StringRef name,
      mlir::ValueRange lenParams = {}, mlir::ValueRange shape = {},
      llvm::ArrayRef<mlir::NamedAttribute> attrs = {},
      std::optional<Fortran::common::CUDADataAttr> cudaAttr = std::nullopt);

  mlir::Value createTemporary(
      mlir::Location loc, mlir::Type type, llvm::StringRef name = {},
      mlir::ValueRange shape = {}, mlir::ValueRange lenParams = {},
      llvm::ArrayRef<mlir::NamedAttribute> attrs = {},
      std::optional<Fortran::common::CUDADataAttr> cudaAttr = std::nullopt);

  mlir::Value createTemporary(mlir::Location loc, mlir::Type type,
                              mlir::ValueRange shape) {
    return createTemporary(loc, type, llvm::StringRef{}, shape);
  }
 
  mlir::Value createTemporary(mlir::Location loc, mlir::Type type,
                              llvm::ArrayRef<mlir::NamedAttribute> attrs) {
    return createTemporary(loc, type, llvm::StringRef{}, {}, {}, attrs);
  }
 
  mlir::Value createTemporary(mlir::Location loc, mlir::Type type,
                              llvm::StringRef name,
                              llvm::ArrayRef<mlir::NamedAttribute> attrs) {
    return createTemporary(loc, type, name, {}, {}, attrs);
  }

  mlir::Value
  createHeapTemporary(mlir::Location loc, mlir::Type type,
                      llvm::StringRef name = {}, mlir::ValueRange shape = {},
                      mlir::ValueRange lenParams = {},
                      llvm::ArrayRef<mlir::NamedAttribute> attrs = {});

  static mlir::Value genTempDeclareOp(fir::FirOpBuilder &builder,
                                      mlir::Location loc, mlir::Value memref,
                                      llvm::StringRef name, mlir::Value shape,
                                      llvm::ArrayRef<mlir::Value> typeParams,
                                      fir::FortranVariableFlagsAttr attrs);

  std::pair<mlir::Value, bool> createAndDeclareTemp(
      mlir::Location loc, mlir::Type baseType, mlir::Value shape,
      llvm::ArrayRef<mlir::Value> extents,
      llvm::ArrayRef<mlir::Value> typeParams,
      const std::function<decltype(genTempDeclareOp)> &genDeclare,
      mlir::Value polymorphicMold, bool useStack, llvm::StringRef tmpName);
  std::pair<mlir::Value, bool>
  createArrayTemp(mlir::Location loc, fir::SequenceType arrayType,
                  mlir::Value shape, llvm::ArrayRef<mlir::Value> extents,
                  llvm::ArrayRef<mlir::Value> typeParams,
                  const std::function<decltype(genTempDeclareOp)> &genDeclare,
                  mlir::Value polymorphicMold, bool useStack = false,
                  llvm::StringRef tmpName = ".tmp.array") {
    return createAndDeclareTemp(loc, arrayType, shape, extents, typeParams,
                                genDeclare, polymorphicMold, useStack, tmpName);
  }

  mlir::Value genStackSave(mlir::Location loc);

  void genStackRestore(mlir::Location loc, mlir::Value stackPointer);

  fir::GlobalOp createGlobal(mlir::Location loc, mlir::Type type,
                             llvm::StringRef name,
                             fir::LinkageAttr linkage = {},
                             mlir::Attribute value = {}, bool isConst = false,
                             bool isTarget = false,
                             cuf::DataAttributeAttr dataAttr = {},
                             bool setDefaultAlignment = true);
 
  fir::GlobalOp createGlobal(mlir::Location loc, mlir::Type type,
                             llvm::StringRef name, bool isConst, bool isTarget,
                             std::function<void(FirOpBuilder &)> bodyBuilder,
                             fir::LinkageAttr linkage = {},
                             cuf::DataAttributeAttr dataAttr = {},
                             bool setDefaultAlignment = true);

  fir::GlobalOp createGlobalConstant(mlir::Location loc, mlir::Type type,
                                     llvm::StringRef name,
                                     fir::LinkageAttr linkage = {},
                                     mlir::Attribute value = {}) {
    return createGlobal(loc, type, name, linkage, value, /*isConst=*/true,
                        /*isTarget=*/false);
  }
 
  fir::GlobalOp
  createGlobalConstant(mlir::Location loc, mlir::Type type,
                       llvm::StringRef name,
                       std::function<void(FirOpBuilder &)> bodyBuilder,
                       fir::LinkageAttr linkage = {}) {
    return createGlobal(loc, type, name, /*isConst=*/true, /*isTarget=*/false,
                        bodyBuilder, linkage);
  }

  fir::StringLitOp createStringLitOp(mlir::Location loc,
                                     llvm::StringRef string);
 
  std::pair<fir::TypeInfoOp, mlir::OpBuilder::InsertPoint>
  createTypeInfoOp(mlir::Location loc, fir::RecordType recordType,
                   fir::RecordType parentType);
 
  //===--------------------------------------------------------------------===//
  // Linkage helpers (inline). The default linkage is external.
  //===--------------------------------------------------------------------===//
 
  static fir::LinkageAttr createCommonLinkage(mlir::MLIRContext *context) {
    return fir::LinkageAttr::get(context, fir::LinkageEnum::Common);
  }
  fir::LinkageAttr createCommonLinkage() {
    return createCommonLinkage(getContext());
  }
 
  fir::LinkageAttr createExternalLinkage() {
    return fir::LinkageAttr::get(getContext(), fir::LinkageEnum::External);
  }
 
  fir::LinkageAttr createInternalLinkage() {
    return fir::LinkageAttr::get(getContext(), fir::LinkageEnum::Internal);
  }
 
  fir::LinkageAttr createLinkOnceLinkage() {
    return fir::LinkageAttr::get(getContext(), fir::LinkageEnum::Linkonce);
  }
 
  fir::LinkageAttr createLinkOnceODRLinkage() {
    return fir::LinkageAttr::get(getContext(), fir::LinkageEnum::LinkonceODR);
  }
 
  fir::LinkageAttr createWeakLinkage() {
    return fir::LinkageAttr::get(getContext(), fir::LinkageEnum::Weak);
  }

  mlir::func::FuncOp getNamedFunction(llvm::StringRef name) {
    return getNamedFunction(getModule(), getMLIRSymbolTable(), name);
  }
  static mlir::func::FuncOp
  getNamedFunction(mlir::ModuleOp module, const mlir::SymbolTable *symbolTable,
                   llvm::StringRef name);

  mlir::func::FuncOp getNamedFunction(mlir::SymbolRefAttr symbol) {
    return getNamedFunction(getModule(), getMLIRSymbolTable(), symbol);
  }
  static mlir::func::FuncOp
  getNamedFunction(mlir::ModuleOp module, const mlir::SymbolTable *symbolTable,
                   mlir::SymbolRefAttr symbol);
 
  fir::GlobalOp getNamedGlobal(llvm::StringRef name) {
    return getNamedGlobal(getModule(), getMLIRSymbolTable(), name);
  }
 
  static fir::GlobalOp getNamedGlobal(mlir::ModuleOp module,
                                      const mlir::SymbolTable *symbolTable,
                                      llvm::StringRef name);

  mlir::Value createConvert(mlir::Location loc, mlir::Type toTy,
                            mlir::Value val);

  mlir::Value createConvertWithVolatileCast(mlir::Location loc, mlir::Type toTy,
                                            mlir::Value val);

  mlir::Value createVolatileCast(mlir::Location loc, bool isVolatile,
                                 mlir::Value value);

  void createStoreWithConvert(mlir::Location loc, mlir::Value val,
                              mlir::Value addr);

  mlir::Value loadIfRef(mlir::Location loc, mlir::Value val);

  mlir::func::FuncOp createFunction(mlir::Location loc, llvm::StringRef name,
                                    mlir::FunctionType ty) {
    return createFunction(loc, getModule(), name, ty, getMLIRSymbolTable());
  }
 
  static mlir::func::FuncOp createFunction(mlir::Location loc,
                                           mlir::ModuleOp module,
                                           llvm::StringRef name,
                                           mlir::FunctionType ty,
                                           mlir::SymbolTable *);

  mlir::func::FuncOp createRuntimeFunction(mlir::Location loc,
                                           llvm::StringRef name,
                                           mlir::FunctionType ty,
                                           bool isIO = false);

  mlir::Value convertToIndexType(mlir::Location loc, mlir::Value val) {
    return createConvert(loc, getIndexType(), val);
  }

  mlir::Value genShape(mlir::Location loc, const fir::AbstractArrayBox &arr);
  mlir::Value genShape(mlir::Location loc, llvm::ArrayRef<mlir::Value> shift,
                       llvm::ArrayRef<mlir::Value> exts);
  mlir::Value genShape(mlir::Location loc, llvm::ArrayRef<mlir::Value> exts);
  mlir::Value genShift(mlir::Location loc, llvm::ArrayRef<mlir::Value> shift);

  mlir::Value createShape(mlir::Location loc, const fir::ExtendedValue &exv);

  mlir::Value createSlice(mlir::Location loc, const fir::ExtendedValue &exv,
                          mlir::ValueRange triples, mlir::ValueRange path);

  mlir::Value createBox(mlir::Location loc, const fir::ExtendedValue &exv,
                        bool isPolymorphic = false, bool isAssumedType = false,
                        unsigned corank = 0);
 
  mlir::Value createBox(mlir::Location loc, mlir::Type boxType,
                        mlir::Value addr, mlir::Value shape, mlir::Value slice,
                        llvm::ArrayRef<mlir::Value> lengths, mlir::Value tdesc);

  mlir::Value createBool(mlir::Location loc, bool b) {
    return createIntegerConstant(loc, getIntegerType(1), b ? 1 : 0);
  }
 
  //===--------------------------------------------------------------------===//
  // If-Then-Else generation helper
  //===--------------------------------------------------------------------===//

  class IfBuilder {
  public:
    IfBuilder(fir::IfOp ifOp, FirOpBuilder &builder)
        : ifOp{ifOp}, builder{builder} {}
    template <typename CC>
    IfBuilder &genThen(CC func) {
      builder.setInsertionPointToStart(&ifOp.getThenRegion().front());
      func();
      return *this;
    }
    template <typename CC>
    IfBuilder &genElse(CC func) {
      assert(!ifOp.getElseRegion().empty() && "must have else region");
      builder.setInsertionPointToStart(&ifOp.getElseRegion().front());
      func();
      return *this;
    }
    void end() { builder.setInsertionPointAfter(ifOp); }

    mlir::Operation::result_range getResults() {
      end();
      return ifOp.getResults();
    }
 
    fir::IfOp &getIfOp() { return ifOp; };
 
  private:
    fir::IfOp ifOp;
    FirOpBuilder &builder;
  };

  IfBuilder genIfOp(mlir::Location loc, mlir::TypeRange results,
                    mlir::Value cdt, bool withElseRegion) {
    auto op = fir::IfOp::create(*this, loc, results, cdt, withElseRegion);
    return IfBuilder(op, *this);
  }

  IfBuilder genIfThen(mlir::Location loc, mlir::Value cdt) {
    auto op = fir::IfOp::create(*this, loc, mlir::TypeRange(), cdt, false);
    return IfBuilder(op, *this);
  }

  IfBuilder genIfThenElse(mlir::Location loc, mlir::Value cdt) {
    auto op = fir::IfOp::create(*this, loc, mlir::TypeRange(), cdt, true);
    return IfBuilder(op, *this);
  }
 
  mlir::Value genNot(mlir::Location loc, mlir::Value boolean) {
    return mlir::arith::CmpIOp::create(*this, loc,
                                       mlir::arith::CmpIPredicate::eq, boolean,
                                       createBool(loc, false));
  }

  mlir::Value genIsNotNullAddr(mlir::Location loc, mlir::Value addr);

  mlir::Value genIsNullAddr(mlir::Location loc, mlir::Value addr);

  mlir::Value genExtentFromTriplet(mlir::Location loc, mlir::Value lb,
                                   mlir::Value ub, mlir::Value step,
                                   mlir::Type type, bool fold = false);

  mlir::Value genAbsentOp(mlir::Location loc, mlir::Type argTy);

  void setFastMathFlags(mlir::arith::FastMathFlags flags) {
    fastMathFlags = flags;
  }

  void setFastMathFlags(Fortran::common::MathOptionsBase options);

  mlir::arith::FastMathFlags getFastMathFlags() const { return fastMathFlags; }

  std::string getFastMathFlagsString() {
    mlir::arith::FastMathFlags flags = getFastMathFlags();
    if (flags == mlir::arith::FastMathFlags::none)
      return {};
 
    std::string fmfString{mlir::arith::stringifyFastMathFlags(flags)};
    std::replace(fmfString.begin(), fmfString.end(), ',', '_');
    return fmfString;
  }

  class FastMathFlagGuard {
  public:
    FastMathFlagGuard(FirOpBuilder &builder, mlir::arith::FastMathFlags flags)
        : builder{builder}, savedFlags{builder.getFastMathFlags()} {
      builder.setFastMathFlags(flags);
    }
    FastMathFlagGuard(const FastMathFlagGuard &) = delete;
    FastMathFlagGuard &operator=(const FastMathFlagGuard &) = delete;
    ~FastMathFlagGuard() { builder.setFastMathFlags(savedFlags); }
 
  private:
    FirOpBuilder &builder;
    mlir::arith::FastMathFlags savedFlags;
  };

  void setIntegerOverflowFlags(mlir::arith::IntegerOverflowFlags flags) {
    integerOverflowFlags = flags;
  }

  mlir::arith::IntegerOverflowFlags getIntegerOverflowFlags() const {
    return integerOverflowFlags;
  }

  void setComplexDivisionToRuntimeFlag(bool flag) {
    complexDivisionToRuntimeFlag = flag;
  }

  bool getComplexDivisionToRuntimeFlag() const {
    return complexDivisionToRuntimeFlag;
  }

  void setFPMaxminBehavior(Fortran::common::FPMaxminBehavior mode) {
    fpMaxminBehavior = mode;
  }
  Fortran::common::FPMaxminBehavior getFPMaxminBehavior() const {
    return fpMaxminBehavior;
  }

  LLVM_DUMP_METHOD void dumpFunc();

  void notifyOperationInserted(mlir::Operation *op,
                               mlir::OpBuilder::InsertPoint previous) override {
    // We only care about newly created operations.
    if (previous.isSet())
      return;
    setCommonAttributes(op);
  }

  mlir::DataLayout &getDataLayout();

  template <typename OpTy>
  mlir::Value createUnsigned(mlir::Location loc, mlir::Type resultType,
                             mlir::Value left, mlir::Value right) {
    if (!resultType.isIntOrFloat())
      return OpTy::create(*this, loc, resultType, left, right);
    mlir::Type signlessType = mlir::IntegerType::get(
        getContext(), resultType.getIntOrFloatBitWidth(),
        mlir::IntegerType::SignednessSemantics::Signless);
    mlir::Type opResType = resultType;
    if (left.getType().isUnsignedInteger()) {
      left = createConvert(loc, signlessType, left);
      opResType = signlessType;
    }
    if (right.getType().isUnsignedInteger()) {
      right = createConvert(loc, signlessType, right);
      opResType = signlessType;
    }
    mlir::Value result = OpTy::create(*this, loc, opResType, left, right);
    if (resultType.isUnsignedInteger())
      result = createConvert(loc, resultType, result);
    return result;
  }

  mlir::Value genPtrCompare(mlir::Location loc,
                            mlir::arith::CmpIPredicate predicate,
                            mlir::Value ptr1, mlir::Value ptr2) {
    ptr1 = createConvert(loc, getIndexType(), ptr1);
    ptr2 = createConvert(loc, getIndexType(), ptr2);
    return mlir::arith::CmpIOp::create(*this, loc, predicate, ptr1, ptr2);
  }
 
private:
  void setCommonAttributes(mlir::Operation *op) const;
 
  KindMapping kindMap;

  mlir::arith::FastMathFlags fastMathFlags{};

  Fortran::common::FPMaxminBehavior fpMaxminBehavior{
      Fortran::common::FPMaxminBehavior::Legacy};

  mlir::arith::IntegerOverflowFlags integerOverflowFlags{};

  bool complexDivisionToRuntimeFlag = true;

  mlir::SymbolTable *symbolTable = nullptr;

  std::unique_ptr<mlir::DataLayout> dataLayout = nullptr;
};
 
} // namespace fir
 
namespace fir::factory {
 
using fir::genDimInfoFromBox;
 
//===----------------------------------------------------------------------===//
// ExtendedValue inquiry helpers
//===----------------------------------------------------------------------===//

mlir::Value readCharLen(fir::FirOpBuilder &builder, mlir::Location loc,
                        const fir::ExtendedValue &box);

mlir::Value readExtent(fir::FirOpBuilder &builder, mlir::Location loc,
                       const fir::ExtendedValue &box, unsigned dim);

mlir::Value readLowerBound(fir::FirOpBuilder &builder, mlir::Location loc,
                           const fir::ExtendedValue &box, unsigned dim,
                           mlir::Value defaultValue);

llvm::SmallVector<mlir::Value> readExtents(fir::FirOpBuilder &builder,
                                           mlir::Location loc,
                                           const fir::BoxValue &box);

fir::ExtendedValue readBoxValue(fir::FirOpBuilder &builder, mlir::Location loc,
                                const fir::BoxValue &box);

llvm::SmallVector<mlir::Value>
getNonDefaultLowerBounds(fir::FirOpBuilder &builder, mlir::Location loc,
                         const fir::ExtendedValue &exv);
 
//===----------------------------------------------------------------------===//
// String literal helper helpers
//===----------------------------------------------------------------------===//

fir::ExtendedValue createStringLiteral(fir::FirOpBuilder &, mlir::Location,
                                       llvm::StringRef string);

std::string uniqueCGIdent(llvm::StringRef prefix, llvm::StringRef name);

llvm::SmallVector<mlir::Value> createExtents(fir::FirOpBuilder &builder,
                                             mlir::Location loc,
                                             fir::SequenceType seqTy);
 
//===--------------------------------------------------------------------===//
// Location helpers
//===--------------------------------------------------------------------===//

mlir::Value locationToFilename(fir::FirOpBuilder &, mlir::Location);
mlir::Value locationToLineNo(fir::FirOpBuilder &, mlir::Location, mlir::Type);
 
//===--------------------------------------------------------------------===//
// ExtendedValue helpers
//===--------------------------------------------------------------------===//

fir::ExtendedValue componentToExtendedValue(fir::FirOpBuilder &builder,
                                            mlir::Location loc,
                                            mlir::Value component);

fir::ExtendedValue arrayElementToExtendedValue(fir::FirOpBuilder &builder,
                                               mlir::Location loc,
                                               const fir::ExtendedValue &array,
                                               mlir::Value element);

fir::ExtendedValue arraySectionElementToExtendedValue(
    fir::FirOpBuilder &builder, mlir::Location loc,
    const fir::ExtendedValue &array, mlir::Value element, mlir::Value slice);

void genScalarAssignment(fir::FirOpBuilder &builder, mlir::Location loc,
                         const fir::ExtendedValue &lhs,
                         const fir::ExtendedValue &rhs,
                         bool needFinalization = false,
                         bool isTemporaryLHS = false,
                         mlir::ArrayAttr accessGroups = {});

void genRecordAssignment(fir::FirOpBuilder &builder, mlir::Location loc,
                         const fir::ExtendedValue &lhs,
                         const fir::ExtendedValue &rhs,
                         bool needFinalization = false,
                         bool isTemporaryLHS = false);

mlir::Value createZeroValue(fir::FirOpBuilder &builder, mlir::Location loc,
                            mlir::Type type);

mlir::Value createOneValue(fir::FirOpBuilder &builder, mlir::Location loc,
                           mlir::Type type);

mlir::Value computeExtent(fir::FirOpBuilder &builder, mlir::Location loc,
                          mlir::Value lb, mlir::Value ub);
mlir::Value computeExtent(fir::FirOpBuilder &builder, mlir::Location loc,
                          mlir::Value lb, mlir::Value ub, mlir::Value zero,
                          mlir::Value one);

mlir::Value genMaxWithZero(fir::FirOpBuilder &builder, mlir::Location loc,
                           mlir::Value value);
mlir::Value genMaxWithZero(fir::FirOpBuilder &builder, mlir::Location loc,
                           mlir::Value value, mlir::Value zero);

mlir::Value genCPtrOrCFunptrAddr(fir::FirOpBuilder &builder, mlir::Location loc,
                                 mlir::Value cPtr, mlir::Type ty);

mlir::Value genCPtrOrCFunptrValue(fir::FirOpBuilder &builder,
                                  mlir::Location loc, mlir::Value cPtr);

fir::BoxValue createBoxValue(fir::FirOpBuilder &builder, mlir::Location loc,
                             const fir::ExtendedValue &exv,
                             unsigned corank = 0);

mlir::Value createNullBoxProc(fir::FirOpBuilder &builder, mlir::Location loc,
                              mlir::Type boxType);

mlir::Value createConvert(mlir::OpBuilder &, mlir::Location, mlir::Type,
                          mlir::Value);

void setInternalLinkage(mlir::func::FuncOp);
 
llvm::SmallVector<mlir::Value>
elideExtentsAlreadyInType(mlir::Type type, mlir::ValueRange shape);
 
llvm::SmallVector<mlir::Value>
elideLengthsAlreadyInType(mlir::Type type, mlir::ValueRange lenParams);

uint64_t getAllocaAddressSpace(const mlir::DataLayout *dataLayout);

llvm::SmallVector<mlir::Value> deduceOptimalExtents(mlir::ValueRange extents1,
                                                    mlir::ValueRange extents2);
 
uint64_t getGlobalAddressSpace(mlir::DataLayout *dataLayout);
 
uint64_t getProgramAddressSpace(mlir::DataLayout *dataLayout);

llvm::SmallVector<mlir::Value> updateRuntimeExtentsForEmptyArrays(
    fir::FirOpBuilder &builder, mlir::Location loc, mlir::ValueRange extents);

mlir::Value genLifetimeStart(mlir::OpBuilder &builder, mlir::Location loc,
                             fir::AllocaOp alloc, const mlir::DataLayout *dl);

void genLifetimeEnd(mlir::OpBuilder &builder, mlir::Location loc,
                    mlir::Value mem);

mlir::Value getDescriptorWithNewBaseAddress(fir::FirOpBuilder &builder,
                                            mlir::Location loc, mlir::Value box,
                                            mlir::Value newAddr);

std::optional<mlir::Value>
genIndexBasedDisjointnessCheck(mlir::Location loc, fir::FirOpBuilder &builder,
                               mlir::Value lhsRef, mlir::Value rhsRef);

std::optional<mlir::Value>
genAddressBasedDisjointnessCheck(mlir::Location loc, fir::FirOpBuilder &builder,
                                 mlir::Value lhsRef, mlir::Value rhsRef);
 
} // namespace fir::factory
 
#endif // FORTRAN_OPTIMIZER_BUILDER_FIRBUILDER_H