================
@@ -6,90 +6,152 @@
//
//===----------------------------------------------------------------------===//
//
-// Emit OpenMP clause nodes as CIR code.
+// OpenMP clause processor implementation. See CIRGenOpenMPClause.h.
//
//===----------------------------------------------------------------------===//
+#include "CIRGenOpenMPClause.h"
#include "CIRGenFunction.h"
#include "mlir/Dialect/OpenMP/OpenMPDialect.h"
+#include "clang/Basic/OpenMPKinds.h"
using namespace clang;
using namespace clang::CIRGen;
-namespace {
-template <typename OpTy>
-class OpenMPClauseCIREmitter final
- : public ConstOMPClauseVisitor<OpenMPClauseCIREmitter<OpTy>> {
- OpTy &operation;
- CIRGen::CIRGenFunction &cgf;
- CIRGen::CIRGenBuilderTy &builder;
-
-public:
- OpenMPClauseCIREmitter(OpTy &operation, CIRGen::CIRGenFunction &cgf,
- CIRGen::CIRGenBuilderTy &builder)
- : operation(operation), cgf(cgf), builder(builder) {}
-
- void VisitOMPClause(const OMPClause *clause) {
- cgf.cgm.errorNYI(clause->getBeginLoc(), "OpenMPClause ",
- llvm::omp::getOpenMPClauseName(clause->getClauseKind()));
+static mlir::omp::ClauseMapFlags
+mapClauseKindToFlags(OpenMPMapClauseKind kind) {
+ switch (kind) {
+ case OMPC_MAP_to:
+ return mlir::omp::ClauseMapFlags::to;
+ case OMPC_MAP_from:
+ return mlir::omp::ClauseMapFlags::from;
+ case OMPC_MAP_tofrom:
+ return mlir::omp::ClauseMapFlags::to | mlir::omp::ClauseMapFlags::from;
+ case OMPC_MAP_alloc:
+ case OMPC_MAP_release:
+ return mlir::omp::ClauseMapFlags::storage;
+ case OMPC_MAP_delete:
+ return mlir::omp::ClauseMapFlags::del;
+ default:
+ return mlir::omp::ClauseMapFlags::none;
}
+}
- void VisitOMPProcBindClause(const OMPProcBindClause *clause) {
- if constexpr (std::is_same_v<OpTy, mlir::omp::ParallelOp>) {
- mlir::omp::ClauseProcBindKind kind;
- switch (clause->getProcBindKind()) {
- case llvm::omp::ProcBindKind::OMP_PROC_BIND_master:
- kind = mlir::omp::ClauseProcBindKind::Master;
- break;
- case llvm::omp::ProcBindKind::OMP_PROC_BIND_close:
- kind = mlir::omp::ClauseProcBindKind::Close;
- break;
- case llvm::omp::ProcBindKind::OMP_PROC_BIND_spread:
- kind = mlir::omp::ClauseProcBindKind::Spread;
- break;
- case llvm::omp::ProcBindKind::OMP_PROC_BIND_primary:
- kind = mlir::omp::ClauseProcBindKind::Primary;
- break;
- case llvm::omp::ProcBindKind::OMP_PROC_BIND_default:
- // 'default' in the classic-codegen does no runtime call/doesn't
- // really do anything. So this is a no-op, and thus shouldn't change
- // the IR.
- return;
- case llvm::omp::ProcBindKind::OMP_PROC_BIND_unknown:
- llvm_unreachable("unknown proc-bind kind");
- }
- operation.setProcBindKind(kind);
- } else {
- cgf.cgm.errorNYI(
- clause->getBeginLoc(),
- "OMPProcBindClause unimplemented on this directive kind");
- }
- }
+static mlir::Value emitMapInfoForVar(CIRGenFunction &cgf,
+ mlir::OpBuilder &builder,
+ mlir::Location loc, const VarDecl *vd,
+ mlir::omp::ClauseMapFlags mapFlags) {
+ Address addr = cgf.getAddrOfLocalVar(vd);
+ mlir::Value varPtr = addr.getPointer();
+ auto varPtrType = mlir::cast<cir::PointerType>(varPtr.getType());
+ mlir::Type elementType = varPtrType.getPointee();
- void emitClauses(ArrayRef<const OMPClause *> clauses) {
- for (const auto *c : clauses)
- this->Visit(c);
+ // Cast to generic pointer if needed.
+ if (varPtrType.getAddrSpace()) {
+ auto genericPtrType =
+ cir::PointerType::get(builder.getContext(), elementType);
+ varPtr = cir::CastOp::create(builder, loc, genericPtrType,
+ cir::CastKind::address_space, varPtr);
+ varPtrType = genericPtrType;
}
-};
-template <typename OpTy>
-auto makeClauseEmitter(OpTy &op, CIRGen::CIRGenFunction &cgf,
- CIRGen::CIRGenBuilderTy &builder) {
- return OpenMPClauseCIREmitter<OpTy>(op, cgf, builder);
+
+ return mlir::omp::MapInfoOp::create(
+ builder, loc,
+ /*omp_ptr=*/varPtrType,
+ /*var_ptr=*/varPtr,
+ /*var_type=*/elementType,
+ /*map_type=*/mapFlags,
+ /*map_capture_type=*/mlir::omp::VariableCaptureKind::ByRef,
+ /*var_ptr_ptr=*/mlir::Value{},
+ /*members=*/mlir::ValueRange{},
+ /*members_index=*/mlir::ArrayAttr{},
+ /*bounds=*/mlir::ValueRange{},
+ /*mapper_id=*/mlir::FlatSymbolRefAttr{},
+ /*name=*/builder.getStringAttr(vd->getName()),
+ /*partial_map=*/false);
}
-} // namespace
-
-template <typename Op>
-void CIRGenFunction::emitOpenMPClauses(Op &op,
- ArrayRef<const OMPClause *> clauses) {
- mlir::OpBuilder::InsertionGuard guardCase(builder);
- builder.setInsertionPoint(op);
- makeClauseEmitter(op, *this, builder).emitClauses(clauses);
+
+bool OpenMPClauseProcessor::processProcBind(
+ mlir::omp::ProcBindClauseOps &result) const {
+ for (const OMPClause *clause : clauses) {
+ const auto *pbc = dyn_cast<OMPProcBindClause>(clause);
+ if (!pbc)
+ continue;
+
+ switch (pbc->getProcBindKind()) {
+ case llvm::omp::ProcBindKind::OMP_PROC_BIND_master:
----------------
erichkeane wrote:
Are we expecting this to do a lot more work? Otherwise, why is this whole
switch not just:
```
assert(pbc->getProcBindKind() !=
llvm::omp::ProcBindKind::OMP_PROC_BIND_unknown);
if (pbc->getProcBindKind() != llvm::omp::ProcBindKind::OMP_PROC_BIND_default)
result.procBindKind = mlir::omp::ClauseProcBindKindAttr::get(
builder.getContext(), pbc->getProcBindKind());
```
perhaps with some sort of conversion function being called (IS there not
already one? I'd VERY much expect the ClauseProcBindKind/mlir dialect to
already have some sort of conversion function between the two somewhere?!).
https://github.com/llvm/llvm-project/pull/195452
_______________________________________________
cfe-commits mailing list
[email protected]
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
