FIRType.h

//===-- Optimizer/Dialect/FIRType.h -- FIR types ----------------*- 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
//
//===----------------------------------------------------------------------===//
//
// Coding style: https://mlir.llvm.org/getting_started/DeveloperGuide/
//
//===----------------------------------------------------------------------===//
 
#ifndef FORTRAN_OPTIMIZER_DIALECT_FIRTYPE_H
#define FORTRAN_OPTIMIZER_DIALECT_FIRTYPE_H
 
#include "mlir/IR/BuiltinAttributes.h"
#include "mlir/IR/BuiltinTypes.h"
#include "mlir/Interfaces/DataLayoutInterfaces.h"
#include "llvm/ADT/SmallVector.h"
#include "llvm/IR/Type.h"
 
namespace fir {
class FIROpsDialect;
class KindMapping;
using KindTy = unsigned;
 
namespace detail {
struct RecordTypeStorage;
} // namespace detail
 
} // namespace fir
 
//===----------------------------------------------------------------------===//
// BaseBoxType
//===----------------------------------------------------------------------===//
 
namespace fir {

class BaseBoxType : public mlir::Type {
public:
  using mlir::Type::Type;

  enum class Attribute { None, Allocatable, Pointer };

  mlir::Type getEleTy() const;

  mlir::Type getBaseAddressType() const;

  mlir::Type unwrapInnerType() const;
 
  // Get the element type or the fir.array
  mlir::Type getElementOrSequenceType() const;

  bool isAssumedRank() const;

  bool isPointer() const;

  bool isPointerOrAllocatable() const;

  bool isVolatile() const;

  BaseBoxType getBoxTypeWithNewShape(mlir::Type shapeMold) const;
  BaseBoxType getBoxTypeWithNewShape(int rank) const;

  BaseBoxType getBoxTypeWithNewAttr(Attribute attr) const;

  static bool classof(mlir::Type type);
};
 
} // namespace fir
 
#define GET_TYPEDEF_CLASSES
#include "flang/Optimizer/Dialect/FIROpsTypes.h.inc"
 
namespace llvm {
class raw_ostream;
class StringRef;
template <typename>
class ArrayRef;
class hash_code;
} // namespace llvm
 
namespace mlir {
class DialectAsmParser;
class DialectAsmPrinter;
class ComplexType;
class FloatType;
class ValueRange;
} // namespace mlir
 
namespace fir {
namespace detail {
struct RecordTypeStorage;
} // namespace detail
 
// These isa_ routines follow the precedent of llvm::isa_or_null<>

bool isa_fir_type(mlir::Type t);

bool isa_std_type(mlir::Type t);

bool isa_fir_or_std_type(mlir::Type t);

inline bool isa_ref_type(mlir::Type t) {
  return mlir::isa<fir::ReferenceType, fir::PointerType, fir::HeapType,
                   fir::LLVMPointerType>(t);
}

inline bool isa_box_type(mlir::Type t) {
  return mlir::isa<fir::BaseBoxType, fir::BoxCharType, fir::BoxProcType>(t);
}

inline bool isa_passbyref_type(mlir::Type t) {
  return mlir::isa<fir::ReferenceType, mlir::FunctionType>(t) ||
         isa_box_type(t);
}

inline bool conformsWithPassByRef(mlir::Type t) {
  return isa_ref_type(t) || isa_box_type(t) || mlir::isa<mlir::FunctionType>(t);
}

inline bool isa_derived(mlir::Type t) { return mlir::isa<fir::RecordType>(t); }

inline bool isa_builtin_cptr_type(mlir::Type t) {
  if (auto recTy = mlir::dyn_cast_or_null<fir::RecordType>(t))
    return recTy.getName().ends_with("T__builtin_c_ptr") ||
           recTy.getName().ends_with("T__builtin_c_funptr");
  return false;
}
 
// Is `t` type(c_devptr)?
inline bool isa_builtin_c_devptr_type(mlir::Type t) {
  if (auto recTy = mlir::dyn_cast_or_null<fir::RecordType>(t))
    return recTy.getName().ends_with("T__builtin_c_devptr");
  return false;
}

inline bool isa_builtin_cdevptr_type(mlir::Type t) {
  if (auto recTy = mlir::dyn_cast_or_null<fir::RecordType>(t))
    return recTy.getName().ends_with("T__builtin_c_devptr");
  return false;
}

inline bool isa_aggregate(mlir::Type t) {
  return mlir::isa<SequenceType, mlir::TupleType>(t) || fir::isa_derived(t);
}

mlir::Type dyn_cast_ptrEleTy(mlir::Type t);

mlir::Type dyn_cast_ptrOrBoxEleTy(mlir::Type t);

inline bool isa_real(mlir::Type t) { return mlir::isa<mlir::FloatType>(t); }

inline bool isa_integer(mlir::Type t) {
  return mlir::isa<mlir::IndexType, mlir::IntegerType, fir::IntegerType>(t);
}

inline bool isa_vector(mlir::Type t) {
  return mlir::isa<mlir::VectorType, fir::VectorType>(t);
}
 
mlir::Type parseFirType(FIROpsDialect *, mlir::DialectAsmParser &parser);
 
void printFirType(FIROpsDialect *, mlir::Type ty, mlir::DialectAsmPrinter &p);

void verifyIntegralType(mlir::Type type);

inline bool isa_complex(mlir::Type t) {
  return mlir::isa<mlir::ComplexType>(t) &&
         mlir::isa<mlir::FloatType>(
             mlir::cast<mlir::ComplexType>(t).getElementType());
}

inline bool isa_char(mlir::Type t) { return mlir::isa<fir::CharacterType>(t); }

inline bool isa_trivial(mlir::Type t) {
  return isa_integer(t) || isa_real(t) || isa_complex(t) || isa_vector(t) ||
         mlir::isa<fir::LogicalType>(t);
}

inline bool isa_char_string(mlir::Type t) {
  if (auto ct = mlir::dyn_cast_or_null<fir::CharacterType>(t))
    return ct.getLen() != fir::CharacterType::singleton();
  return false;
}

bool isa_unknown_size_box(mlir::Type t);

bool isa_volatile_type(mlir::Type t);

inline bool characterWithDynamicLen(mlir::Type t) {
  if (auto charTy = mlir::dyn_cast<fir::CharacterType>(t))
    return charTy.hasDynamicLen();
  return false;
}

inline bool sequenceWithNonConstantShape(fir::SequenceType seqTy) {
  return seqTy.hasUnknownShape() || seqTy.hasDynamicExtents();
}

bool hasDynamicSize(mlir::Type t);
 
inline unsigned getRankOfShapeType(mlir::Type t) {
  if (auto shTy = mlir::dyn_cast<fir::ShapeType>(t))
    return shTy.getRank();
  if (auto shTy = mlir::dyn_cast<fir::ShapeShiftType>(t))
    return shTy.getRank();
  if (auto shTy = mlir::dyn_cast<fir::ShiftType>(t))
    return shTy.getRank();
  return 0;
}

inline mlir::Type boxMemRefType(fir::BaseBoxType t) {
  auto eleTy = t.getEleTy();
  if (!mlir::isa<fir::PointerType, fir::HeapType>(eleTy))
    eleTy = fir::ReferenceType::get(t);
  return eleTy;
}

inline mlir::Type unwrapSequenceType(mlir::Type t) {
  if (auto seqTy = mlir::dyn_cast<fir::SequenceType>(t))
    return seqTy.getEleTy();
  return t;
}

mlir::Type extractSequenceType(mlir::Type ty);
 
inline mlir::Type unwrapRefType(mlir::Type t) {
  if (auto eleTy = dyn_cast_ptrEleTy(t))
    return eleTy;
  return t;
}

inline mlir::Type unwrapPassByRefType(mlir::Type t) {
  if (auto eleTy = dyn_cast_ptrOrBoxEleTy(t))
    return eleTy;
  return t;
}

mlir::Type getFortranElementType(mlir::Type ty);

mlir::Type unwrapSeqOrBoxedSeqType(mlir::Type ty);

mlir::Type unwrapAllRefAndSeqType(mlir::Type ty);

inline fir::SequenceType unwrapUntilSeqType(mlir::Type t) {
  while (true) {
    if (!t)
      return {};
    if (auto ty = dyn_cast_ptrOrBoxEleTy(t)) {
      t = ty;
      continue;
    }
    if (auto seqTy = mlir::dyn_cast<fir::SequenceType>(t))
      return seqTy;
    return {};
  }
}

inline fir::RecordType unwrapIfDerived(fir::BaseBoxType boxTy) {
  return mlir::dyn_cast<fir::RecordType>(
      fir::unwrapSequenceType(fir::unwrapRefType(boxTy.getEleTy())));
}

inline bool isDerivedTypeWithLenParams(fir::BaseBoxType boxTy) {
  auto recTy = unwrapIfDerived(boxTy);
  return recTy && recTy.getNumLenParams() > 0;
}

inline bool isDerivedType(fir::BaseBoxType boxTy) {
  return static_cast<bool>(unwrapIfDerived(boxTy));
}
 
#ifndef NDEBUG
// !fir.ptr<X> and !fir.heap<X> where X is !fir.ptr, !fir.heap, or !fir.ref
// is undefined and disallowed.
inline bool singleIndirectionLevel(mlir::Type ty) {
  return !fir::isa_ref_type(ty);
}
#endif

bool isPointerType(mlir::Type ty);

bool isAllocatableType(mlir::Type ty);

bool isBoxNone(mlir::Type ty);

bool isBoxedRecordType(mlir::Type ty);

bool isTypeWithDescriptor(mlir::Type ty);

bool isScalarBoxedRecordType(mlir::Type ty);

mlir::Type getDerivedType(mlir::Type ty);

bool isPolymorphicType(mlir::Type ty);

bool isUnlimitedPolymorphicType(mlir::Type ty);

bool isClassStarType(mlir::Type ty);

bool isAssumedType(mlir::Type ty);

bool isAssumedShape(mlir::Type ty);

bool isAllocatableOrPointerArray(mlir::Type ty);

inline bool boxHasAddendum(fir::BaseBoxType boxTy) {
  return static_cast<bool>(unwrapIfDerived(boxTy)) ||
         fir::isUnlimitedPolymorphicType(boxTy);
}

unsigned getBoxRank(mlir::Type boxTy);

mlir::Type unwrapInnerType(mlir::Type ty);

bool isRecordWithAllocatableMember(mlir::Type ty);

bool isRecordWithDescriptorMember(mlir::Type ty);

inline bool isRecordWithTypeParameters(mlir::Type ty) {
  if (auto recTy = mlir::dyn_cast_or_null<fir::RecordType>(ty))
    return recTy.isDependentType();
  return false;
}

bool isCharacterProcedureTuple(mlir::Type type, bool acceptRawFunc = true);

mlir::Type applyPathToType(mlir::Type rootTy, mlir::ValueRange path);

bool hasAbstractResult(mlir::FunctionType ty);

mlir::Type fromRealTypeID(mlir::MLIRContext *context, llvm::Type::TypeID typeID,
                          fir::KindTy kind);
 
int getTypeCode(mlir::Type ty, const KindMapping &kindMap);
 
inline bool BaseBoxType::classof(mlir::Type type) {
  return mlir::isa<fir::BoxType, fir::ClassType>(type);
}

inline bool isNoneOrSeqNone(mlir::Type type) {
  if (auto seqTy = mlir::dyn_cast<fir::SequenceType>(type))
    return mlir::isa<mlir::NoneType>(seqTy.getEleTy());
  return mlir::isa<mlir::NoneType>(type);
}

inline mlir::Type wrapInClassOrBoxType(mlir::Type eleTy,
                                       bool isPolymorphic = false,
                                       bool isAssumedType = false) {
  if (isPolymorphic && !isAssumedType)
    return fir::ClassType::get(eleTy);
  return fir::BoxType::get(eleTy);
}

mlir::Type updateTypeWithVolatility(mlir::Type type, bool isVolatile);

inline mlir::Type updateTypeForUnlimitedPolymorphic(mlir::Type ty) {
  if (auto seqTy = mlir::dyn_cast<fir::SequenceType>(ty))
    return fir::SequenceType::get(
        seqTy.getShape(), updateTypeForUnlimitedPolymorphic(seqTy.getEleTy()));
  if (auto heapTy = mlir::dyn_cast<fir::HeapType>(ty))
    return fir::HeapType::get(
        updateTypeForUnlimitedPolymorphic(heapTy.getEleTy()));
  if (auto pointerTy = mlir::dyn_cast<fir::PointerType>(ty))
    return fir::PointerType::get(
        updateTypeForUnlimitedPolymorphic(pointerTy.getEleTy()));
  if (!mlir::isa<mlir::NoneType, fir::RecordType>(ty))
    return mlir::NoneType::get(ty.getContext());
  return ty;
}

mlir::Type updateTypeWithVolatility(mlir::Type type, bool isVolatile);

mlir::Type changeElementType(mlir::Type type, mlir::Type newElementType,
                             bool turnBoxIntoClass);

inline bool isBoxAddress(mlir::Type t) {
  return fir::isa_ref_type(t) &&
         mlir::isa<fir::BaseBoxType>(fir::unwrapRefType(t));
}

inline bool isBoxAddressOrValue(mlir::Type t) {
  return mlir::isa<fir::BaseBoxType>(fir::unwrapRefType(t));
}

inline bool isBoxProcAddressType(mlir::Type t) {
  t = fir::dyn_cast_ptrEleTy(t);
  return t && mlir::isa<fir::BoxProcType>(t);
}
 
inline bool isRefOfConstantSizeAggregateType(mlir::Type t) {
  t = fir::dyn_cast_ptrEleTy(t);
  return t &&
         mlir::isa<fir::CharacterType, fir::RecordType, fir::SequenceType>(t) &&
         !hasDynamicSize(t);
}

std::string getTypeAsString(mlir::Type ty, const KindMapping &kindMap,
                            llvm::StringRef prefix = "");


std::pair<std::uint64_t, unsigned short>
getTypeSizeAndAlignmentOrCrash(mlir::Location loc, mlir::Type ty,
                               const mlir::DataLayout &dl,
                               const fir::KindMapping &kindMap);

std::optional<std::pair<uint64_t, unsigned short>>
getTypeSizeAndAlignment(mlir::Location loc, mlir::Type ty,
                        const mlir::DataLayout &dl,
                        const fir::KindMapping &kindMap);
 
} // namespace fir
 
#endif // FORTRAN_OPTIMIZER_DIALECT_FIRTYPE_H