Utils.h

//===-- Lower/Support/Utils.h -- utilities ----------------------*- 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_SUPPORT_UTILS_H
#define FORTRAN_LOWER_SUPPORT_UTILS_H
 
#include "flang/Common/indirection.h"
#include "flang/Parser/char-block.h"
#include "flang/Semantics/tools.h"
#include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/IR/BuiltinAttributes.h"
#include "llvm/ADT/SmallSet.h"
#include "llvm/ADT/StringRef.h"
 
namespace Fortran::evaluate {
class Component;
class ArrayRef;
} // namespace Fortran::evaluate
 
namespace Fortran::lower {
using SomeExpr = Fortran::evaluate::Expr<Fortran::evaluate::SomeType>;
using ExplicitSpaceArrayBases =
    std::variant<const semantics::Symbol *, const evaluate::Component *,
                 const evaluate::ArrayRef *>;
// FIXME: needed for privatizeSymbol that does not belong to this header.
class AbstractConverter;
class SymMap;
} // end namespace Fortran::lower
 
namespace fir {
class FirOpBuilder;
}
 
//===----------------------------------------------------------------------===//
// Small inline helper functions to deal with repetitive, clumsy conversions.
//===----------------------------------------------------------------------===//

inline llvm::StringRef toStringRef(const Fortran::parser::CharBlock &cb) {
  return {cb.begin(), cb.size()};
}

template <typename A>
const A &removeIndirection(const A &a) {
  return a;
}
template <typename A>
const A &removeIndirection(const Fortran::common::Indirection<A> &a) {
  return a.value();
}

template <typename A>
static Fortran::lower::SomeExpr toEvExpr(const A &x) {
  return Fortran::evaluate::AsGenericExpr(Fortran::common::Clone(x));
}
 
template <Fortran::common::TypeCategory FROM>
static Fortran::lower::SomeExpr ignoreEvConvert(
    const Fortran::evaluate::Convert<
        Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>,
        FROM> &x) {
  return toEvExpr(x.left());
}
template <typename A>
static Fortran::lower::SomeExpr ignoreEvConvert(const A &x) {
  return toEvExpr(x);
}

inline Fortran::lower::SomeExpr
ignoreEvConvert(const Fortran::evaluate::Expr<Fortran::evaluate::Type<
                    Fortran::common::TypeCategory::Integer, 8>> &x) {
  return Fortran::common::visit(
      [](const auto &v) { return ignoreEvConvert(v); }, x.u);
}

template <typename A>
A flatZip(const A &container1, const A &container2) {
  assert(container1.size() == container2.size());
  A result;
  for (auto [e1, e2] : llvm::zip(container1, container2)) {
    result.emplace_back(e1);
    result.emplace_back(e2);
  }
  return result;
}
 
namespace Fortran::lower {
unsigned getHashValue(const Fortran::lower::SomeExpr *x);
unsigned getHashValue(const Fortran::lower::ExplicitSpaceArrayBases &x);
unsigned getHashValue(const Fortran::evaluate::Component *x);
 
bool isEqual(const Fortran::lower::SomeExpr *x,
             const Fortran::lower::SomeExpr *y);
bool isEqual(const Fortran::lower::ExplicitSpaceArrayBases &x,
             const Fortran::lower::ExplicitSpaceArrayBases &y);
bool isEqual(const Fortran::evaluate::Component *x,
             const Fortran::evaluate::Component *y);
 
template <typename OpType, typename OperandsStructType>
void privatizeSymbol(
    lower::AbstractConverter &converter, fir::FirOpBuilder &firOpBuilder,
    lower::SymMap &symTable,
    llvm::SetVector<const semantics::Symbol *> &allPrivatizedSymbols,
    llvm::SmallPtrSet<const semantics::Symbol *, 16> &mightHaveReadHostSym,
    const semantics::Symbol *symToPrivatize, OperandsStructType *clauseOps,
    std::optional<llvm::omp::Directive> dir = std::nullopt);
 
} // end namespace Fortran::lower
 
// DenseMapInfo for pointers to Fortran::lower::SomeExpr.
namespace llvm {
template <>
struct DenseMapInfo<const Fortran::lower::SomeExpr *> {
  static inline const Fortran::lower::SomeExpr *getEmptyKey() {
    return reinterpret_cast<Fortran::lower::SomeExpr *>(~0);
  }
  static inline const Fortran::lower::SomeExpr *getTombstoneKey() {
    return reinterpret_cast<Fortran::lower::SomeExpr *>(~0 - 1);
  }
  static unsigned getHashValue(const Fortran::lower::SomeExpr *v) {
    return Fortran::lower::getHashValue(v);
  }
  static bool isEqual(const Fortran::lower::SomeExpr *lhs,
                      const Fortran::lower::SomeExpr *rhs) {
    return Fortran::lower::isEqual(lhs, rhs);
  }
};
 
// DenseMapInfo for pointers to Fortran::evaluate::Component.
template <>
struct DenseMapInfo<const Fortran::evaluate::Component *> {
  static inline const Fortran::evaluate::Component *getEmptyKey() {
    return reinterpret_cast<Fortran::evaluate::Component *>(~0);
  }
  static inline const Fortran::evaluate::Component *getTombstoneKey() {
    return reinterpret_cast<Fortran::evaluate::Component *>(~0 - 1);
  }
  static unsigned getHashValue(const Fortran::evaluate::Component *v) {
    return Fortran::lower::getHashValue(v);
  }
  static bool isEqual(const Fortran::evaluate::Component *lhs,
                      const Fortran::evaluate::Component *rhs) {
    return Fortran::lower::isEqual(lhs, rhs);
  }
};
} // namespace llvm
 
#endif // FORTRAN_LOWER_SUPPORT_UTILS_H