ConvertType.h

//===-- Lower/ConvertType.h -- lowering of 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_LOWER_CONVERT_TYPE_H
#define FORTRAN_LOWER_CONVERT_TYPE_H
 
#include "flang/Evaluate/type.h"
#include "flang/Support/Fortran.h"
#include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/IR/BuiltinTypes.h"
 
namespace mlir {
class Location;
class MLIRContext;
class Type;
} // namespace mlir
 
namespace Fortran {
namespace common {
template <typename>
class Reference;
} // namespace common
 
namespace evaluate {
template <typename>
class Expr;
template <typename>
class FunctionRef;
struct SomeType;
} // namespace evaluate
 
namespace semantics {
class Symbol;
class DerivedTypeSpec;
class DerivedTypeDetails;
class Scope;
} // namespace semantics
 
namespace lower {
class AbstractConverter;
namespace pft {
struct Variable;
}
 
using SomeExpr = evaluate::Expr<evaluate::SomeType>;
using SymbolRef = common::Reference<const semantics::Symbol>;
 
// Type for compile time constant length type parameters.
using LenParameterTy = std::int64_t;

mlir::Type getFIRType(mlir::MLIRContext *ctxt, common::TypeCategory tc,
                      int kind, llvm::ArrayRef<LenParameterTy>);

mlir::Type
translateDerivedTypeToFIRType(Fortran::lower::AbstractConverter &,
                              const Fortran::semantics::DerivedTypeSpec &);

mlir::Type translateSomeExprToFIRType(Fortran::lower::AbstractConverter &,
                                      const SomeExpr &expr);

mlir::Type translateSymbolToFIRType(Fortran::lower::AbstractConverter &,
                                    const SymbolRef symbol);

mlir::Type translateVariableToFIRType(Fortran::lower::AbstractConverter &,
                                      const pft::Variable &variable);

mlir::Type convertReal(mlir::MLIRContext *ctxt, int KIND);
 
bool isDerivedTypeWithLenParameters(const semantics::Symbol &);
 
template <typename T>
class TypeBuilder {
public:
  static mlir::Type genType(Fortran::lower::AbstractConverter &,
                            const Fortran::evaluate::FunctionRef<T> &);
};
using namespace evaluate;
FOR_EACH_SPECIFIC_TYPE(extern template class TypeBuilder, )
 

class ComponentReverseIterator {
public:
  ComponentReverseIterator(const Fortran::semantics::DerivedTypeSpec &derived) {
    setCurrentType(derived);
  }
  bool lookup(const Fortran::parser::CharBlock &name) {
    componentIt = std::find(componentIt, componentItEnd, name);
    return componentIt != componentItEnd;
  };

  const Fortran::semantics::DerivedTypeSpec &advanceToParentType();

  const Fortran::semantics::Symbol *getParentComponent() const;
 
private:
  void setCurrentType(const Fortran::semantics::DerivedTypeSpec &derived);
  const Fortran::semantics::DerivedTypeSpec *currentParentType = nullptr;
  const Fortran::semantics::DerivedTypeDetails *currentTypeDetails = nullptr;
  using name_iterator =
      std::list<Fortran::parser::CharBlock>::const_reverse_iterator;
  name_iterator componentIt{};
  name_iterator componentItEnd{};
};
 
mlir::arith::CmpIPredicate
translateSignedRelational(Fortran::common::RelationalOperator rop);
mlir::arith::CmpIPredicate
translateUnsignedRelational(Fortran::common::RelationalOperator rop);
mlir::arith::CmpFPredicate
translateFloatRelational(Fortran::common::RelationalOperator rop);
} // namespace lower
} // namespace Fortran
 
#endif // FORTRAN_LOWER_CONVERT_TYPE_H