[flang][OpenMP] Added initial support for lowering OpenMP parallel construct

[SouraVX]

Summary

This patch lower !OMP PARALLEL construct from PFT to OpenMPDialect operations.
This is first patch in this direction(lowering parallel construct).

OpenMP parallel construct can have multiple clauses and parameters. This patch
only implements lowering of an empty(contains no code in body) parallel construct
without any clauses or parameters.

Patch is carved out of following approved PR:
https://github.com/flang-compiler/f18-llvm-project/pull/322

[DavidTruby]

If this lowers to the OpenMP MLIR Dialect, would it be possible to have some lit codegen tests on the generated IR from a sample input file? Unless not all the necessary infrastructure is in yet for this.

[DavidTruby]

LGTM other than possibly adding a lit test if the right infrastructure is there

[SouraVX]

In D84965#2187279, @DavidTruby wrote:

If this lowers to the OpenMP MLIR Dialect, would it be possible to have some lit codegen tests on the generated IR from a sample input file? Unless not all the necessary infrastructure is in yet for this.

We already got this covered, test case is there in PR. Till the bridge code is up-streamed we can't put those sort of test here.

[kiranchandramohan]

LGTM.

flang/lib/Lower/OpenMP.cpp

std::visit(
             TODO();
           },
           [&](const Fortran::parser::OpenMPCancellationPointConstruct
                   &cancellationPointConstruct) { TODO(); },
       },
       standaloneConstruct.u);
 }
 
+static void
+genOMP(Fortran::lower::AbstractConverter &absConv,
+       Fortran::lower::pft::Evaluation &eval,
+       const Fortran::parser::OpenMPBlockConstruct &blockConstruct) {
+  const auto &blockDirective =
+      std::get<Fortran::parser::OmpBeginBlockDirective>(blockConstruct.t);
+  const auto &parallelDirective =
+      std::get<Fortran::parser::OmpBlockDirective>(blockDirective.t);
+  if (parallelDirective.v == llvm::omp::OMPD_parallel) {
+    auto &firOpBuilder = absConv.getFirOpBuilder();
+    auto currentLocation = absConv.getCurrentLocation();
+    auto insertPt = firOpBuilder.saveInsertionPoint();
+    llvm::ArrayRef<mlir::Type> argTy;
+    mlir::ValueRange range;
+    llvm::SmallVector<int32_t, 6> operandSegmentSizes(6 /*Size=*/,
+                                                      0 /*Value=*/);
+    // create and insert the operation.
+    auto parallelOp = firOpBuilder.create<mlir::omp::ParallelOp>(
+        currentLocation, argTy, range);
+    parallelOp.setAttr(mlir::omp::ParallelOp::getOperandSegmentSizeAttr(),
+                       firOpBuilder.getI32VectorAttr(operandSegmentSizes));
+    parallelOp.getRegion().push_back(new Block{});
+    auto &block = parallelOp.getRegion().back();
+    firOpBuilder.setInsertionPointToStart(&block);
+    // ensure the block is well-formed.
+    firOpBuilder.create<mlir::omp::TerminatorOp>(currentLocation);
+    firOpBuilder.restoreInsertionPoint(insertPt);
+  }
+}
+
 void Fortran::lower::genOpenMPConstruct(
     Fortran::lower::AbstractConverter &absConv,
     Fortran::lower::pft::Evaluation &eval,
     const Fortran::parser::OpenMPConstruct &ompConstruct) {
 
   std::visit(
       common::visitors{
           [&](const Fortran::parser::OpenMPStandaloneConstruct
                   &standaloneConstruct) {
             genOMP(absConv, eval, standaloneConstruct);
           },
           [&](const Fortran::parser::OpenMPSectionsConstruct
                   &sectionsConstruct) { TODO(); },
           [&](const Fortran::parser::OpenMPLoopConstruct &loopConstruct) {
             TODO();
           },
           [&](const Fortran::parser::OpenMPBlockConstruct &blockConstruct) {
-            TODO();
+            genOMP(absConv, eval, blockConstruct);
           },
           [&](const Fortran::parser::OpenMPAtomicConstruct &atomicConstruct) {
             TODO();
           },
           [&](const Fortran::parser::OpenMPCriticalConstruct
                   &criticalConstruct) { TODO(); },
       },
       ompConstruct.u);
 }
 
 void Fortran::lower::genOpenMPEndLoop(
     Fortran::lower::AbstractConverter &, Fortran::lower::pft::Evaluation &,
     const Fortran::parser::OmpEndLoopDirective &) {
   TODO();
 }

flang/unittests/Lower/OpenMPLoweringTest.cpp

TEST_F(OpenMPLoweringTest, TaskYield) {
   EXPECT_EQ(taskYieldDirective.v, llvm::omp::Directive::OMPD_taskyield);
   auto taskYieldOp = mlirOpBuilder->create<mlir::omp::TaskyieldOp>(
       mlirOpBuilder->getUnknownLoc());
 
   EXPECT_EQ(taskYieldOp.getOperationName(), "omp.taskyield");
   EXPECT_EQ(succeeded(taskYieldOp.verify()), true);
 }
 
+TEST_F(OpenMPLoweringTest, EmptyParallel) {
+  // Construct a dummy parse tree node for `!OMP parallel`.
+  struct Fortran::parser::OmpSimpleStandaloneDirective parallelDirective(
+      llvm::omp::Directive::OMPD_parallel);
+
+  // Check and lower the `!OMP parallel` node to `ParallelOp` operation of
+  // OpenMPDialect.
+  EXPECT_EQ(parallelDirective.v, llvm::omp::Directive::OMPD_parallel);
+  auto insertPt = mlirOpBuilder->saveInsertionPoint();
+  llvm::ArrayRef<mlir::Type> argTy;
+  mlir::ValueRange range;
+  llvm::SmallVector<int32_t, 6> operandSegmentSizes(6 /*Size=*/, 0 /*Value=*/);
+  // create and insert the operation.
+  auto parallelOp = mlirOpBuilder->create<mlir::omp::ParallelOp>(
+      mlirOpBuilder->getUnknownLoc(), argTy, range);
+  parallelOp.setAttr(mlir::omp::ParallelOp::getOperandSegmentSizeAttr(),
+      mlirOpBuilder->getI32VectorAttr(operandSegmentSizes));
+  parallelOp.getRegion().push_back(new mlir::Block{});
+  auto &block = parallelOp.getRegion().back();
+  mlirOpBuilder->setInsertionPointToStart(&block);
+  // ensure the block is well-formed.
+  mlirOpBuilder->create<mlir::omp::TerminatorOp>(
+      mlirOpBuilder->getUnknownLoc());
+  mlirOpBuilder->restoreInsertionPoint(insertPt);
+  EXPECT_EQ(succeeded(parallelOp.verify()), true);
+}
+
 // main() from gtest_main