[flang] Add lowering stubs for OpenMP/OpenACC declarative constructs

[peixin]

Summary

This patch provides the basic infrastructure for lowering declarative
constructs for OpenMP and OpenACC.

This is part of the upstreaming effort from the fir-dev branch in [1].
[1] https://github.com/flang-compiler/f18-llvm-project

[shraiysh]

LGTM. Is it a common practice to add XFAIL tests for undeveloped features without any CHECK: lines? I'd like for them to be added only while adding features without the XFAIL but I don't have a problem if others are okay with it.

[peixin]

In D124225#3469878, @shraiysh wrote:

LGTM. Is it a common practice to add XFAIL tests for undeveloped features without any CHECK: lines? I'd like for them to be added only while adding features without the XFAIL but I don't have a problem if others are okay with it.

To be honest, I don't know if it's common practice. I assume there is no strict rule. I was asked to add the test cases in fir-dev when I create this patch, so I added them.

[peixin]

ping

[kiranchandramohan]

LGTM.

We have a facility for checking TODO messages. See https://reviews.llvm.org/D114371. If you are interested, you can try this.

[peixin]

Fix the test cases according to @kiranchandramohan 's comments.

@clementval Is the fix for OpenACC OK to you?

BTW, declare reduction test case has one segfault during semantic analysis. It is not our current priority.

[clementval]

Looks ok for me for now.

[peixin]

@clementval The new patch is not supported in fir-dev anymore. But do I need to cherry-pick this to fir-dev considering this has some changes in lowering. Will this affect your upstreaming work?

[peixin]

Sorry, not cherry-pick. I mean, sync to fir-dev.

flang/include/flang/Lower/OpenACC.h

 //===----------------------------------------------------------------------===//
 
 #ifndef FORTRAN_LOWER_OPENACC_H
 #define FORTRAN_LOWER_OPENACC_H
 
 namespace Fortran {
 namespace parser {
 struct OpenACCConstruct;
+struct OpenACCDeclarativeConstruct;
 } // namespace parser
 
 namespace lower {
 
 class AbstractConverter;
 
 namespace pft {
 struct Evaluation;
 } // namespace pft
 
 void genOpenACCConstruct(AbstractConverter &, pft::Evaluation &,
                          const parser::OpenACCConstruct &);
+void genOpenACCDeclarativeConstruct(
+    AbstractConverter &, pft::Evaluation &,
+    const parser::OpenACCDeclarativeConstruct &);
 
 } // namespace lower
 } // namespace Fortran
 
 #endif // FORTRAN_LOWER_OPENACC_H

flang/include/flang/Lower/OpenMP.h

 //===----------------------------------------------------------------------===//
 
 #ifndef FORTRAN_LOWER_OPENMP_H
 #define FORTRAN_LOWER_OPENMP_H
 
 namespace Fortran {
 namespace parser {
 struct OpenMPConstruct;
+struct OpenMPDeclarativeConstruct;
 } // namespace parser
 
 namespace lower {
 
 class AbstractConverter;
 
 namespace pft {
 struct Evaluation;
 } // namespace pft
 
 void genOpenMPConstruct(AbstractConverter &, pft::Evaluation &,
                         const parser::OpenMPConstruct &);
+void genOpenMPDeclarativeConstruct(AbstractConverter &, pft::Evaluation &,
+                                   const parser::OpenMPDeclarativeConstruct &);
 
 } // namespace lower
 } // namespace Fortran
 
 #endif // FORTRAN_LOWER_OPENMP_H

flang/lib/Lower/Bridge.cpp

private:
   void genFIR(const Fortran::parser::OpenACCConstruct &acc) {
     mlir::OpBuilder::InsertPoint insertPt = builder->saveInsertionPoint();
     genOpenACCConstruct(*this, getEval(), acc);
     for (Fortran::lower::pft::Evaluation &e : getEval().getNestedEvaluations())
       genFIR(e);
     builder->restoreInsertionPoint(insertPt);
   }
 
-  void genFIR(const Fortran::parser::OpenACCDeclarativeConstruct &) {
-    TODO(toLocation(), "OpenACCDeclarativeConstruct lowering");
+  void genFIR(const Fortran::parser::OpenACCDeclarativeConstruct &accDecl) {
+    mlir::OpBuilder::InsertPoint insertPt = builder->saveInsertionPoint();
+    genOpenACCDeclarativeConstruct(*this, getEval(), accDecl);
+    for (Fortran::lower::pft::Evaluation &e : getEval().getNestedEvaluations())
+      genFIR(e);
+    builder->restoreInsertionPoint(insertPt);
   }
 
   void genFIR(const Fortran::parser::OpenMPConstruct &omp) {
     mlir::OpBuilder::InsertPoint insertPt = builder->saveInsertionPoint();
     localSymbols.pushScope();
     Fortran::lower::genOpenMPConstruct(*this, getEval(), omp);
 
     for (Fortran::lower::pft::Evaluation &e : getEval().getNestedEvaluations())
       genFIR(e);
     localSymbols.popScope();
     builder->restoreInsertionPoint(insertPt);
   }
 
   void genFIR(const Fortran::parser::OpenMPDeclarativeConstruct &ompDecl) {
-    TODO(toLocation(), "OpenMPDeclarativeConstruct lowering");
+    mlir::OpBuilder::InsertPoint insertPt = builder->saveInsertionPoint();
+    genOpenMPDeclarativeConstruct(*this, getEval(), ompDecl);
+    for (Fortran::lower::pft::Evaluation &e : getEval().getNestedEvaluations())
+      genFIR(e);
+    builder->restoreInsertionPoint(insertPt);
   }
 
   /// Generate FIR for a SELECT CASE statement.
   /// The type may be CHARACTER, INTEGER, or LOGICAL.
   void genFIR(const Fortran::parser::SelectCaseStmt &stmt) {
     Fortran::lower::pft::Evaluation &eval = getEval();
     mlir::MLIRContext *context = builder->getContext();
     mlir::Location loc = toLocation();

flang/lib/Lower/OpenACC.cpp

std::visit(
           },
           [&](const Fortran::parser::OpenACCLoopConstruct &loopConstruct) {
             genACC(converter, eval, loopConstruct);
           },
           [&](const Fortran::parser::OpenACCStandaloneConstruct
                   &standaloneConstruct) {
             genACC(converter, eval, standaloneConstruct);
           },
-          [&](const Fortran::parser::OpenACCRoutineConstruct
-                  &routineConstruct) {
-            TODO(converter.getCurrentLocation(),
-                 "OpenACC Routine construct not lowered yet!");
-          },
           [&](const Fortran::parser::OpenACCCacheConstruct &cacheConstruct) {
             TODO(converter.getCurrentLocation(),
                  "OpenACC Cache construct not lowered yet!");
           },
           [&](const Fortran::parser::OpenACCWaitConstruct &waitConstruct) {
             genACC(converter, eval, waitConstruct);
           },
           [&](const Fortran::parser::OpenACCAtomicConstruct &atomicConstruct) {
             TODO(converter.getCurrentLocation(),
                  "OpenACC Atomic construct not lowered yet!");
           },
       },
       accConstruct.u);
 }
+
+void Fortran::lower::genOpenACCDeclarativeConstruct(
+    Fortran::lower::AbstractConverter &converter,
+    Fortran::lower::pft::Evaluation &eval,
+    const Fortran::parser::OpenACCDeclarativeConstruct &accDeclConstruct) {
+
+  std::visit(
+      common::visitors{
+          [&](const Fortran::parser::OpenACCStandaloneDeclarativeConstruct
+                  &standaloneDeclarativeConstruct) {
+            TODO(converter.getCurrentLocation(),
+                 "OpenACC Standalone Declarative construct not lowered yet!");
+          },
+          [&](const Fortran::parser::OpenACCRoutineConstruct
+                  &routineConstruct) {
+            TODO(converter.getCurrentLocation(),
+                 "OpenACC Routine construct not lowered yet!");
+          },
+      },
+      accDeclConstruct.u);
+}

flang/lib/Lower/OpenMP.cpp

std::visit(
           },
           [&](const Fortran::parser::OpenMPCriticalConstruct
                   &criticalConstruct) {
             genOMP(converter, eval, criticalConstruct);
           },
       },
       ompConstruct.u);
 }
+
+void Fortran::lower::genOpenMPDeclarativeConstruct(
+    Fortran::lower::AbstractConverter &converter,
+    Fortran::lower::pft::Evaluation &eval,
+    const Fortran::parser::OpenMPDeclarativeConstruct &ompDeclConstruct) {
+
+  std::visit(
+      common::visitors{
+          [&](const Fortran::parser::OpenMPDeclarativeAllocate
+                  &declarativeAllocate) {
+            TODO(converter.getCurrentLocation(), "OpenMPDeclarativeAllocate");
+          },
+          [&](const Fortran::parser::OpenMPDeclareReductionConstruct
+                  &declareReductionConstruct) {
+            TODO(converter.getCurrentLocation(),
+                 "OpenMPDeclareReductionConstruct");
+          },
+          [&](const Fortran::parser::OpenMPDeclareSimdConstruct
+                  &declareSimdConstruct) {
+            TODO(converter.getCurrentLocation(), "OpenMPDeclareSimdConstruct");
+          },
+          [&](const Fortran::parser::OpenMPDeclareTargetConstruct
+                  &declareTargetConstruct) {
+            TODO(converter.getCurrentLocation(),
+                 "OpenMPDeclareTargetConstruct");
+          },
+          [&](const Fortran::parser::OpenMPThreadprivate &threadprivate) {
+            TODO(converter.getCurrentLocation(), "OpenMPThreadprivate");
+          },
+      },
+      ompDeclConstruct.u);
+}

flang/test/Lower/OpenACC/Todo/acc-declare.f90

+! This test checks lowering of OpenACC declare Directive.
+
+// RUN: not flang-new -fc1 -emit-fir -fopenacc %s 2>&1 | FileCheck %s
+
+program main
+  real, dimension(10) :: aa, bb
+
+  // CHECK: not yet implemented: OpenACC Standalone Declarative construct
+  !$acc declare present(aa, bb)
+end

flang/test/Lower/OpenACC/Todo/acc-routine.f90

+! This test checks lowering of OpenACC routine Directive.
+
+// RUN: not flang-new -fc1 -emit-fir -fopenacc %s 2>&1 | FileCheck %s
+
+program main
+  // CHECK: not yet implemented: OpenACC Routine construct not lowered yet!
+  !$acc routine(sub) seq
+contains
+  subroutine sub(a)
+    real :: a(:)
+  end
+end

flang/test/Lower/OpenMP/Todo/omp-declarative-allocate.f90

+! This test checks lowering of OpenMP allocate Directive.
+
+// RUN: not flang-new -fc1 -emit-fir -fopenmp %s 2>&1 | FileCheck %s
+
+program main
+  integer :: x, y
+
+  // CHECK: not yet implemented: OpenMPDeclarativeAllocate
+  !$omp allocate(x, y)
+end

flang/test/Lower/OpenMP/Todo/omp-declare-reduction.f90

+! This test checks lowering of OpenMP declare reduction Directive.
+
+// RUN: not flang-new -fc1 -emit-fir -fopenmp %s 2>&1 | FileCheck %s
+
+subroutine declare_red()
+  integer :: my_var
+  // CHECK: not yet implemented: OpenMPDeclareReductionConstruct
+  !$omp declare reduction (my_red : integer : omp_out = omp_in) initializer (omp_priv = 0)
+  my_var = 0
+end subroutine declare_red

flang/test/Lower/OpenMP/Todo/omp-declare-simd.f90

+! This test checks lowering of OpenMP declare simd Directive.
+
+// RUN: not flang-new -fc1 -emit-fir -fopenmp %s 2>&1 | FileCheck %s
+
+subroutine sub(x, y)
+  real, intent(inout) :: x, y
+
+  // CHECK: not yet implemented: OpenMPDeclareSimdConstruct
+  !$omp declare simd(sub) aligned(x)
+  x = 3.14 + y
+end

flang/test/Lower/OpenMP/Todo/omp-declare-target.f90

+! This test checks lowering of OpenMP declare target Directive.
+
+// RUN: not flang-new -fc1 -emit-fir -fopenmp %s 2>&1 | FileCheck %s
+
+module mod1
+contains
+  subroutine sub()
+    integer :: x, y
+    // CHECK: not yet implemented: OpenMPDeclareTargetConstruct
+    !$omp declare target
+  end
+end module

flang/test/Lower/OpenMP/Todo/omp-threadprivate.f90

+! This test checks lowering of OpenMP threadprivate Directive.
+
+// RUN: not flang-new -fc1 -emit-fir -fopenmp %s 2>&1 | FileCheck %s
+
+program main
+  integer, save :: x, y
+
+// CHECK: not yet implemented: OpenMPThreadprivate
+  !$omp threadprivate(x, y)
+end