FIROpsSupport.h

//===-- Optimizer/Dialect/FIROpsSupport.h -- FIR op support -----*- 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
//
//===----------------------------------------------------------------------===//
 
#ifndef FORTRAN_OPTIMIZER_DIALECT_FIROPSSUPPORT_H
#define FORTRAN_OPTIMIZER_DIALECT_FIROPSSUPPORT_H
 
#include "flang/Optimizer/Dialect/FIROps.h"
#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/IR/BuiltinOps.h"
#include "llvm/ADT/APInt.h"
 
namespace fir {

inline void addVolatileMemoryEffects(
    mlir::TypeRange type,
    llvm::SmallVectorImpl<
        mlir::SideEffects::EffectInstance<mlir::MemoryEffects::Effect>>
        &effects) {
  for (mlir::Type t : type) {
    if (fir::isa_volatile_type(t)) {
      effects.emplace_back(mlir::MemoryEffects::Read::get(),
                           fir::VolatileMemoryResource::get());
      effects.emplace_back(mlir::MemoryEffects::Write::get(),
                           fir::VolatileMemoryResource::get());
      break;
    }
  }
}

inline bool isaCall(mlir::Operation *op) {
  return mlir::isa<fir::CallOp>(op) || mlir::isa<fir::DispatchOp>(op) ||
         mlir::isa<mlir::func::CallOp>(op) ||
         mlir::isa<mlir::func::CallIndirectOp>(op);
}

inline bool impureCall(mlir::Operation *op) {
  // Should we also auto-detect that the called function is pure if its
  // arguments are not references?  For now, rely on a "pure" attribute.
  return op && isaCall(op) && !op->getAttr("pure");
}

inline bool pureCall(mlir::Operation *op) {
  // Should we also auto-detect that the called function is pure if its
  // arguments are not references?  For now, rely on a "pure" attribute.
  return op && isaCall(op) && op->getAttr("pure");
}

mlir::func::FuncOp createFuncOp(mlir::Location loc, mlir::ModuleOp module,
                                llvm::StringRef name, mlir::FunctionType type,
                                llvm::ArrayRef<mlir::NamedAttribute> attrs = {},
                                const mlir::SymbolTable *symbolTable = nullptr);

fir::GlobalOp createGlobalOp(mlir::Location loc, mlir::ModuleOp module,
                             llvm::StringRef name, mlir::Type type,
                             llvm::ArrayRef<mlir::NamedAttribute> attrs = {},
                             const mlir::SymbolTable *symbolTable = nullptr);

constexpr llvm::StringRef getContiguousAttrName() { return "fir.contiguous"; }

constexpr llvm::StringRef getOptionalAttrName() { return "fir.optional"; }

static constexpr llvm::StringRef getTargetAttrName() { return "fir.target"; }

static constexpr llvm::StringRef getAsynchronousAttrName() {
  return "fir.asynchronous";
}

static constexpr llvm::StringRef getVolatileAttrName() {
  return "fir.volatile";
}

static constexpr llvm::StringRef getReadOnlyAttrName() {
  return "fir.read_only";
}

static constexpr llvm::StringRef getFortranAttrsAttrName() {
  return "fir.fortran_attrs";
}

static constexpr llvm::StringRef getCharacterProcedureDummyAttrName() {
  return "fir.char_proc";
}

static constexpr llvm::StringRef getSymbolAttrName() {
  return "fir.bindc_name";
}

static constexpr llvm::StringRef getHostAssocAttrName() {
  return "fir.host_assoc";
}

static constexpr llvm::StringRef getHostSymbolAttrName() {
  return "fir.host_symbol";
}

static constexpr llvm::StringRef getDefiningSubmoduleAttrName() {
  return "fir.defining_submodule";
}

static constexpr llvm::StringRef getInternalFuncNameAttrName() {
  return "fir.internal_name";
}

static constexpr llvm::StringRef getHasLifetimeMarkerAttrName() {
  return "fir.has_lifetime";
}

static constexpr llvm::StringRef getAccessGroupsAttrName() {
  return "access_groups";
}

static constexpr llvm::StringRef getUniqNameAttrName() { return "uniq_name"; }

constexpr llvm::StringRef getCorankAttrName() { return "fir.corank"; }

bool hasHostAssociationArgument(mlir::func::FuncOp func);

inline bool isInternalProcedure(mlir::func::FuncOp func) {
  return func->hasAttr(fir::getHostSymbolAttrName());
}

bool valueHasFirAttribute(mlir::Value value, llvm::StringRef attributeName);

bool valueMayHaveFirAttributes(mlir::Value value,
                               llvm::ArrayRef<llvm::StringRef> attributeNames);

bool anyFuncArgsHaveAttr(mlir::func::FuncOp func, llvm::StringRef attr);

std::optional<llvm::APInt> getIntIfConstant(mlir::Value value);
 
static constexpr llvm::StringRef getAdaptToByRefAttrName() {
  return "adapt.valuebyref";
}
 
static constexpr llvm::StringRef getFuncPureAttrName() {
  return "fir.func_pure";
}
 
static constexpr llvm::StringRef getFuncElementalAttrName() {
  return "fir.func_elemental";
}
 
static constexpr llvm::StringRef getFuncRecursiveAttrName() {
  return "fir.func_recursive";
}
 
static constexpr llvm::StringRef getFortranProcedureFlagsAttrName() {
  return "fir.proc_attrs";
}
 
// Attribute for an alloca that is a trivial adaptor for converting a value to
// pass-by-ref semantics for a VALUE parameter. The optimizer may be able to
// eliminate these.
// Template is used to avoid compiler errors in places that don't include
// FIRBuilder.h
template <typename Builder>
inline mlir::NamedAttribute getAdaptToByRefAttr(Builder &builder) {
  return {mlir::StringAttr::get(builder.getContext(),
                                fir::getAdaptToByRefAttrName()),
          builder.getUnitAttr()};
}
 
bool isDummyArgument(mlir::Value v);

enum class FortranDummyIntent { In, Out, InOut };

inline std::optional<FortranDummyIntent>
getFortranDummyIntent(mlir::func::FuncOp callee, unsigned argIdx) {
  if (!callee || argIdx >= callee.getNumArguments())
    return std::nullopt;
  auto attrs = callee.getArgAttrOfType<FortranVariableFlagsAttr>(
      argIdx, getFortranAttrsAttrName());
  if (!attrs)
    return std::nullopt;
  switch (attrs.getFlags()) {
  case FortranVariableFlagsEnum::intent_in:
    return FortranDummyIntent::In;
  case FortranVariableFlagsEnum::intent_out:
    return FortranDummyIntent::Out;
  case FortranVariableFlagsEnum::intent_inout:
    return FortranDummyIntent::InOut;
  default:
    return std::nullopt;
  }
}
 
template <fir::FortranProcedureFlagsEnum Flag>
inline bool hasProcedureAttr(fir::FortranProcedureFlagsEnumAttr flags) {
  return flags && bitEnumContainsAny(flags.getValue(), Flag);
}
 
template <fir::FortranProcedureFlagsEnum Flag>
inline bool hasProcedureAttr(mlir::Operation *op) {
  if (auto firCallOp = mlir::dyn_cast<fir::CallOp>(op))
    return hasProcedureAttr<Flag>(firCallOp.getProcedureAttrsAttr());
  if (auto firCallOp = mlir::dyn_cast<fir::DispatchOp>(op))
    return hasProcedureAttr<Flag>(firCallOp.getProcedureAttrsAttr());
  return hasProcedureAttr<Flag>(
      op->getAttrOfType<fir::FortranProcedureFlagsEnumAttr>(
          getFortranProcedureFlagsAttrName()));
}
 
inline bool hasBindcAttr(mlir::Operation *op) {
  return hasProcedureAttr<fir::FortranProcedureFlagsEnum::bind_c>(op);
}

std::optional<int64_t> getAllocaByteSize(fir::AllocaOp alloca,
                                         const mlir::DataLayout &dl,
                                         const fir::KindMapping &kindMap);

bool reboxPreservesContinuity(fir::ReboxOp rebox,
                              bool mayHaveNonDefaultLowerBounds = true,
                              bool checkWhole = true);

bool isContiguousEmbox(fir::EmboxOp embox, bool checkWhole = true);

bool isInOffloadRegion(mlir::Operation *op);
 
} // namespace fir
 
#endif // FORTRAN_OPTIMIZER_DIALECT_FIROPSSUPPORT_H