OpenMP.h

//===-- Lower/OpenMP.h -- lower Open MP directives --------------*- 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_OPENMP_H
#define FORTRAN_LOWER_OPENMP_H
 
#include "llvm/ADT/SmallVector.h"
#include "llvm/ADT/StringRef.h"
 
#include <cinttypes>
 
namespace mlir {
class Operation;
class Location;
class Type;
class Value;
class OpBuilder;
namespace omp {
enum class DeclareTargetDeviceType : uint32_t;
enum class DeclareTargetCaptureClause : uint32_t;
} // namespace omp
} // namespace mlir
 
namespace fir {
class FirOpBuilder;
} // namespace fir
 
namespace Fortran {
namespace evaluate {
class ProcedureRef;
} // namespace evaluate
 
namespace parser {
struct OpenMPConstruct;
struct OpenMPDeclarativeConstruct;
struct OmpClauseList;
} // namespace parser
 
namespace semantics {
class Symbol;
class Scope;
class SemanticsContext;
} // namespace semantics
 
namespace lower {
 
class AbstractConverter;
class SymMap;
 
namespace pft {
struct Evaluation;
struct Variable;
} // namespace pft
 
struct OMPDeferredDeclareTargetInfo {
  mlir::omp::DeclareTargetCaptureClause declareTargetCaptureClause;
  mlir::omp::DeclareTargetDeviceType declareTargetDeviceType;
  bool automap = false;
  const Fortran::semantics::Symbol &sym;
};
 
// Generate the OpenMP terminator for Operation at Location.
mlir::Operation *genOpenMPTerminator(fir::FirOpBuilder &, mlir::Operation *,
                                     mlir::Location);
 
void genOpenMPConstruct(AbstractConverter &, Fortran::lower::SymMap &,
                        semantics::SemanticsContext &, pft::Evaluation &,
                        const parser::OpenMPConstruct &);
void genOpenMPDeclarativeConstruct(AbstractConverter &,
                                   Fortran::lower::SymMap &,
                                   semantics::SemanticsContext &,
                                   pft::Evaluation &,
                                   const parser::OpenMPDeclarativeConstruct &);
void genOpenMPSymbolProperties(AbstractConverter &converter,
                               const pft::Variable &var);
 
void genGroupprivateOp(AbstractConverter &, const pft::Variable &);
void genThreadprivateOp(AbstractConverter &, const pft::Variable &);
void genDeclareTargetIntGlobal(AbstractConverter &, const pft::Variable &);
bool isOpenMPTargetConstruct(const parser::OpenMPConstruct &);
bool isOpenMPDeviceDeclareTarget(Fortran::lower::AbstractConverter &,
                                 Fortran::semantics::SemanticsContext &,
                                 Fortran::lower::pft::Evaluation &,
                                 const parser::OpenMPDeclarativeConstruct &);
void gatherOpenMPDeferredDeclareTargets(
    Fortran::lower::AbstractConverter &, Fortran::semantics::SemanticsContext &,
    Fortran::lower::pft::Evaluation &,
    const parser::OpenMPDeclarativeConstruct &,
    llvm::SmallVectorImpl<OMPDeferredDeclareTargetInfo> &);
bool markOpenMPDeferredDeclareTargetFunctions(
    mlir::Operation *, llvm::SmallVectorImpl<OMPDeferredDeclareTargetInfo> &,
    AbstractConverter &);
void genOpenMPRequires(mlir::Operation *, const Fortran::semantics::Symbol *);
 
// Materialize omp.declare_mapper ops for mapper declarations found in
// imported modules. If \p scope is null, materialize for the whole
// semantics global scope; otherwise, operate recursively starting at \p scope.
void materializeOpenMPDeclareMappers(
    Fortran::lower::AbstractConverter &, Fortran::semantics::SemanticsContext &,
    const Fortran::semantics::Scope *scope = nullptr);
 
// Mark declare target globals and functions that were imported from a
// module file.
void markOpenMPImportedDeclareTargets(
    Fortran::lower::AbstractConverter &converter,
    semantics::SemanticsContext &semaCtx);
 
namespace omp {
bool isDispatchTargetCall(const Fortran::evaluate::ProcedureRef &proc,
                          AbstractConverter &converter);

const Fortran::semantics::Symbol *
resolveDeclareVariantCallee(const Fortran::semantics::Symbol &base,
                            AbstractConverter &converter,
                            bool excludeDispatchContext = false);

mlir::Value getEnclosingDispatchNovariants(mlir::OpBuilder &builder);

mlir::Value getEnclosingDispatchNocontext(mlir::OpBuilder &builder);
} // namespace omp
 
// Materialize (idempotently) the omp.declare_reduction op for one already-
// resolved imported user reduction and one requested element type, at module
// scope, for separate compilation. Only the per-type instance whose scoped op
// name equals \p requestedOpName is emitted, so a multi-type declaration's
// other listed types (and any unsupported sibling type) are left alone. No-op
// if the requested type's shape is not lowerable (a combiner-in-clause form or
// an unsupported element type) or the op already exists. Safe to call
// mid-function (uses createDeclareReductionHelper's InsertionGuard). \p
// isByRef selects the by-ref/by-value naming variant used by the clause.
void materializeUserReduction(
    Fortran::lower::AbstractConverter &, Fortran::semantics::SemanticsContext &,
    const Fortran::semantics::Symbol &resolvedReduction,
    llvm::StringRef requestedOpName, mlir::Type requestedType, bool isByRef);
 
} // namespace lower
} // namespace Fortran
 
#endif // FORTRAN_LOWER_OPENMP_H