[flang][OpenMP] upstream OpenMP lowering

[SouraVX]

Summary

This patch implements lowering of OpenMP barrier construct from
pft to OpenMPDialect.

Patch is carved out of following merged PR's from fir-dev branch
of https://github.com/flang-compiler/f18-llvm-project/

PR's:
https://github.com/flang-compiler/f18-llvm-project/pull/248
https://github.com/flang-compiler/f18-llvm-project/pull/251

Unfortunately primary tool bbc for functional validation is not
yet upstreamed. So this patch includes a unittest for lowering
!OMP barrier construct.

Some part of the these PR's still remains downstream(functional test
and dialect registration to legalizer) for obvious reasons.
Will upstream them when the dependencies are upstreamed.

[kiranchandramohan]

Thanks @SouraVX for adding the lowering code for barrier.

Could you clarify in the commit message that the lowering is from parse-tree/pft to MLIR.

A few nits inline.

flang/include/flang/Lower/OpenMP.h

35–40

Do these need to be visible outside?

flang/include/flang/Optimizer/Dialect/FIRDialect.h

46

Are mlir dialects listed in alphabetical order? If so openmp dialect should also be.

flang/lib/Lower/OpenMP.cpp

32

is this line empty as per coding style or accidental?

[SouraVX]

Thanks @kiranchandramohan for reviewing this.

• Addressed nit comments.
• updated commit message accordingly.

flang/include/flang/Lower/OpenMP.h

35–40

No, I'll make them static. Thanks. genOpenMPConstruct is the only public interface needed.

flang/include/flang/Optimizer/Dialect/FIRDialect.h

46

Sure, it's looking a bit odd. I'll correct.

flang/lib/Lower/OpenMP.cpp

32

Accidental I believe. clang-format didn't caught it. Removed.

[kiranchandramohan]

LGTM. Please wait for a day before submitting.

flang/include/flang/Lower/OpenMP.h

19–20

Are these required now?

[SouraVX]

flang/include/flang/Lower/OpenMP.h

19–20

Removed, thanks!

flang/include/flang/Lower/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
 
 namespace Fortran {
 namespace parser {
 struct OpenMPConstruct;
+struct OpenMPStandaloneConstruct;
+struct OpenMPSimpleStandaloneConstruct;
 struct OmpEndLoopDirective;
 } // namespace parser
 
 namespace lower {
 
 class AbstractConverter;
 
 namespace pft {
 struct Evaluation;
 } // namespace pft
 
 void genOpenMPConstruct(AbstractConverter &, pft::Evaluation &,
                         const parser::OpenMPConstruct &);
 
 void genOpenMPEndLoop(AbstractConverter &, pft::Evaluation &,
                       const parser::OmpEndLoopDirective &);
 
 } // namespace lower
 } // namespace Fortran
 
 #endif // FORTRAN_LOWER_OPENMP_H

flang/include/flang/Optimizer/Dialect/FIRDialect.h

 };
 
 /// Register the dialect with MLIR
 inline void registerFIR() {
   // we want to register exactly once
   [[maybe_unused]] static bool init_once = [] {
     mlir::registerDialect<mlir::AffineDialect>();
     mlir::registerDialect<mlir::LLVM::LLVMDialect>();
+    mlir::registerDialect<mlir::omp::OpenMPDialect>();
     mlir::registerDialect<mlir::scf::SCFDialect>();
     mlir::registerDialect<mlir::StandardOpsDialect>();
     mlir::registerDialect<mlir::vector::VectorDialect>();
     mlir::registerDialect<FIROpsDialect>();
     return true;
   }();
 }
 
 /// Register the standard passes we use. This comes from registerAllPasses(),
 /// but is a smaller set since we aren't using many of the passes found there.
 inline void registerGeneralPasses() {
   mlir::createCanonicalizerPass();
   mlir::createCSEPass();

flang/lib/Lower/OpenMP.cpp

 //===-- OpenMP.cpp -- Open MP directive lowering --------------------------===//
 //
 // 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/
+//
+//===----------------------------------------------------------------------===//
 
 #include "flang/Lower/OpenMP.h"
 #include "flang/Lower/Bridge.h"
+#include "flang/Lower/FIRBuilder.h"
 #include "flang/Lower/PFTBuilder.h"
 #include "flang/Parser/parse-tree.h"
+#include "mlir/Dialect/OpenMP/OpenMPDialect.h"
+#include "llvm/Frontend/OpenMP/OMPConstants.h"
 
 #define TODO() llvm_unreachable("not yet implemented")
 
+static void genOMP(Fortran::lower::AbstractConverter &absConv,
+                   Fortran::lower::pft::Evaluation &eval,
+                   const Fortran::parser::OpenMPSimpleStandaloneConstruct
+                       &simpleStandaloneConstruct) {
+  const auto &directive =
+      std::get<Fortran::parser::OmpSimpleStandaloneDirective>(
+          simpleStandaloneConstruct.t);
+  switch (directive.v) {
+  default:
+    break;
+  case llvm::omp::Directive::OMPD_barrier:
+    absConv.getFirOpBuilder().create<mlir::omp::BarrierOp>(
+        absConv.getCurrentLocation());
+    break;
+  case llvm::omp::Directive::OMPD_taskwait:
+    TODO();
+  case llvm::omp::Directive::OMPD_taskyield:
+    TODO();
+  case llvm::omp::Directive::OMPD_target_enter_data:
+    TODO();
+  case llvm::omp::Directive::OMPD_target_exit_data:
+    TODO();
+  case llvm::omp::Directive::OMPD_target_update:
+    TODO();
+  case llvm::omp::Directive::OMPD_ordered:
+    TODO();
+  }
+}
+
+static void
+genOMP(Fortran::lower::AbstractConverter &absConv,
+       Fortran::lower::pft::Evaluation &eval,
+       const Fortran::parser::OpenMPStandaloneConstruct &standaloneConstruct) {
+  std::visit(
+      Fortran::common::visitors{
+          [&](const Fortran::parser::OpenMPSimpleStandaloneConstruct
+                  &simpleStandaloneConstruct) {
+            genOMP(absConv, eval, simpleStandaloneConstruct);
+          },
+          [&](const Fortran::parser::OpenMPFlushConstruct &flushConstruct) {
+            TODO();
+          },
+          [&](const Fortran::parser::OpenMPCancelConstruct &cancelConstruct) {
+            TODO();
+          },
+          [&](const Fortran::parser::OpenMPCancellationPointConstruct
+                  &cancellationPointConstruct) { TODO(); },
+      },
+      standaloneConstruct.u);
+}
+
 void Fortran::lower::genOpenMPConstruct(
-    Fortran::lower::AbstractConverter &, Fortran::lower::pft::Evaluation &,
-    const Fortran::parser::OpenMPConstruct &) {
+    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();
+          },
+          [&](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/CMakeLists.txt

 add_custom_target(FlangUnitTests)
 set_target_properties(FlangUnitTests PROPERTIES FOLDER "Flang Unit Tests")
 
 function(add_flang_unittest test_dirname)
   add_unittest(FlangUnitTests ${test_dirname} ${ARGN})
 endfunction()
 
 add_subdirectory(Optimizer)
 add_subdirectory(Decimal)
 add_subdirectory(Evaluate)
 add_subdirectory(Runtime)
+add_subdirectory(Lowering)

flang/unittests/Lowering/CMakeLists.txt

+get_property(dialect_libs GLOBAL PROPERTY MLIR_DIALECT_LIBS)
+
+set(LIBS
+  MLIRLLVMIR
+  ${dialect_libs}
+)
+
+add_flang_unittest(FlangLoweringOpenMPTests
+  OpenMPLoweringTest.cpp
+)
+target_link_libraries(FlangLoweringOpenMPTests
+  PRIVATE
+  ${LIBS})

flang/unittests/Lowering/OpenMPLoweringTest.cpp

+//===- OpenMPLoweringTest.cpp -- OpenMPLowering unit tests ----------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#include "gtest/gtest.h"
+#include "mlir/Dialect/OpenMP/OpenMPDialect.h"
+#include "mlir/IR/Builders.h"
+#include "flang/Parser/parse-tree.h"
+#include "llvm/Frontend/OpenMP/OMPConstants.h"
+
+class OpenMPLoweringTest : public testing::Test {
+protected:
+  void SetUp() override {
+    mlir::registerDialect<mlir::omp::OpenMPDialect>();
+    mlir::registerAllDialects(&ctx);
+    mlirOpBuilder.reset(new mlir::OpBuilder(&ctx));
+  }
+
+  void TearDown() override { mlirOpBuilder.reset(); }
+
+  mlir::MLIRContext ctx;
+  std::unique_ptr<mlir::OpBuilder> mlirOpBuilder;
+};
+
+TEST_F(OpenMPLoweringTest, Barrier) {
+  // Construct a dummy parse tree node for `!OMP barrier`.
+  struct Fortran::parser::OmpSimpleStandaloneDirective barrierDirective(
+      llvm::omp::Directive::OMPD_barrier);
+
+  // Check and lower the `!OMP barrier` node to `BarrierOp` operation of
+  // OpenMPDialect.
+  EXPECT_EQ(barrierDirective.v, llvm::omp::Directive::OMPD_barrier);
+  auto barrierOp = mlirOpBuilder->create<mlir::omp::BarrierOp>(
+      mlirOpBuilder->getUnknownLoc());
+
+  EXPECT_EQ(barrierOp.getOperationName(), "omp.barrier");
+  EXPECT_EQ(succeeded(barrierOp.verify()), true);
+}
+
+// main() from gtest_main