[flang] [OpenMP 4.5] Add semantic checks for OpenMP Depend clause

[praveen]

Summary

Add the semantic checks for the OpenMP 4.5 - 2.13.9 Depend clause.

• List items in depend clause should not be zero length array sections
• A variable that is part of another variable like structure component should not be specified on a depend clause

Test cases : omp-depend01.f90 , omp-depend02.f90

[kiranchandramohan]

Thanks for the patch. A few questions inline.

flang/lib/Semantics/check-omp-structure.cpp

651

Can you check whether this is dropped from OpenMP 5.0. If so I would prefer to skip this check.

658

Can you add a test for this error?
Is this restriction from some other section or from a general point that Fortran features like Block, coarrays etc are not supported?

flang/lib/Semantics/check-omp-structure.h

165–167

Can these be private?

[kiranchandramohan]

Would need a response for questions above to proceed to acceptance.

[praveen]

Add test case omp-depend03.f90 for usage of coarray in the depend clause

[kiranchandramohan]

LGTM.

flang/lib/Semantics/check-omp-structure.h

#include "llvm/Frontend/OpenMP/OMP.cpp.inc"
   void Enter(const parser::OmpDistScheduleClause &);
   void Enter(const parser::OmpIfClause &);
   void Enter(const parser::OmpLinearClause &);
   void Enter(const parser::OmpMapClause &);
   void Enter(const parser::OmpProcBindClause &);
   void Enter(const parser::OmpReductionClause &);
   void Enter(const parser::OmpScheduleClause &);
 
-private:
+  void CheckDependList(const parser::DataRef &);
+  void CheckDependArraySection(
+      const common::Indirection<parser::ArrayElement> &, const parser::Name &);
 
+private:
   bool HasInvalidWorksharingNesting(
       const parser::CharBlock &, const OmpDirectiveSet &);
 
   // specific clause related
   bool ScheduleModifierHasType(const parser::OmpScheduleClause &,
       const parser::OmpScheduleModifierType::ModType &);
 
   llvm::StringRef getClauseName(llvm::omp::Clause clause) override;
   llvm::StringRef getDirectiveName(llvm::omp::Directive directive) override;
 };
 } // namespace Fortran::semantics
 #endif // FORTRAN_SEMANTICS_CHECK_OMP_STRUCTURE_H_

flang/lib/Semantics/check-omp-structure.cpp

void OmpStructureChecker::Enter(const parser::OmpDefaultmapClause &x) {
   CheckAllowed(llvm::omp::Clause::OMPC_defaultmap);
   using VariableCategory = parser::OmpDefaultmapClause::VariableCategory;
   if (!std::get<std::optional<VariableCategory>>(x.t)) {
     context_.Say(GetContext().clauseSource,
         "The argument TOFROM:SCALAR must be specified on the DEFAULTMAP "
         "clause"_err_en_US);
   }
 }
-void OmpStructureChecker::Enter(const parser::OmpDependClause &) {
+void OmpStructureChecker::Enter(const parser::OmpDependClause &x) {
   CheckAllowed(llvm::omp::Clause::OMPC_depend);
+  if (const auto *inOut{std::get_if<parser::OmpDependClause::InOut>(&x.u)}) {
+    const auto &designators{std::get<std::list<parser::Designator>>(inOut->t)};
+    for (const auto &ele : designators) {
+      if (const auto *dataRef{std::get_if<parser::DataRef>(&ele.u)}) {
+        CheckDependList(*dataRef);
+        if (const auto *arr{
+                std::get_if<common::Indirection<parser::ArrayElement>>(
+                    &dataRef->u)}) {
+          CheckDependArraySection(*arr, GetLastName(*dataRef));
+        }
+      }
+    }
+  }
 }
 
 void OmpStructureChecker::Enter(const parser::OmpIfClause &x) {
   CheckAllowed(llvm::omp::Clause::OMPC_if);
 
   using dirNameModifier = parser::OmpIfClause::DirectiveNameModifier;
   static std::unordered_map<dirNameModifier, OmpDirectiveSet>
       dirNameModifierMap{{dirNameModifier::Parallel, llvm::omp::parallelSet},
llvm::StringRef OmpStructureChecker::getClauseName(llvm::omp::Clause clause) {
   return llvm::omp::getOpenMPClauseName(clause);
 }
 
 llvm::StringRef OmpStructureChecker::getDirectiveName(
     llvm::omp::Directive directive) {
   return llvm::omp::getOpenMPDirectiveName(directive);
 }
 
+void OmpStructureChecker::CheckDependList(const parser::DataRef &d) {
+  std::visit(
+      common::visitors{
+          [&](const common::Indirection<parser::ArrayElement> &elem) {
+            // Check if the base element is valid on Depend Clause
+            CheckDependList(elem.value().base);
+          },
+          [&](const common::Indirection<parser::StructureComponent> &) {
+            context_.Say(GetContext().clauseSource,
+                "A variable that is part of another variable "
+                "(such as an element of a structure) but is not an array "
+                "element or an array section cannot appear in a DEPEND "
+                "clause"_err_en_US);
+          },
+          [&](const common::Indirection<parser::CoindexedNamedObject> &) {
+            context_.Say(GetContext().clauseSource,
+                "Coarrays are not supported in DEPEND clause"_err_en_US);
+          },
+          [&](const parser::Name &) { return; },
+      },
+      d.u);
+}
+
+void OmpStructureChecker::CheckDependArraySection(
+    const common::Indirection<parser::ArrayElement> &arr,
+    const parser::Name &name) {
+  for (const auto &subscript : arr.value().subscripts) {
+    if (const auto *triplet{
+            std::get_if<parser::SubscriptTriplet>(&subscript.u)}) {
+      if (std::get<2>(triplet->t)) {
+        context_.Say(GetContext().clauseSource,
+            "Stride should not be specified for array section in DEPEND "
+            "clause"_err_en_US);
+      }
+      const auto &lower{std::get<0>(triplet->t)};
+      const auto &upper{std::get<1>(triplet->t)};
+      if (lower && upper) {
+        const auto lval{GetIntValue(lower)};
+        const auto uval{GetIntValue(upper)};
+        if (lval && uval && *uval < *lval) {
+          context_.Say(GetContext().clauseSource,
+              "'%s' in DEPEND clause is a zero size array section"_err_en_US,
+              name.ToString());
+          break;
+        }
+      }
+    }
+  }
+}
+
 } // namespace Fortran::semantics

flang/test/Semantics/omp-depend01.f90

+! RUN: %S/test_errors.sh %s %t %f18 -fopenmp
+! OpenMP Version 4.5
+! 2.13.9 Depend Clause
+! List items used in depend clauses cannot be zero-length array sections.
+
+program omp_depend
+  integer :: a(10) , b(10,10)
+  a = 10
+  b = 20
+
+  !$omp parallel
+  !$omp single
+
+  !ERROR: 'a' in DEPEND clause is a zero size array section
+  !ERROR: 'b' in DEPEND clause is a zero size array section
+  !$omp task shared(a,b) depend(out: a(2:1), b(3:1, 1:-1))
+  a(2:1) = b(2, 2)
+  !$omp end task
+
+  !ERROR: Stride should not be specified for array section in DEPEND clause
+  !$omp task shared(x) depend(in: a(5:10:1))
+  print *, a(5:10), b
+  !$omp end task
+
+  !$omp end single
+  !$omp end parallel
+
+end program omp_depend

flang/test/Semantics/omp-depend02.f90

+! RUN: %S/test_errors.sh %s %t %f18 -fopenmp
+! OpenMP Version 4.5
+! 2.13.9 Depend Clause
+! A variable that is part of another variable
+! (such as an element of a structure) but is not an array element or
+! an array section cannot appear in a DEPEND clause
+
+subroutine vec_mult(N)
+  implicit none
+  integer :: i, N
+  real, allocatable :: p(:), v1(:), v2(:)
+
+  type my_type
+    integer :: a(10)
+  end type my_type
+
+  type(my_type) :: my_var
+  allocate( p(N), v1(N), v2(N) )
+
+  !$omp parallel num_threads(2)
+  !$omp single
+
+  !$omp task depend(out:v1)
+  call init(v1, N)
+  !$omp end task
+
+  !$omp task depend(out:v2)
+  call init(v2, N)
+  !$omp end task
+
+  !ERROR: A variable that is part of another variable (such as an element of a structure) but is not an array element or an array section cannot appear in a DEPEND clause
+  !$omp target nowait depend(in:v1,v2, my_var%a) depend(out:p) &
+  !$omp& map(to:v1,v2) map(from: p)
+  !$omp parallel do
+  do i=1,N
+    p(i) = v1(i) * v2(i)
+  end do
+  !$omp end target
+
+  !$omp task depend(in:p)
+  call output(p, N)
+  !$omp end task
+
+  !$omp end single
+  !$omp end parallel
+
+  deallocate( p, v1, v2 )
+
+end subroutine