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
//
//===----------------------------------------------------------------------===//
//
// Coding style: https://mlir.llvm.org/getting_started/DeveloperGuide/
//
//===----------------------------------------------------------------------===//
 
#ifndef FORTRAN_LOWER_ABSTRACTCONVERTER_H
#define FORTRAN_LOWER_ABSTRACTCONVERTER_H
 
#include "flang/Lower/LoweringOptions.h"
#include "flang/Lower/PFTDefs.h"
#include "flang/Lower/Support/Utils.h"
#include "flang/Optimizer/Builder/BoxValue.h"
#include "flang/Optimizer/Dialect/FIRAttr.h"
#include "flang/Semantics/symbol.h"
#include "flang/Support/Fortran.h"
#include "mlir/IR/Builders.h"
#include "mlir/IR/BuiltinOps.h"
#include "mlir/IR/Operation.h"
#include "llvm/ADT/ArrayRef.h"
#include "llvm/ADT/DenseMap.h"
 
namespace mlir {
class SymbolTable;
class StateStack;
}
 
namespace fir {
class KindMapping;
class FirOpBuilder;
} // namespace fir
 
namespace Fortran {
namespace common {
template <typename>
class Reference;
}
 
namespace evaluate {
struct DataRef;
template <typename>
class Expr;
class FoldingContext;
struct SomeType;
} // namespace evaluate
 
namespace parser {
class CharBlock;
}
namespace semantics {
class Symbol;
class Scope;
class DerivedTypeSpec;
} // namespace semantics
 
namespace lower {
class SymMap;
struct SymbolBox;
namespace pft {
struct Variable;
struct FunctionLikeUnit;
} // namespace pft
 
using SomeExpr = Fortran::evaluate::Expr<Fortran::evaluate::SomeType>;
using SymbolRef = Fortran::common::Reference<const Fortran::semantics::Symbol>;
using TypeConstructionStack =
    llvm::DenseMap<const Fortran::semantics::Scope *, mlir::Type>;
class StatementContext;
 
using ExprToValueMap = llvm::DenseMap<const SomeExpr *, mlir::Value>;
 
//===----------------------------------------------------------------------===//
// AbstractConverter interface
//===----------------------------------------------------------------------===//

class AbstractConverter {
public:
  //===--------------------------------------------------------------------===//
  // Symbols
  //===--------------------------------------------------------------------===//

  virtual mlir::Value getSymbolAddress(SymbolRef sym) = 0;
 
  virtual fir::ExtendedValue
  symBoxToExtendedValue(const Fortran::lower::SymbolBox &symBox) = 0;
 
  virtual fir::ExtendedValue
  getSymbolExtendedValue(const Fortran::semantics::Symbol &sym,
                         Fortran::lower::SymMap *symMap = nullptr) = 0;

  virtual mlir::Value impliedDoBinding(llvm::StringRef name) = 0;

  virtual void copySymbolBinding(SymbolRef src, SymbolRef target) = 0;

  virtual void bindSymbol(SymbolRef sym, const fir::ExtendedValue &exval) = 0;

  virtual void
  bindSymbolStorage(SymbolRef sym,
                    Fortran::lower::SymMap::StorageDesc storage) = 0;

  virtual Fortran::lower::SymMap::StorageDesc
  getSymbolStorage(SymbolRef sym) = 0;

  virtual Fortran::lower::SymMap &getSymbolMap() = 0;

  virtual void overrideExprValues(const ExprToValueMap *) = 0;
  void resetExprOverrides() { overrideExprValues(nullptr); }
  virtual const ExprToValueMap *getExprOverrides() = 0;

  virtual bool lookupLabelSet(SymbolRef sym, pft::LabelSet &labelSet) = 0;

  virtual pft::Evaluation *lookupLabel(pft::Label label) = 0;

  virtual bool
  createHostAssociateVarClone(const Fortran::semantics::Symbol &sym,
                              bool skipDefaultInit) = 0;
 
  virtual void
  createHostAssociateVarCloneDealloc(const Fortran::semantics::Symbol &sym) = 0;

  virtual void
  copyHostAssociateVar(const Fortran::semantics::Symbol &sym,
                       mlir::OpBuilder::InsertPoint *copyAssignIP = nullptr,
                       bool hostIsSource = true) = 0;
 
  virtual void copyVar(mlir::Location loc, mlir::Value dst, mlir::Value src,
                       fir::FortranVariableFlagsEnum attrs) = 0;

  virtual bool
  isPresentShallowLookup(const Fortran::semantics::Symbol &sym) = 0;

  virtual void collectSymbolSet(
      pft::Evaluation &eval,
      llvm::SetVector<const Fortran::semantics::Symbol *> &symbolSet,
      Fortran::semantics::Symbol::Flag flag, bool collectSymbols = true,
      bool collectHostAssociatedSymbols = false) = 0;

  virtual llvm::StringRef
  getUniqueLitName(mlir::Location loc,
                   std::unique_ptr<Fortran::lower::SomeExpr> expression,
                   mlir::Type eleTy) = 0;
 
  //===--------------------------------------------------------------------===//
  // Expressions
  //===--------------------------------------------------------------------===//

  virtual fir::ExtendedValue genExprAddr(const SomeExpr &expr,
                                         StatementContext &context,
                                         mlir::Location *locPtr = nullptr) = 0;

  fir::ExtendedValue genExprAddr(mlir::Location loc, const SomeExpr *expr,
                                 StatementContext &stmtCtx) {
    return genExprAddr(*expr, stmtCtx, &loc);
  }
  fir::ExtendedValue genExprAddr(mlir::Location loc, const SomeExpr &expr,
                                 StatementContext &stmtCtx) {
    return genExprAddr(expr, stmtCtx, &loc);
  }

  virtual fir::ExtendedValue genExprValue(const SomeExpr &expr,
                                          StatementContext &context,
                                          mlir::Location *locPtr = nullptr) = 0;

  fir::ExtendedValue genExprValue(mlir::Location loc, const SomeExpr *expr,
                                  StatementContext &stmtCtx) {
    return genExprValue(*expr, stmtCtx, &loc);
  }
  fir::ExtendedValue genExprValue(mlir::Location loc, const SomeExpr &expr,
                                  StatementContext &stmtCtx) {
    return genExprValue(expr, stmtCtx, &loc);
  }

  virtual fir::ExtendedValue genExprBox(mlir::Location loc,
                                        const SomeExpr &expr,
                                        StatementContext &stmtCtx) = 0;

  virtual fir::MutableBoxValue genExprMutableBox(mlir::Location loc,
                                                 const SomeExpr &expr) = 0;

  virtual Fortran::evaluate::FoldingContext &getFoldingContext() = 0;

  virtual mlir::Value hostAssocTupleValue() = 0;

  virtual void bindHostAssocTuple(mlir::Value val) = 0;

  virtual mlir::Value dummyArgsScopeValue() const = 0;

  virtual bool
  isRegisteredDummySymbol(Fortran::semantics::SymbolRef symRef) const = 0;

  virtual const Fortran::lower::pft::FunctionLikeUnit *
  getCurrentFunctionUnit() const = 0;

  virtual void checkCoarrayEnabled() = 0;
 
  //===--------------------------------------------------------------------===//
  // Types
  //===--------------------------------------------------------------------===//

  virtual mlir::Type genType(const SomeExpr &) = 0;
  virtual mlir::Type genType(SymbolRef) = 0;
  virtual mlir::Type genType(Fortran::common::TypeCategory tc) = 0;
  virtual mlir::Type
  genType(Fortran::common::TypeCategory tc, int kind,
          llvm::ArrayRef<std::int64_t> lenParameters = {}) = 0;
  virtual mlir::Type genType(const Fortran::semantics::DerivedTypeSpec &) = 0;
  virtual mlir::Type genType(const pft::Variable &) = 0;

  virtual void
  registerTypeInfo(mlir::Location loc, SymbolRef typeInfoSym,
                   const Fortran::semantics::DerivedTypeSpec &typeSpec,
                   fir::RecordType type) = 0;

  virtual TypeConstructionStack &getTypeConstructionStack() = 0;
 
  //===--------------------------------------------------------------------===//
  // Locations
  //===--------------------------------------------------------------------===//

  virtual mlir::Location getCurrentLocation() = 0;
  virtual mlir::Location genUnknownLocation() = 0;
  virtual mlir::Location genLocation(const Fortran::parser::CharBlock &) = 0;

  virtual const Fortran::semantics::Scope &getCurrentScope() = 0;
 
  //===--------------------------------------------------------------------===//
  // FIR/MLIR
  //===--------------------------------------------------------------------===//

  virtual fir::FirOpBuilder &getFirOpBuilder() = 0;
  virtual mlir::ModuleOp getModuleOp() = 0;
  virtual mlir::MLIRContext &getMLIRContext() = 0;
  virtual std::string mangleName(const Fortran::semantics::Symbol &) = 0;
  virtual std::string
  mangleName(const Fortran::semantics::DerivedTypeSpec &) = 0;
  virtual std::string mangleName(std::string &) = 0;
  virtual std::string mangleName(std::string &, const semantics::Scope &) = 0;
  virtual std::string
  getRecordTypeFieldName(const Fortran::semantics::Symbol &component) = 0;

  virtual const fir::KindMapping &getKindMap() = 0;
 
  virtual Fortran::lower::StatementContext &getFctCtx() = 0;
 
  AbstractConverter(const Fortran::lower::LoweringOptions &loweringOptions)
      : loweringOptions(loweringOptions) {}
  virtual ~AbstractConverter() = default;
 
  //===--------------------------------------------------------------------===//
  // Miscellaneous
  //===--------------------------------------------------------------------===//

  virtual void genEval(pft::Evaluation &eval,
                       bool unstructuredContext = true) = 0;

  const Fortran::lower::LoweringOptions &getLoweringOptions() const {
    return loweringOptions;
  }

  virtual Fortran::lower::SymbolBox
  lookupOneLevelUpSymbol(const Fortran::semantics::Symbol &sym) = 0;

  virtual Fortran::lower::SymbolBox
  shallowLookupSymbol(const Fortran::semantics::Symbol &sym) = 0;

  virtual mlir::SymbolTable *getMLIRSymbolTable() = 0;
 
  virtual mlir::StateStack &getStateStack() = 0;
 
private:
  const Fortran::lower::LoweringOptions &loweringOptions;
};
 
} // namespace lower
} // namespace Fortran
 
#endif // FORTRAN_LOWER_ABSTRACTCONVERTER_H