HLFIRDialect.h

//===- HLFIRDialect.h - High Level Fortran IR dialect -----------*- 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
//
//===----------------------------------------------------------------------===//
//
// This file defines the HLFIR dialect that models Fortran expressions and
// assignments without requiring storage allocation and manipulations.
//
//===----------------------------------------------------------------------===//
 
#ifndef FORTRAN_OPTIMIZER_HLFIR_HLFIRDIALECT_H
#define FORTRAN_OPTIMIZER_HLFIR_HLFIRDIALECT_H
 
#include "flang/Optimizer/Dialect/FIRType.h"
#include "mlir/IR/Dialect.h"
 
namespace hlfir {
bool isFortranVariableType(mlir::Type);
bool isFortranScalarCharacterType(mlir::Type);
bool isFortranScalarCharacterExprType(mlir::Type);
bool isFortranArrayCharacterExprType(mlir::Type);
} // namespace hlfir
 
#include "flang/Optimizer/HLFIR/HLFIRDialect.h.inc"
 
#include "flang/Optimizer/HLFIR/HLFIREnums.h.inc"
 
#define GET_TYPEDEF_CLASSES
#include "flang/Optimizer/HLFIR/HLFIRTypes.h.inc"
 
#define GET_ATTRDEF_CLASSES
#include "flang/Optimizer/HLFIR/HLFIRAttributes.h.inc"
 
namespace hlfir {
inline mlir::Type getFortranElementType(mlir::Type type) {
  type = fir::unwrapSequenceType(
      fir::unwrapPassByRefType(fir::unwrapRefType(type)));
  if (auto exprType = mlir::dyn_cast<hlfir::ExprType>(type))
    return exprType.getEleTy();
  if (auto boxCharType = mlir::dyn_cast<fir::BoxCharType>(type))
    return boxCharType.getEleTy();
  return type;
}

inline mlir::Type getFortranElementOrSequenceType(mlir::Type type) {
  type = fir::unwrapPassByRefType(fir::unwrapRefType(type));
  if (auto exprType = mlir::dyn_cast<hlfir::ExprType>(type)) {
    if (exprType.isArray())
      return fir::SequenceType::get(exprType.getShape(), exprType.getEleTy());
    return exprType.getEleTy();
  }
  if (auto boxCharType = mlir::dyn_cast<fir::BoxCharType>(type))
    return boxCharType.getEleTy();
  return type;
}

mlir::Type getExprType(mlir::Type variableType);

inline bool isBoxAddressType(mlir::Type type) {
  type = fir::dyn_cast_ptrEleTy(type);
  return type && mlir::isa<fir::BaseBoxType>(type);
}

inline bool isBoxAddressOrValueType(mlir::Type type) {
  return mlir::isa<fir::BaseBoxType>(fir::unwrapRefType(type));
}
 
inline bool isPolymorphicType(mlir::Type type) {
  if (auto exprType = mlir::dyn_cast<hlfir::ExprType>(type))
    return exprType.isPolymorphic();
  return fir::isPolymorphicType(type);
}

inline bool isFortranProcedurePointerType(mlir::Type type) {
  return fir::isBoxProcAddressType(type);
}
 
inline bool isFortranPointerObjectType(mlir::Type type) {
  auto boxTy =
      llvm::dyn_cast_or_null<fir::BaseBoxType>(fir::dyn_cast_ptrEleTy(type));
  return boxTy && boxTy.isPointer();
}

inline bool isFortranProcedureValue(mlir::Type type) {
  return mlir::isa<fir::BoxProcType>(type) ||
         (mlir::isa<mlir::TupleType>(type) &&
          fir::isCharacterProcedureTuple(type, /*acceptRawFunc=*/false));
}

inline bool isFortranValueType(mlir::Type type) {
  return mlir::isa<hlfir::ExprType>(type) || fir::isa_trivial(type) ||
         isFortranProcedureValue(type);
}

inline bool isFortranValue(mlir::Value value) {
  return isFortranValueType(value.getType());
}

inline bool isFortranEntity(mlir::Value value) {
  return isFortranValue(value) || isFortranVariableType(value.getType());
}
 
bool isFortranScalarNumericalType(mlir::Type);
bool isFortranNumericalArrayObject(mlir::Type);
bool isFortranNumericalOrLogicalArrayObject(mlir::Type);
bool isFortranArrayObject(mlir::Type);
bool isFortranLogicalArrayObject(mlir::Type);
bool isPassByRefOrIntegerType(mlir::Type);
bool isI1Type(mlir::Type);
// scalar i1 or logical, or sequence of logical (via (boxed?) array or expr)
bool isMaskArgument(mlir::Type);
bool isPolymorphicObject(mlir::Type);

mlir::Value genExprShape(mlir::OpBuilder &builder, const mlir::Location &loc,
                         const hlfir::ExprType &expr);

bool mayHaveAllocatableComponent(mlir::Type ty);

bool isFortranIntegerScalarOrArrayObject(mlir::Type type);
 
} // namespace hlfir
 
#endif // FORTRAN_OPTIMIZER_HLFIR_HLFIRDIALECT_H