[OpenMP][CIR] Implement basic 'parallel' lowering + some clause infra

clang/include/clang/AST/OpenMPClause.h

@@ -9527,7 +9527,9 @@ class OMPClauseVisitorBase {
 
 #define GEN_CLANG_CLAUSE_CLASS
 #define CLAUSE_CLASS(Enum, Str, Class)                                         \
-  RetTy Visit##Class(PTR(Class) S) { DISPATCH(Class); }
+  RetTy Visit##Class(PTR(Class) S) {                                           \
+    return static_cast<ImplClass *>(this)->VisitOMPClause(S);                  \
+  }
 #include "llvm/Frontend/OpenMP/OMP.inc"
 
   RetTy Visit(PTR(OMPClause) S) {
@@ -9536,7 +9538,7 @@ class OMPClauseVisitorBase {
 #define GEN_CLANG_CLAUSE_CLASS
 #define CLAUSE_CLASS(Enum, Str, Class)                                         \
   case llvm::omp::Clause::Enum:                                                \
-    return Visit##Class(static_cast<PTR(Class)>(S));
+    DISPATCH(Class);
 #define CLAUSE_NO_CLASS(Enum, Str)                                             \
   case llvm::omp::Clause::Enum:                                                \
     break;

clang/lib/CIR/CodeGen/CIRGenFunction.h

@@ -2155,6 +2155,10 @@ class CIRGenFunction : public CIRGenTypeCache {
   void emitOMPDeclareMapper(const OMPDeclareMapperDecl &d);
   void emitOMPRequiresDecl(const OMPRequiresDecl &d);
 
+private:
+  template <typename Op>
+  void emitOpenMPClauses(Op &op, ArrayRef<const OMPClause *> clauses);
+
   //===--------------------------------------------------------------------===//
   //                         OpenACC Emission
   //===--------------------------------------------------------------------===//

clang/lib/CIR/CodeGen/CIRGenOpenMPClause.cpp

@@ -0,0 +1,63 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+//
+// Emit OpenMP clause nodes as CIR code.
+//
+//===----------------------------------------------------------------------===//
+
+#include "CIRGenFunction.h"
+#include "mlir/Dialect/OpenMP/OpenMPDialect.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 ",
+                     clause->getClauseKind());
+  }
+
+  void emitClauses(ArrayRef<const OMPClause *> clauses) {
+    for (const auto *c : clauses)
+      this->Visit(c);
+  }
+};
+template <typename OpTy>
+auto makeClauseEmitter(OpTy &op, CIRGen::CIRGenFunction &cgf,
+                       CIRGen::CIRGenBuilderTy &builder) {
+  return OpenMPClauseCIREmitter<OpTy>(op, cgf, builder);
+}
+} // 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);
+}
+
+// We're defining the template for this in a .cpp file, so we have to explicitly
+// specialize the templates.
+#define EXPL_SPEC(N)                                                           \
+  template void CIRGenFunction::emitOpenMPClauses<N>(                          \
+      N &, ArrayRef<const OMPClause *>);
+EXPL_SPEC(mlir::omp::ParallelOp)
+#undef EXPL_SPEC

clang/lib/CIR/CodeGen/CIRGenStmtOpenMP.cpp

@@ -30,8 +30,35 @@ CIRGenFunction::emitOMPErrorDirective(const OMPErrorDirective &s) {
 }
 mlir::LogicalResult
 CIRGenFunction::emitOMPParallelDirective(const OMPParallelDirective &s) {
-  getCIRGenModule().errorNYI(s.getSourceRange(), "OpenMP OMPParallelDirective");
-  return mlir::failure();
+  mlir::LogicalResult res = mlir::success();
+  llvm::SmallVector<mlir::Type> retTy;
+  llvm::SmallVector<mlir::Value> operands;
+  mlir::Location begin = getLoc(s.getBeginLoc());
+  mlir::Location end = getLoc(s.getEndLoc());
+
+  auto parallelOp =
+      mlir::omp::ParallelOp::create(builder, begin, retTy, operands);
+  emitOpenMPClauses(parallelOp, s.clauses());
+
+  {
+    mlir::Block &block = parallelOp.getRegion().emplaceBlock();
+    mlir::OpBuilder::InsertionGuard guardCase(builder);
+    builder.setInsertionPointToEnd(&block);
+
+    LexicalScope ls{*this, begin, builder.getInsertionBlock()};
+
+    if (s.hasCancel())
+      getCIRGenModule().errorNYI(s.getBeginLoc(),
+                                 "OpenMP Parallel with Cancel");
+    if (s.getTaskReductionRefExpr())
+      getCIRGenModule().errorNYI(s.getBeginLoc(),
+                                 "OpenMP Parallel with Task Reduction");
+
+    res = emitStmt(s.getAssociatedStmt(), /*useCurrentScope=*/true);
+
+    mlir::omp::TerminatorOp::create(builder, end);
+  }
+  return res;
 }
 
 mlir::LogicalResult

clang/lib/CIR/CodeGen/CMakeLists.txt

@@ -37,6 +37,7 @@ add_clang_library(clangCIR
   CIRGenOpenACC.cpp
   CIRGenOpenACCClause.cpp
   CIRGenOpenACCRecipe.cpp
+  CIRGenOpenMPClause.cpp
   CIRGenPointerAuth.cpp
   CIRGenRecordLayoutBuilder.cpp
   CIRGenStmt.cpp

clang/test/CIR/CodeGenOpenMP/not-yet-implemented.c

@@ -10,7 +10,10 @@ void do_things() {
   {}
 
   int i;
-  // expected-error@+1{{ClangIR code gen Not Yet Implemented: OpenMP OMPParallelDirective}}
+  // TODO(OMP): We might consider overloading operator<< for OMPClauseKind in
+  // the future if we want to improve this.
+  // expected-error@+2{{ClangIR code gen Not Yet Implemented: OpenMPClause : 50}}
+  // expected-error@+2{{ClangIR code gen Not Yet Implemented: emitStmt: CapturedStmt}}
 #pragma omp parallel if(i)
   {}
 }

clang/test/CIR/CodeGenOpenMP/parallel.c

@@ -0,0 +1,50 @@
+// RUN: not %clang_cc1 -fopenmp -emit-cir -fclangir %s -o - | FileCheck %s
+
+void before(int);
+void during(int);
+void after(int);
+
+void emit_simple_parallel() {
+  // CHECK: cir.func{{.*}}@emit_simple_parallel
+  int i = 5;
+  before(i);
+  // CHECK: %[[I_LOAD:.*]] = cir.load{{.*}}
+  // CHECK-NEXT: cir.call @before(%[[I_LOAD]])
+
+#pragma omp parallel
+  {}
+  // CHECK-NEXT: omp.parallel {
+  // CHECK-NEXT: omp.terminator
+  // CHECK-NEXT: }
+#pragma omp parallel
+  {
+    // TODO(OMP): We don't yet emit captured stmt, so the body of this is lost,x
+    // thus we don't emit the 'during' call.
+    during(i);
+  }
+  // CHECK-NEXT: omp.parallel {
+  // CHECK-NEXT: omp.terminator
+  // CHECK-NEXT: }
+
+  after(i);
+  // CHECK: %[[I_LOAD:.*]] = cir.load{{.*}}
+  // CHECK-NEXT: cir.call @after(%[[I_LOAD]])
+}
+
+void parallel_with_operations() {
+  // CHECK: cir.func{{.*}}@parallel_with_operations
+  int a, b;
+  // CHECK-NEXT: cir.alloca{{.*}}["a"]
+  // CHECK-NEXT: cir.alloca{{.*}}["b"]
+  // TODO(OMP): At the moment this results in 3 NYI diagnostics, 1 each for the
+  // clauses + 1 for the CapturedStmt. When those are implemented, the check
+  // lines will need updating.
+#pragma omp parallel shared(a) firstprivate(b)
+  {
+   ++a;
+   ++b;
+  }
+  // CHECK-NEXT: omp.parallel {
+  // CHECK-NEXT: omp.terminator
+  // CHECK-NEXT: }
+}