[flang][OpenMP] Add semantic check for cancellation nesting

[peixin]

Summary

This patch implements the following check for cancellation constructs:

OpenMP Version 5.0 Section 2.18.1: CANCEL construct restriction:
If construct-type-clause is taskgroup, the cancel construct must be
closely nested inside a task or a taskloop construct and the cancel
region must be closely nested inside a taskgroup region. If
construct-type-clause is sections, the cancel construct must be closely
nested inside a sections or section construct. Otherwise, the cancel
construct must be closely nested inside an OpenMP construct that matches
the type specified in construct-type-clause of the cancel construct.

OpenMP Version 5.0 Section 2.18.2: CANCELLATION POINT restriction:
A cancellation point construct for which construct-type-clause is
taskgroup must be closely nested inside a task or taskloop construct,
and the cancellation point region must be closely nested inside a
taskgroup region. A cancellation point construct for which
construct-type-clause is sections must be closely nested inside a
sections or section construct. A cancellation point construct for which
construct-type-clause is neither sections nor taskgroup must be closely
nested inside an OpenMP construct that matches the type specified in
construct-type-clause.

Also add test cases for the check.

[peixin]

Currently, I do not implement the semantic check for the following two scenarios, which should not be allowed according to OpenMP Version 5.0 Specification.

!$omp task
  !$omp cancel taskgroup
!$omp end task

!$omp taskloop nogroup
  do i = 1, N
    !$omp cancel taskgroup
    a = 3.14;
  end do

They are supported by gfortran and current clang. Should we report errors or warnings or just ignore it? Or maybe my understanding is incorrect.

[kiranchandramohan]

In D106538#2896051, @peixin wrote:

Currently, I do not implement the semantic check for the following two scenarios, which should not be allowed according to OpenMP Version 5.0 Specification.

!$omp task
  !$omp cancel taskgroup
!$omp end task

!$omp taskloop nogroup
  do i = 1, N
    !$omp cancel taskgroup
    a = 3.14;
  end do

They are supported by gfortran and current clang. Should we report errors or warnings or just ignore it? Or maybe my understanding is incorrect.

The region is a dynamic concept, unlike constructs. So nesting of regions is satisfied if the taskgroup is enclosing somewhere in the call sequence. This is difficult to test since it requires interprocedural analysis.

subroutine two
!$omp task
  !$omp cancel taskgroup
!$omp end task
end subroutine two

subroutine one
!$omp taskgroup
call two()
!$omp end taskgroup
end subroutine one

I think the current implementation does not catch the following case which is clearly not permitted by the standard.
(Note the definition of closely nested region. A region nested inside another region with no parallel region nested between them)

subroutine sb
!$omp parallel
  !$omp task
    !$omp cancel taskgroup
  !$omp end task
!$omp end parallel
end subroutine

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

934

Nit: Can you provide a better error message here? Like "%s directive is not closely nested inside %s"

[peixin]

@kiranchandramohan Thanks for the explanation and review.

Add the test case you provided that I did not catch in last patch and other three scenarios that should also be not permitted by the standard. The implementation of cancel taskgroup is fixed to cover these test scenarios.

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

934

Fixed the error message. Could you please check if it is ok now?

[peixin]

Found two more scenarios that are not covered. Please wait for the new patch to review in a few minutes.

[peixin]

Add the following test scenarios, which is taskgroup nested between parallel and cancel taskgroup and fix the implementation by break the for loop when encountering taskgroup or parallel/target parallel.

!$omp parallel
!$omp taskgroup
!$omp task
!$omp cancel taskgroup
a = 3.14
!$omp end task
!$omp end taskgroup
!$omp end parallel

!$omp parallel
!$omp taskgroup
!$omp taskloop nogroup
do i = 1, N
  !$omp cancel taskgroup
  a = 3.14
end do
!$omp end taskloop
!$omp end taskgroup
!$omp end parallel

By the way, according to the description of target parallel construct in OpenMP 5.0 Specification, the target parallel construct should have the similar behavior as the above parallel construct.

Target Parallel Description
The semantics are identical to explicitly specifying a target directive immediately followed by a parallel directive.

[kiranchandramohan]

LGTM. Thanks for the patch and the patience.

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

885

Nit: Add a comment here on what is checked in the if portion.

904

Nit: Can you add a comment signifying the importance of 3?

957

Nit: Add a comment here on what is checked in the else portion.

[peixin]

@kiranchandramohan Thanks for the review. Added the comments.

[Leporacanthicus]

It would seem that your patch may have broken some builds:
https://lab.llvm.org/buildbot/#/builders/175/builds/2077

There are default cases in switches, where those defaults can not be reached because all cases are covered.

Proibably relatively easy to fix by deleting those default statements.

[kiranchandramohan]

I have pushed in a fix directly.
https://github.com/llvm/llvm-project/commit/6c3ae442ac9c2d740947d11efe870438c1db83b8

[peixin]

@Leporacanthicus @kiranchandramohan Thanks for the help.

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

void CheckIsLoopIvPartOfClause(
       llvmOmpClause clause, const parser::OmpObjectList &ompObjectList);
   void CheckWorkshareBlockStmts(const parser::Block &, parser::CharBlock);
 
   void CheckLoopItrVariableIsInt(const parser::OpenMPLoopConstruct &x);
   void CheckDoWhile(const parser::OpenMPLoopConstruct &x);
   void CheckCycleConstraints(const parser::OpenMPLoopConstruct &x);
   void CheckDistLinear(const parser::OpenMPLoopConstruct &x);
   void CheckSIMDNest(const parser::OpenMPConstruct &x);
+  void CheckCancellationNest(
+      const parser::CharBlock &source, const parser::OmpCancelType::Type &type);
   std::int64_t GetOrdCollapseLevel(const parser::OpenMPLoopConstruct &x);
   void CheckIfDoOrderedClause(const parser::OmpBlockDirective &blkDirectiv);
   bool CheckReductionOperators(const parser::OmpClause::Reduction &);
   bool CheckIntrinsicOperator(
       const parser::DefinedOperator::IntrinsicOperator &);
   void CheckReductionTypeList(const parser::OmpClause::Reduction &);
   void CheckMasterNesting(const parser::OpenMPBlockConstruct &x);
   void CheckBarrierNesting(const parser::OpenMPSimpleStandaloneConstruct &x);

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

if (const auto &flushList{
           "must not be specified on the FLUSH directive"_err_en_US);
     }
   }
   dirContext_.pop_back();
 }
 
 void OmpStructureChecker::Enter(const parser::OpenMPCancelConstruct &x) {
   const auto &dir{std::get<parser::Verbatim>(x.t)};
+  const auto &type{std::get<parser::OmpCancelType>(x.t)};
   PushContextAndClauseSets(dir.source, llvm::omp::Directive::OMPD_cancel);
+  CheckCancellationNest(dir.source, type.v);
 }
 
 void OmpStructureChecker::Leave(const parser::OpenMPCancelConstruct &) {
   dirContext_.pop_back();
 }
 
 void OmpStructureChecker::Enter(const parser::OpenMPCriticalConstruct &x) {
   const auto &dir{std::get<parser::OmpCriticalDirective>(x.t)};
   PushContextAndClauseSets(dir.source, llvm::omp::Directive::OMPD_critical);
   const auto &block{std::get<parser::Block>(x.t)};
   CheckNoBranching(block, llvm::omp::Directive::OMPD_critical, dir.source);
 }
 
 void OmpStructureChecker::Leave(const parser::OpenMPCriticalConstruct &) {
   dirContext_.pop_back();
 }
 
 void OmpStructureChecker::Enter(
     const parser::OpenMPCancellationPointConstruct &x) {
   const auto &dir{std::get<parser::Verbatim>(x.t)};
+  const auto &type{std::get<parser::OmpCancelType>(x.t)};
   PushContextAndClauseSets(
       dir.source, llvm::omp::Directive::OMPD_cancellation_point);
+  CheckCancellationNest(dir.source, type.v);
 }
 
 void OmpStructureChecker::Leave(
     const parser::OpenMPCancellationPointConstruct &) {
   dirContext_.pop_back();
 }
 
+void OmpStructureChecker::CheckCancellationNest(
+    const parser::CharBlock &source, const parser::OmpCancelType::Type &type) {
+  if (CurrentDirectiveIsNested()) {
+    // If construct-type-clause is taskgroup, the cancellation construct must be
+    // closely nested inside a task or a taskloop construct and the cancellation
+    // region must be closely nested inside a taskgroup region. If
+    // construct-type-clause is sections, the cancellation construct must be
+    // closely nested inside a sections or section construct. Otherwise, the
+    // cancellation construct must be closely nested inside an OpenMP construct
+    // that matches the type specified in construct-type-clause of the
+    // cancellation construct.
+
+    OmpDirectiveSet allowedTaskgroupSet{
+        llvm::omp::Directive::OMPD_task, llvm::omp::Directive::OMPD_taskloop};
+    OmpDirectiveSet allowedSectionsSet{llvm::omp::Directive::OMPD_sections,
+        llvm::omp::Directive::OMPD_parallel_sections};
+    OmpDirectiveSet allowedDoSet{llvm::omp::Directive::OMPD_do,
+        llvm::omp::Directive::OMPD_distribute_parallel_do,
+        llvm::omp::Directive::OMPD_parallel_do,
+        llvm::omp::Directive::OMPD_target_parallel_do,
+        llvm::omp::Directive::OMPD_target_teams_distribute_parallel_do,
+        llvm::omp::Directive::OMPD_teams_distribute_parallel_do};
+    OmpDirectiveSet allowedParallelSet{llvm::omp::Directive::OMPD_parallel,
+        llvm::omp::Directive::OMPD_target_parallel};
+
+    bool eligibleCancellation{false};
+    switch (type) {
+    case parser::OmpCancelType::Type::Taskgroup:
+      if (allowedTaskgroupSet.test(GetContextParent().directive)) {
+        eligibleCancellation = true;
+        if (dirContext_.size() >= 3) {
+          // Check if the cancellation region is closely nested inside a
+          // taskgroup region when there are more than two levels of directives
+          // in the directive context stack.
+          if (GetContextParent().directive == llvm::omp::Directive::OMPD_task ||
+              FindClauseParent(llvm::omp::Clause::OMPC_nogroup)) {
+            for (int i = dirContext_.size() - 3; i >= 0; i--) {
+              if (dirContext_[i].directive ==
+                  llvm::omp::Directive::OMPD_taskgroup) {
+                break;
+              }
+              if (allowedParallelSet.test(dirContext_[i].directive)) {
+                eligibleCancellation = false;
+                break;
+              }
+            }
+          }
+        }
+      }
+      if (!eligibleCancellation) {
+        context_.Say(source,
+            "With %s clause, %s construct must be closely nested inside TASK "
+            "or TASKLOOP construct and %s region must be closely nested inside "
+            "TASKGROUP region"_err_en_US,
+            parser::ToUpperCaseLetters(
+                parser::OmpCancelType::EnumToString(type)),
+            ContextDirectiveAsFortran(), ContextDirectiveAsFortran());
+      }
+      return;
+    case parser::OmpCancelType::Type::Sections:
+      if (allowedSectionsSet.test(GetContextParent().directive)) {
+        eligibleCancellation = true;
+      }
+      break;
+    case Fortran::parser::OmpCancelType::Type::Do:
+      if (allowedDoSet.test(GetContextParent().directive)) {
+        eligibleCancellation = true;
+      }
+      break;
+    case parser::OmpCancelType::Type::Parallel:
+      if (allowedParallelSet.test(GetContextParent().directive)) {
+        eligibleCancellation = true;
+      }
+      break;
+    default:
+      break;
+    }
+    if (!eligibleCancellation) {
+      context_.Say(source,
+          "With %s clause, %s construct cannot be closely nested inside %s "
+          "construct"_err_en_US,
+          parser::ToUpperCaseLetters(parser::OmpCancelType::EnumToString(type)),
+          ContextDirectiveAsFortran(),
+          parser::ToUpperCaseLetters(
+              getDirectiveName(GetContextParent().directive).str()));
+    }
+  } else {
+    // The cancellation directive cannot be orphaned.
+    switch (type) {
+    case parser::OmpCancelType::Type::Taskgroup:
+      context_.Say(source,
+          "%s %s directive is not closely nested inside "
+          "TASK or TASKLOOP"_err_en_US,
+          ContextDirectiveAsFortran(),
+          parser::ToUpperCaseLetters(
+              parser::OmpCancelType::EnumToString(type)));
+      break;
+    case parser::OmpCancelType::Type::Sections:
+      context_.Say(source,
+          "%s %s directive is not closely nested inside "
+          "SECTION or SECTIONS"_err_en_US,
+          ContextDirectiveAsFortran(),
+          parser::ToUpperCaseLetters(
+              parser::OmpCancelType::EnumToString(type)));
+      break;
+    case Fortran::parser::OmpCancelType::Type::Do:
+      context_.Say(source,
+          "%s %s directive is not closely nested inside "
+          "the construct that matches the DO clause type"_err_en_US,
+          ContextDirectiveAsFortran(),
+          parser::ToUpperCaseLetters(
+              parser::OmpCancelType::EnumToString(type)));
+      break;
+    case parser::OmpCancelType::Type::Parallel:
+      context_.Say(source,
+          "%s %s directive is not closely nested inside "
+          "the construct that matches the PARALLEL clause type"_err_en_US,
+          ContextDirectiveAsFortran(),
+          parser::ToUpperCaseLetters(
+              parser::OmpCancelType::EnumToString(type)));
+      break;
+    default:
+      break;
+    }
+  }
+}
+
 void OmpStructureChecker::Enter(const parser::OmpEndBlockDirective &x) {
   const auto &dir{std::get<parser::OmpBlockDirective>(x.t)};
   ResetPartialContext(dir.source);
   switch (dir.v) {
   // 2.7.3 end-single-clause -> copyprivate-clause |
   //                            nowait-clause
   case llvm::omp::Directive::OMPD_single:
     PushContextAndClauseSets(dir.source, llvm::omp::Directive::OMPD_end_single);

flang/test/Semantics/omp-clause-validity01.f90

! Standalone Directives (basic)
   !$omp flush acquire
   !ERROR: If memory-order-clause is RELEASE, ACQUIRE, or ACQ_REL, list items must not be specified on the FLUSH directive
   !$omp flush release (c)
   !ERROR: SEQ_CST clause is not allowed on the FLUSH directive
   !$omp flush seq_cst
   !ERROR: RELAXED clause is not allowed on the FLUSH directive
   !$omp flush relaxed
 
-  !$omp cancel DO
-  !$omp cancellation point parallel
-
 ! 2.13.2 critical Construct
 
   ! !$omp critical (first)
   a = 3.14
   ! !$omp end critical (first)
 
 ! 2.9.1 task-clause -> if-clause |
 !                      final-clause |

flang/test/Semantics/omp-nested-cancel.f90

+! RUN: %S/test_errors.sh %s %t %flang -fopenmp
+! REQUIRES: shell
+
+! OpenMP Version 5.0
+! Check OpenMP construct validity for the following directives:
+! 2.18.1 Cancel Construct
+
+program main
+  integer :: i, N = 10
+  real :: a
+
+  !ERROR: CANCEL TASKGROUP directive is not closely nested inside TASK or TASKLOOP
+  !$omp cancel taskgroup
+
+  !ERROR: CANCEL SECTIONS directive is not closely nested inside SECTION or SECTIONS
+  !$omp cancel sections
+
+  !ERROR: CANCEL DO directive is not closely nested inside the construct that matches the DO clause type
+  !$omp cancel do
+
+  !ERROR: CANCEL PARALLEL directive is not closely nested inside the construct that matches the PARALLEL clause type
+  !$omp cancel parallel
+
+  !$omp parallel
+  !$omp sections
+  !$omp cancel sections
+  !$omp section
+  a = 3.14
+  !$omp end sections
+  !$omp end parallel
+
+  !$omp sections
+  !$omp section
+  !$omp cancel sections
+  a = 3.14
+  !$omp end sections
+
+  !$omp parallel
+  !ERROR: With SECTIONS clause, CANCEL construct cannot be closely nested inside PARALLEL construct
+  !$omp cancel sections
+  a = 3.14
+  !$omp end parallel
+
+  !$omp parallel sections
+  !$omp cancel sections
+  a = 3.14
+  !$omp end parallel sections
+
+  !$omp do
+  do i = 1, N
+    a = 3.14
+    !$omp cancel do
+  end do
+  !$omp end do
+
+  !$omp parallel do
+  do i = 1, N
+    a = 3.14
+    !$omp cancel do
+  end do
+  !$omp end parallel do
+
+  !$omp target
+  !$omp teams
+  !$omp distribute parallel do
+  do i = 1, N
+    a = 3.14
+    !$omp cancel do
+  end do
+  !$omp end distribute parallel do
+  !$omp end teams
+  !$omp end target
+
+  !$omp target
+  !$omp teams distribute parallel do
+  do i = 1, N
+    a = 3.14
+    !$omp cancel do
+  end do
+  !$omp end teams distribute parallel do
+  !$omp end target
+
+  !$omp target teams distribute parallel do
+  do i = 1, N
+    a = 3.14
+    !$omp cancel do
+  end do
+  !$omp end target teams distribute parallel do
+
+  !$omp target parallel do
+  do i = 1, N
+    a = 3.14
+    !$omp cancel do
+  end do
+  !$omp end target parallel do
+
+  !$omp parallel
+  do i = 1, N
+    a = 3.14
+    !ERROR: With DO clause, CANCEL construct cannot be closely nested inside PARALLEL construct
+    !$omp cancel do
+  end do
+  !$omp end parallel
+
+  !$omp parallel
+  do i = 1, N
+    a = 3.14
+    !$omp cancel parallel
+  end do
+  !$omp end parallel
+
+  !$omp target parallel
+  do i = 1, N
+    a = 3.14
+    !$omp cancel parallel
+  end do
+  !$omp end target parallel
+
+  !$omp target parallel do
+  do i = 1, N
+    a = 3.14
+    !ERROR: With PARALLEL clause, CANCEL construct cannot be closely nested inside TARGET PARALLEL DO construct
+    !$omp cancel parallel
+  end do
+  !$omp end target parallel do
+
+  !$omp do
+  do i = 1, N
+    a = 3.14
+    !ERROR: With PARALLEL clause, CANCEL construct cannot be closely nested inside DO construct
+    !$omp cancel parallel
+  end do
+  !$omp end do
+
+contains
+  subroutine sub1()
+    !$omp task
+    !$omp cancel taskgroup
+    a = 3.14
+    !$omp end task
+
+    !$omp taskloop
+    do i = 1, N
+      !$omp parallel
+      !$omp end parallel
+      !$omp cancel taskgroup
+      a = 3.14
+    end do
+    !$omp end taskloop
+
+    !$omp taskloop nogroup
+    do i = 1, N
+      !$omp cancel taskgroup
+      a = 3.14
+    end do
+
+    !$omp parallel
+    !ERROR: With TASKGROUP clause, CANCEL construct must be closely nested inside TASK or TASKLOOP construct and CANCEL region must be closely nested inside TASKGROUP region
+    !$omp cancel taskgroup
+    a = 3.14
+    !$omp end parallel
+
+    !$omp do
+    do i = 1, N
+      !$omp task
+      !$omp cancel taskgroup
+      a = 3.14
+      !$omp end task
+    end do
+    !$omp end do
+
+    !$omp parallel
+    !$omp taskgroup
+    !$omp task
+    !$omp cancel taskgroup
+    a = 3.14
+    !$omp end task
+    !$omp end taskgroup
+    !$omp end parallel
+
+    !$omp parallel
+    !$omp task
+    !ERROR: With TASKGROUP clause, CANCEL construct must be closely nested inside TASK or TASKLOOP construct and CANCEL region must be closely nested inside TASKGROUP region
+    !$omp cancel taskgroup
+    a = 3.14
+    !$omp end task
+    !$omp end parallel
+
+    !$omp parallel
+    !$omp do
+    do i = 1, N
+      !$omp task
+      !ERROR: With TASKGROUP clause, CANCEL construct must be closely nested inside TASK or TASKLOOP construct and CANCEL region must be closely nested inside TASKGROUP region
+      !$omp cancel taskgroup
+      a = 3.14
+      !$omp end task
+    end do
+    !$omp end do
+    !$omp end parallel
+
+    !$omp target parallel
+    !$omp task
+    !ERROR: With TASKGROUP clause, CANCEL construct must be closely nested inside TASK or TASKLOOP construct and CANCEL region must be closely nested inside TASKGROUP region
+    !$omp cancel taskgroup
+    a = 3.14
+    !$omp end task
+    !$omp end target parallel
+
+    !$omp parallel
+    !$omp taskloop private(j) nogroup
+    do i = 1, N
+      !ERROR: With TASKGROUP clause, CANCEL construct must be closely nested inside TASK or TASKLOOP construct and CANCEL region must be closely nested inside TASKGROUP region
+      !$omp cancel taskgroup
+      a = 3.14
+    end do
+    !$omp end taskloop
+    !$omp end parallel
+
+    !$omp parallel
+    !$omp taskloop
+    do i = 1, N
+      !$omp cancel taskgroup
+      a = 3.14
+    end do
+    !$omp end taskloop
+    !$omp end parallel
+
+    !$omp parallel
+    !$omp taskgroup
+    !$omp taskloop nogroup
+    do i = 1, N
+      !$omp cancel taskgroup
+      a = 3.14
+    end do
+    !$omp end taskloop
+    !$omp end taskgroup
+    !$omp end parallel
+
+    !$omp target parallel
+    !$omp taskloop nogroup
+    do i = 1, N
+      !ERROR: With TASKGROUP clause, CANCEL construct must be closely nested inside TASK or TASKLOOP construct and CANCEL region must be closely nested inside TASKGROUP region
+      !$omp cancel taskgroup
+      a = 3.14
+    end do
+    !$omp end taskloop
+    !$omp end target parallel
+  end subroutine sub1
+
+end program main

flang/test/Semantics/omp-nested-cancellation-point.f90

+! RUN: %S/test_errors.sh %s %t %flang -fopenmp
+! REQUIRES: shell
+
+! OpenMP Version 5.0
+! Check OpenMP construct validity for the following directives:
+! 2.18.2 Cancellation Point Construct
+
+program main
+  integer :: i, N = 10
+  real :: a
+
+  !ERROR: CANCELLATION POINT TASKGROUP directive is not closely nested inside TASK or TASKLOOP
+  !$omp cancellation point taskgroup
+
+  !ERROR: CANCELLATION POINT SECTIONS directive is not closely nested inside SECTION or SECTIONS
+  !$omp cancellation point sections
+
+  !ERROR: CANCELLATION POINT DO directive is not closely nested inside the construct that matches the DO clause type
+  !$omp cancellation point do
+
+  !ERROR: CANCELLATION POINT PARALLEL directive is not closely nested inside the construct that matches the PARALLEL clause type
+  !$omp cancellation point parallel
+
+  !$omp parallel
+  !$omp sections
+  !$omp cancellation point sections
+  !$omp section
+  a = 3.14
+  !$omp end sections
+  !$omp end parallel
+
+  !$omp sections
+  !$omp section
+  !$omp cancellation point sections
+  a = 3.14
+  !$omp end sections
+
+  !$omp parallel
+  !ERROR: With SECTIONS clause, CANCELLATION POINT construct cannot be closely nested inside PARALLEL construct
+  !$omp cancellation point sections
+  a = 3.14
+  !$omp end parallel
+
+  !$omp parallel sections
+  !$omp cancellation point sections
+  a = 3.14
+  !$omp end parallel sections
+
+  !$omp do
+  do i = 1, N
+    a = 3.14
+    !$omp cancellation point do
+  end do
+  !$omp end do
+
+  !$omp parallel do
+  do i = 1, N
+    a = 3.14
+    !$omp cancellation point do
+  end do
+  !$omp end parallel do
+
+  !$omp target
+  !$omp teams
+  !$omp distribute parallel do
+  do i = 1, N
+    a = 3.14
+    !$omp cancellation point do
+  end do
+  !$omp end distribute parallel do
+  !$omp end teams
+  !$omp end target
+
+  !$omp target
+  !$omp teams distribute parallel do
+  do i = 1, N
+    a = 3.14
+    !$omp cancellation point do
+  end do
+  !$omp end teams distribute parallel do
+  !$omp end target
+
+  !$omp target teams distribute parallel do
+  do i = 1, N
+    a = 3.14
+    !$omp cancellation point do
+  end do
+  !$omp end target teams distribute parallel do
+
+  !$omp target parallel do
+  do i = 1, N
+    a = 3.14
+    !$omp cancellation point do
+  end do
+  !$omp end target parallel do
+
+  !$omp parallel
+  do i = 1, N
+    a = 3.14
+    !ERROR: With DO clause, CANCELLATION POINT construct cannot be closely nested inside PARALLEL construct
+    !$omp cancellation point do
+  end do
+  !$omp end parallel
+
+  !$omp parallel
+  do i = 1, N
+    a = 3.14
+    !$omp cancellation point parallel
+  end do
+  !$omp end parallel
+
+  !$omp target parallel
+  do i = 1, N
+    a = 3.14
+    !$omp cancellation point parallel
+  end do
+  !$omp end target parallel
+
+  !$omp target parallel do
+  do i = 1, N
+    a = 3.14
+    !ERROR: With PARALLEL clause, CANCELLATION POINT construct cannot be closely nested inside TARGET PARALLEL DO construct
+    !$omp cancellation point parallel
+  end do
+  !$omp end target parallel do
+
+  !$omp do
+  do i = 1, N
+    a = 3.14
+    !ERROR: With PARALLEL clause, CANCELLATION POINT construct cannot be closely nested inside DO construct
+    !$omp cancellation point parallel
+  end do
+  !$omp end do
+
+contains
+  subroutine sub1()
+    !$omp task
+    !$omp cancellation point taskgroup
+    a = 3.14
+    !$omp end task
+
+    !$omp taskloop
+    do i = 1, N
+      !$omp parallel
+      !$omp end parallel
+      !$omp cancellation point taskgroup
+      a = 3.14
+    end do
+    !$omp end taskloop
+
+    !$omp taskloop nogroup
+    do i = 1, N
+      !$omp cancellation point taskgroup
+      a = 3.14
+    end do
+
+    !$omp parallel
+    !ERROR: With TASKGROUP clause, CANCELLATION POINT construct must be closely nested inside TASK or TASKLOOP construct and CANCELLATION POINT region must be closely nested inside TASKGROUP region
+    !$omp cancellation point taskgroup
+    a = 3.14
+    !$omp end parallel
+
+    !$omp do
+    do i = 1, N
+      !$omp task
+      !$omp cancellation point taskgroup
+      a = 3.14
+      !$omp end task
+    end do
+    !$omp end do
+
+    !$omp parallel
+    !$omp taskgroup
+    !$omp task
+    !$omp cancellation point taskgroup
+    a = 3.14
+    !$omp end task
+    !$omp end taskgroup
+    !$omp end parallel
+
+    !$omp parallel
+    !$omp task
+    !ERROR: With TASKGROUP clause, CANCELLATION POINT construct must be closely nested inside TASK or TASKLOOP construct and CANCELLATION POINT region must be closely nested inside TASKGROUP region
+    !$omp cancellation point taskgroup
+    a = 3.14
+    !$omp end task
+    !$omp end parallel
+
+    !$omp parallel
+    !$omp do
+    do i = 1, N
+      !$omp task
+      !ERROR: With TASKGROUP clause, CANCELLATION POINT construct must be closely nested inside TASK or TASKLOOP construct and CANCELLATION POINT region must be closely nested inside TASKGROUP region
+      !$omp cancellation point taskgroup
+      a = 3.14
+      !$omp end task
+    end do
+    !$omp end do
+    !$omp end parallel
+
+    !$omp target parallel
+    !$omp task
+    !ERROR: With TASKGROUP clause, CANCELLATION POINT construct must be closely nested inside TASK or TASKLOOP construct and CANCELLATION POINT region must be closely nested inside TASKGROUP region
+    !$omp cancellation point taskgroup
+    a = 3.14
+    !$omp end task
+    !$omp end target parallel
+
+    !$omp parallel
+    !$omp taskloop private(j) nogroup
+    do i = 1, N
+      !ERROR: With TASKGROUP clause, CANCELLATION POINT construct must be closely nested inside TASK or TASKLOOP construct and CANCELLATION POINT region must be closely nested inside TASKGROUP region
+      !$omp cancellation point taskgroup
+      a = 3.14
+    end do
+    !$omp end taskloop
+    !$omp end parallel
+
+    !$omp parallel
+    !$omp taskloop
+    do i = 1, N
+      !$omp cancellation point taskgroup
+      a = 3.14
+    end do
+    !$omp end taskloop
+    !$omp end parallel
+
+    !$omp parallel
+    !$omp taskgroup
+    !$omp taskloop nogroup
+    do i = 1, N
+      !$omp cancellation point taskgroup
+      a = 3.14
+    end do
+    !$omp end taskloop
+    !$omp end taskgroup
+    !$omp end parallel
+
+    !$omp target parallel
+    !$omp taskloop nogroup
+    do i = 1, N
+      !ERROR: With TASKGROUP clause, CANCELLATION POINT construct must be closely nested inside TASK or TASKLOOP construct and CANCELLATION POINT region must be closely nested inside TASKGROUP region
+      !$omp cancellation point taskgroup
+      a = 3.14
+    end do
+    !$omp end taskloop
+    !$omp end target parallel
+  end subroutine sub1
+
+end program main