[flang] Semantic checks for OpenMP combined constructs.

[DavidTruby]

Summary

This includes a refactor of the existing combined construct checks
that were present, as well as adding the remaining combined constructs
that had not been implemented yet.

[DavidTruby]

flang/include/flang/Common/enum-set.h

1

I have no idea what's going on with these lints. git-clang-format doesn't suggest any changes, and this is suggesting an empty change?

[DavidTruby]

This review is continued from https://github.com/flang-compiler/f18/pull/987

[jdoerfert]

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

30

This is the kind of information I would like to share with OMPKinds.def. While we need to add the "once" flag there the interface in OMPConstants.h is already there to be reused:

/// Return true if \p C is a valid clause for \p D in version \p Version.                                             
bool isAllowedClauseForDirective(Directive D, Clause C, unsigned Version);

[jdoerfert]

My other comment was of general nature not to block this review.

flang/include/flang/Common/enum-set.h

1

Maybe your local clang-format returns an error, e.g., it is not found? I'm guessing here.

[klausler]

flang/include/flang/Common/enum-set.h

115

Please be consistent with the braced initialization used throughout f18. It's safer for many types than old-style initialization.

119

That's going to add v to the set if it's not already present, which seems unintended.

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

16

What do you think inline is going to do for you when static also appears?

[DavidTruby]

flang/include/flang/Common/enum-set.h

115

Looking at it again I don't think the intermediate result is necessary anyway. I can just return the expression.

119

Good spot. I believe it should be *this & ~EnumSet{v};?

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

16

I'm really using inline here as a hint to the reader/future contributors of the intent of these variables. It's certainly not necessary, as it is implied by constexpr and the semantics it provides on top of static aren't necessary here.
I'm happy to remove it but I do think it signals the intent of what I'm doing.

30

I agree that it would be ideal to share this information between different parts of the LLVM project. However as alluded to in your email to flang-dev we would need to reconcile the difference between Flang's OmpDirective and OmpClause and the Directive and Clause classes in this function. I think that's outside the scope of this patch but certianly something we should consider in future!

[klausler]

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

16

What is the hint to the reader?

[DavidTruby]

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

16

That the variables shouldn't be used in any context that would cause them to have to exist in the binary

[klausler]

Is it possible to see an updated diff with fixes?

[DavidTruby]

In D77812#1978420, @klausler wrote:

Is it possible to see an updated diff with fixes?

Sure, I'll update it tomorrow; Friday and Today are non-working days here in the UK.

[DavidTruby]

Fix EnumSet bit handling.

[DavidTruby]

@klausler do you want me to make any more changes to this?

flang/include/flang/Common/enum-set.h

 //===-- include/flang/Common/enum-set.h -------------------------*- 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef FORTRAN_COMMON_ENUM_SET_H_
constexpr EnumSet operator^(const EnumSet &that) const {
     return result;
   }
   constexpr EnumSet operator^(EnumSet &&that) const {
     EnumSet result{*this};
     result.bitset_ ^= that.bitset_;
     return result;
   }
 
+  constexpr EnumSet operator+(enumerationType v) const {
+    return {*this | EnumSet{v}};
+  }
+  constexpr EnumSet operator-(enumerationType v) const {
+    return {*this & ~EnumSet{v}};
+  }
+
   constexpr bool operator==(const EnumSet &that) const {
     return bitset_ == that.bitset_;
   }
   constexpr bool operator==(EnumSet &&that) const {
     return bitset_ == that.bitset_;
   }
   constexpr bool operator!=(const EnumSet &that) const {
     return bitset_ != that.bitset_;

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

 //===-- lib/Semantics/check-omp-structure.cpp -----------------------------===//
 //
 // 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 "check-omp-structure.h"
 #include "flang/Parser/parse-tree.h"
 #include "flang/Semantics/tools.h"
 #include <unordered_map>
 
 namespace Fortran::semantics {
 
+static constexpr inline OmpClauseSet doAllowedClauses{OmpClause::PRIVATE,
+    OmpClause::FIRSTPRIVATE, OmpClause::LASTPRIVATE, OmpClause::LINEAR,
+    OmpClause::REDUCTION};
+static constexpr inline OmpClauseSet doAllowedOnceClauses{
+    OmpClause::SCHEDULE, OmpClause::COLLAPSE, OmpClause::ORDERED};
+
+static constexpr inline OmpClauseSet simdAllowedClauses{OmpClause::LINEAR,
+    OmpClause::ALIGNED, OmpClause::PRIVATE, OmpClause::LASTPRIVATE,
+    OmpClause::REDUCTION};
+static constexpr inline OmpClauseSet simdAllowedOnceClauses{
+    OmpClause::COLLAPSE, OmpClause::SAFELEN, OmpClause::SIMDLEN};
+
+static constexpr inline OmpClauseSet parallelAllowedClauses{OmpClause::DEFAULT,
+    OmpClause::PRIVATE, OmpClause::FIRSTPRIVATE, OmpClause::SHARED,
+    OmpClause::COPYIN, OmpClause::REDUCTION};
+static constexpr inline OmpClauseSet parallelAllowedOnceClauses{
+    OmpClause::IF, OmpClause::NUM_THREADS, OmpClause::PROC_BIND};
+
+static constexpr inline OmpClauseSet taskloopAllowedClauses{OmpClause::SHARED,
+    OmpClause::PRIVATE, OmpClause::FIRSTPRIVATE, OmpClause::LASTPRIVATE,
+    OmpClause::DEFAULT, OmpClause::UNTIED, OmpClause::MERGEABLE,
+    OmpClause::NOGROUP};
+static constexpr inline OmpClauseSet taskloopAllowedOnceClauses{
+    OmpClause::COLLAPSE, OmpClause::IF, OmpClause::FINAL, OmpClause::PRIORITY};
+static constexpr inline OmpClauseSet taskloopAllowedExclusiveClauses{
+    OmpClause::GRAINSIZE, OmpClause::NUM_TASKS};
+
+static constexpr inline OmpClauseSet distributeAllowedClauses{
+    OmpClause::PRIVATE, OmpClause::FIRSTPRIVATE, OmpClause::LASTPRIVATE};
+static constexpr inline OmpClauseSet distributeAllowedOnceClauses{
+    OmpClause::COLLAPSE, OmpClause::DIST_SCHEDULE};
+
+static constexpr inline OmpClauseSet targetAllowedClauses{OmpClause::IF,
+    OmpClause::PRIVATE, OmpClause::FIRSTPRIVATE, OmpClause::MAP,
+    OmpClause::IS_DEVICE_PTR, OmpClause::DEPEND};
+static constexpr inline OmpClauseSet targetAllowedOnceClauses{
+    OmpClause::DEVICE, OmpClause::DEFAULTMAP, OmpClause::NOWAIT};
+
+static constexpr inline OmpClauseSet teamsAllowedClauses{OmpClause::PRIVATE,
+    OmpClause::FIRSTPRIVATE, OmpClause::SHARED, OmpClause::REDUCTION};
+static constexpr inline OmpClauseSet teamsAllowedOnceClauses{
+    OmpClause::NUM_TEAMS, OmpClause::THREAD_LIMIT, OmpClause::DEFAULT};
+
+static constexpr inline OmpClauseSet sectionsAllowedClauses{OmpClause::PRIVATE,
+    OmpClause::FIRSTPRIVATE, OmpClause::LASTPRIVATE, OmpClause::REDUCTION};
+
 std::string OmpStructureChecker::ContextDirectiveAsFortran() {
   auto dir{EnumToString(GetContext().directive)};
   std::replace(dir.begin(), dir.end(), '_', ' ');
   return dir;
 }
 
 void OmpStructureChecker::SayNotMatching(
     const parser::CharBlock &beginSource, const parser::CharBlock &endSource) {
case parser::OmpLoopDirective::Directive::Do: {
     // nesting check
     HasInvalidWorksharingNesting(beginDir.source,
         {OmpDirective::DO, OmpDirective::SECTIONS, OmpDirective::SINGLE,
             OmpDirective::WORKSHARE, OmpDirective::TASK, OmpDirective::TASKLOOP,
             OmpDirective::CRITICAL, OmpDirective::ORDERED, OmpDirective::ATOMIC,
             OmpDirective::MASTER});
 
     PushContext(beginDir.source, OmpDirective::DO);
-    OmpClauseSet allowed{OmpClause::PRIVATE, OmpClause::FIRSTPRIVATE,
-        OmpClause::LASTPRIVATE, OmpClause::LINEAR, OmpClause::REDUCTION};
-    SetContextAllowed(allowed);
-    OmpClauseSet allowedOnce{
-        OmpClause::SCHEDULE, OmpClause::COLLAPSE, OmpClause::ORDERED};
-    SetContextAllowedOnce(allowedOnce);
+    SetContextAllowed(doAllowedClauses);
+    SetContextAllowedOnce(doAllowedOnceClauses);
   } break;
 
   // 2.11.1 parallel-do-clause -> parallel-clause |
   //                              do-clause
   case parser::OmpLoopDirective::Directive::ParallelDo: {
     PushContext(beginDir.source, OmpDirective::PARALLEL_DO);
-    OmpClauseSet allowed{OmpClause::DEFAULT, OmpClause::PRIVATE,
-        OmpClause::FIRSTPRIVATE, OmpClause::SHARED, OmpClause::COPYIN,
-        OmpClause::REDUCTION, OmpClause::LASTPRIVATE, OmpClause::LINEAR};
-    SetContextAllowed(allowed);
-    OmpClauseSet allowedOnce{OmpClause::IF, OmpClause::NUM_THREADS,
-        OmpClause::PROC_BIND, OmpClause::SCHEDULE, OmpClause::COLLAPSE,
-        OmpClause::ORDERED};
-    SetContextAllowedOnce(allowedOnce);
+    SetContextAllowed(parallelAllowedClauses | doAllowedClauses);
+    SetContextAllowedOnce(parallelAllowedOnceClauses | doAllowedOnceClauses);
   } break;
 
   // 2.8.1 simd-clause -> safelen-clause |
   //                      simdlen-clause |
   //                      linear-clause |
   //                      aligned-clause |
   //                      private-clause |
   //                      lastprivate-clause |
   //                      reduction-clause |
   //                      collapse-clause
   case parser::OmpLoopDirective::Directive::Simd: {
     PushContext(beginDir.source, OmpDirective::SIMD);
-    OmpClauseSet allowed{OmpClause::LINEAR, OmpClause::ALIGNED,
-        OmpClause::PRIVATE, OmpClause::LASTPRIVATE, OmpClause::REDUCTION};
-    SetContextAllowed(allowed);
-    OmpClauseSet allowedOnce{
-        OmpClause::COLLAPSE, OmpClause::SAFELEN, OmpClause::SIMDLEN};
-    SetContextAllowedOnce(allowedOnce);
+    SetContextAllowed(simdAllowedClauses);
+    SetContextAllowedOnce(simdAllowedOnceClauses);
   } break;
 
   // 2.8.3 do-simd-clause -> do-clause |
   //                         simd-clause
   case parser::OmpLoopDirective::Directive::DoSimd: {
     PushContext(beginDir.source, OmpDirective::DO_SIMD);
-    OmpClauseSet allowed{OmpClause::PRIVATE, OmpClause::FIRSTPRIVATE,
-        OmpClause::LASTPRIVATE, OmpClause::LINEAR, OmpClause::REDUCTION,
-        OmpClause::ALIGNED};
-    SetContextAllowed(allowed);
-    OmpClauseSet allowedOnce{OmpClause::SCHEDULE, OmpClause::COLLAPSE,
-        OmpClause::ORDERED, OmpClause::SAFELEN, OmpClause::SIMDLEN};
-    SetContextAllowedOnce(allowedOnce);
+    SetContextAllowed(doAllowedClauses | simdAllowedClauses);
+    SetContextAllowedOnce(doAllowedOnceClauses | simdAllowedOnceClauses);
   } break;
 
   // 2.11.4 parallel-do-simd-clause -> parallel-clause |
   //                                   do-simd-clause
   case parser::OmpLoopDirective::Directive::ParallelDoSimd: {
     PushContext(beginDir.source, OmpDirective::PARALLEL_DO_SIMD);
-    OmpClauseSet allowed{OmpClause::DEFAULT, OmpClause::PRIVATE,
-        OmpClause::FIRSTPRIVATE, OmpClause::SHARED, OmpClause::COPYIN,
-        OmpClause::REDUCTION, OmpClause::LASTPRIVATE, OmpClause::LINEAR,
-        OmpClause::ALIGNED};
-    SetContextAllowed(allowed);
-    OmpClauseSet allowedOnce{OmpClause::IF, OmpClause::NUM_THREADS,
-        OmpClause::PROC_BIND, OmpClause::SCHEDULE, OmpClause::COLLAPSE,
-        OmpClause::ORDERED, OmpClause::SAFELEN, OmpClause::SIMDLEN};
-    SetContextAllowedOnce(allowedOnce);
+    SetContextAllowed(
+        parallelAllowedClauses | doAllowedClauses | simdAllowedClauses);
+    SetContextAllowedOnce(parallelAllowedOnceClauses | doAllowedOnceClauses |
+        simdAllowedOnceClauses);
   } break;
 
   // 2.9.2 taskloop-clause -> if-clause |
   //                          shared-clause |
   //                          private-clause |
   //                          firstprivate-clause |
   //                          lastprivate-clause |
   //                          default-clause |
   //                          grainsize-clause |
   //                          num-tasks-clause |
   //                          collapse-clause |
   //                          final-clause |
   //                          priority-clause |
   //                          untied-clause |
   //                          mergeable-clause |
   //                          nogroup-clause
   case parser::OmpLoopDirective::Directive::Taskloop: {
     PushContext(beginDir.source, OmpDirective::TASKLOOP);
-    OmpClauseSet allowed{OmpClause::SHARED, OmpClause::PRIVATE,
-        OmpClause::FIRSTPRIVATE, OmpClause::LASTPRIVATE, OmpClause::DEFAULT,
-        OmpClause::UNTIED, OmpClause::MERGEABLE, OmpClause::NOGROUP};
-    SetContextAllowed(allowed);
-    OmpClauseSet allowedOnce{OmpClause::COLLAPSE, OmpClause::IF,
-        OmpClause::FINAL, OmpClause::PRIORITY};
-    SetContextAllowedOnce(allowedOnce);
-    OmpClauseSet allowedExclusive{OmpClause::GRAINSIZE, OmpClause::NUM_TASKS};
-    SetContextAllowedExclusive(allowedExclusive);
+    SetContextAllowed(taskloopAllowedClauses);
+    SetContextAllowedOnce(taskloopAllowedOnceClauses);
+    SetContextAllowedExclusive(taskloopAllowedExclusiveClauses);
   } break;
 
   // 2.9.3 taskloop-simd-clause -> taskloop-clause |
   //                               simd-clause
   case parser::OmpLoopDirective::Directive::TaskloopSimd: {
     PushContext(beginDir.source, OmpDirective::TASKLOOP_SIMD);
-    OmpClauseSet allowed{OmpClause::LINEAR, OmpClause::ALIGNED,
-        OmpClause::SHARED, OmpClause::PRIVATE, OmpClause::FIRSTPRIVATE,
-        OmpClause::LASTPRIVATE, OmpClause::DEFAULT, OmpClause::UNTIED,
-        OmpClause::MERGEABLE, OmpClause::NOGROUP};
-    SetContextAllowed(allowed);
-    OmpClauseSet allowedOnce{OmpClause::COLLAPSE, OmpClause::SAFELEN,
-        OmpClause::SIMDLEN, OmpClause::IF, OmpClause::FINAL,
-        OmpClause::PRIORITY};
-    SetContextAllowedOnce(allowedOnce);
-    OmpClauseSet allowedExclusive{OmpClause::GRAINSIZE, OmpClause::NUM_TASKS};
-    SetContextAllowedExclusive(allowedExclusive);
+    SetContextAllowed(
+        taskloopAllowedClauses | simdAllowedClauses - OmpClause::REDUCTION);
+    SetContextAllowedOnce(taskloopAllowedOnceClauses | simdAllowedOnceClauses);
+    SetContextAllowedExclusive(taskloopAllowedExclusiveClauses);
   } break;
 
   // 2.10.8 distribute-clause -> private-clause |
   //                             firstprivate-clause |
   //                             lastprivate-clause |
   //                             collapse-clause |
   //                             dist-schedule-clause
   case parser::OmpLoopDirective::Directive::Distribute: {
     PushContext(beginDir.source, OmpDirective::DISTRIBUTE);
-    OmpClauseSet allowed{
-        OmpClause::PRIVATE, OmpClause::FIRSTPRIVATE, OmpClause::LASTPRIVATE};
-    SetContextAllowed(allowed);
-    OmpClauseSet allowedOnce{OmpClause::COLLAPSE, OmpClause::DIST_SCHEDULE};
-    SetContextAllowedOnce(allowedOnce);
+    SetContextAllowed(distributeAllowedClauses);
+    SetContextAllowedOnce(distributeAllowedOnceClauses);
   } break;
 
-  default:
-    // TODO others
-    break;
+    // 2.10.9 distribute-simd-clause -> distribute-clause |
+    //                                  simd-clause
+  case parser::OmpLoopDirective::Directive::DistributeSimd: {
+    PushContext(beginDir.source, OmpDirective::DISTRIBUTE_SIMD);
+    SetContextAllowed(distributeAllowedClauses | simdAllowedClauses);
+    SetContextAllowedOnce(
+        distributeAllowedOnceClauses | simdAllowedOnceClauses);
+  } break;
+
+    // 2.10.10 distribute-parallel-do-clause -> distribute-clause |
+    //                                          parallel-do-clause
+  case parser::OmpLoopDirective::Directive::DistributeParallelDo: {
+    PushContext(beginDir.source, OmpDirective::DISTRIBUTE_PARALLEL_DO);
+    SetContextAllowed(
+        distributeAllowedClauses | parallelAllowedClauses | doAllowedClauses);
+    SetContextAllowedOnce(distributeAllowedOnceClauses |
+        parallelAllowedOnceClauses | doAllowedOnceClauses);
+  } break;
+
+    // 2.10.11 distribute-parallel-do-simd-clause -> distribute-clause |
+    //                                               parallel-do-simd-clause
+  case parser::OmpLoopDirective::Directive::DistributeParallelDoSimd: {
+    PushContext(beginDir.source, OmpDirective::DISTRIBUTE_PARALLEL_DO_SIMD);
+    SetContextAllowed(distributeAllowedClauses | parallelAllowedClauses |
+        doAllowedClauses | simdAllowedClauses);
+    SetContextAllowedOnce(distributeAllowedOnceClauses |
+        parallelAllowedOnceClauses | doAllowedOnceClauses | simdAllowedClauses);
+  } break;
+
+    // 2.11.6 target-parallel-do-clause -> target-clause |
+    //                                     parallel-do-clause
+  case parser::OmpLoopDirective::Directive::TargetParallelDo: {
+    PushContext(beginDir.source, OmpDirective::TARGET_PARALLEL_DO);
+    SetContextAllowed(
+        targetAllowedClauses | parallelAllowedClauses | doAllowedClauses);
+    SetContextAllowedOnce(
+        (targetAllowedOnceClauses | parallelAllowedOnceClauses |
+            doAllowedOnceClauses) -
+        OmpClause::NOWAIT);
+  } break;
+
+    // 2.11.7 target-parallel-do-simd-clause -> target-clause |
+    //                                          parallel-do-simd-clause
+  case parser::OmpLoopDirective::Directive::TargetParallelDoSimd: {
+    PushContext(beginDir.source, OmpDirective::TARGET_PARALLEL_DO_SIMD);
+    SetContextAllowed(targetAllowedClauses | parallelAllowedClauses |
+        doAllowedClauses | simdAllowedClauses);
+    SetContextAllowedOnce(
+        (targetAllowedOnceClauses | parallelAllowedOnceClauses |
+            doAllowedOnceClauses | simdAllowedOnceClauses) -
+        OmpClause::NOWAIT);
+  } break;
+
+    // 2.11.8 target-simd-clause -> target-clause |
+    //                              simd-clause
+  case parser::OmpLoopDirective::Directive::TargetSimd: {
+    PushContext(beginDir.source, OmpDirective::TARGET_SIMD);
+    SetContextAllowed(targetAllowedClauses | simdAllowedClauses);
+    SetContextAllowedOnce(targetAllowedOnceClauses | simdAllowedOnceClauses);
+  } break;
+
+    // 2.11.10 teams-distribute-clause -> teams-clause |
+    //                                    distribute-clause
+  case parser::OmpLoopDirective::Directive::TeamsDistribute: {
+    PushContext(beginDir.source, OmpDirective::TEAMS_DISTRIBUTE);
+    SetContextAllowed(teamsAllowedClauses | distributeAllowedClauses);
+    SetContextAllowedOnce(
+        teamsAllowedOnceClauses | distributeAllowedOnceClauses);
+  } break;
+
+    // 2.11.11 teams-distribute-simd-clause -> teams-clause |
+    //                                         distribute-simd-clause
+  case parser::OmpLoopDirective::Directive::TeamsDistributeSimd: {
+    PushContext(beginDir.source, OmpDirective::TEAMS_DISTRIBUTE_SIMD);
+    SetContextAllowed(
+        teamsAllowedClauses | distributeAllowedClauses | simdAllowedClauses);
+    SetContextAllowedOnce(teamsAllowedOnceClauses |
+        distributeAllowedOnceClauses | simdAllowedOnceClauses);
+  } break;
+
+    // 2.11.12 target-teams-distribute-clause -> target-clause |
+    //                                           teams-distribute-clause
+  case parser::OmpLoopDirective::Directive::TargetTeamsDistribute: {
+    PushContext(beginDir.source, OmpDirective::TARGET_TEAMS_DISTRIBUTE);
+    SetContextAllowed(
+        targetAllowedClauses | teamsAllowedClauses | distributeAllowedClauses);
+    SetContextAllowedOnce(targetAllowedOnceClauses | teamsAllowedOnceClauses |
+        distributeAllowedOnceClauses);
+  } break;
+
+    // 2.11.13 target-teams-distribute-simd-clause -> target-clause |
+    //                                                teams-distribute-simd-clause
+  case parser::OmpLoopDirective::Directive::TargetTeamsDistributeSimd: {
+    PushContext(beginDir.source, OmpDirective::TARGET_TEAMS_DISTRIBUTE_SIMD);
+    SetContextAllowed(targetAllowedClauses | teamsAllowedClauses |
+        distributeAllowedClauses | simdAllowedClauses);
+    SetContextAllowed(targetAllowedOnceClauses | teamsAllowedOnceClauses |
+        distributeAllowedOnceClauses | simdAllowedOnceClauses);
+  } break;
+
+    // 2.11.14 teams-distribute-parallel-do-clause -> teams-clause |
+    //                                                distribute-parallel-do-clause
+  case parser::OmpLoopDirective::Directive::TeamsDistributeParallelDo: {
+    PushContext(beginDir.source, OmpDirective::TEAMS_DISTRIBUTE_PARALLEL_DO);
+    SetContextAllowed(teamsAllowedClauses | distributeAllowedClauses |
+        parallelAllowedClauses | doAllowedClauses);
+    SetContextAllowedOnce(teamsAllowedOnceClauses |
+        distributeAllowedOnceClauses | parallelAllowedOnceClauses |
+        doAllowedOnceClauses);
+  } break;
+
+    // 2.11.15 target-teams-distribute-parallel-do-clause -> target-clause |
+    //                                                       teams-distribute-parallel-do-clause
+  case parser::OmpLoopDirective::Directive::TargetTeamsDistributeParallelDo: {
+    PushContext(
+        beginDir.source, OmpDirective::TARGET_TEAMS_DISTRIBUTE_PARALLEL_DO);
+    SetContextAllowed(targetAllowedClauses | teamsAllowedClauses |
+        distributeAllowedClauses | parallelAllowedClauses | doAllowedClauses);
+    SetContextAllowedOnce(targetAllowedOnceClauses | teamsAllowedOnceClauses |
+        distributeAllowedOnceClauses | parallelAllowedOnceClauses |
+        doAllowedOnceClauses);
+  } break;
+
+    // 2.11.16 teams-distribute-parallel-do-clause -> teams-clause |
+    //                                                distribute-parallel-do-simd-clause
+  case parser::OmpLoopDirective::Directive::TeamsDistributeParallelDoSimd: {
+    PushContext(
+        beginDir.source, OmpDirective::TEAMS_DISTRIBUTE_PARALLEL_DO_SIMD);
+    SetContextAllowed(teamsAllowedClauses | distributeAllowedClauses |
+        parallelAllowedClauses | doAllowedClauses | simdAllowedClauses);
+    SetContextAllowedOnce(teamsAllowedOnceClauses |
+        distributeAllowedOnceClauses | parallelAllowedOnceClauses |
+        doAllowedOnceClauses | simdAllowedOnceClauses);
+  } break;
+
+  case parser::OmpLoopDirective::Directive::
+      TargetTeamsDistributeParallelDoSimd: {
+    PushContext(beginDir.source,
+        OmpDirective::TARGET_TEAMS_DISTRIBUTE_PARALLEL_DO_SIMD);
+    SetContextAllowed(targetAllowedClauses | teamsAllowedClauses |
+        distributeAllowedClauses | parallelAllowedClauses | doAllowedClauses |
+        simdAllowedClauses);
+    SetContextAllowedOnce(targetAllowedOnceClauses | teamsAllowedOnceClauses |
+        distributeAllowedOnceClauses | parallelAllowedOnceClauses |
+        doAllowedOnceClauses | simdAllowedOnceClauses);
+  }
+
   }
 }
 
 void OmpStructureChecker::Leave(const parser::OpenMPLoopConstruct &) {
   ompContext_.pop_back();
 }
 
 void OmpStructureChecker::Enter(const parser::OmpEndLoopDirective &x) {
void OmpStructureChecker::Enter(const parser::OpenMPBlockConstruct &x) {
   //                        firstprivate-clause |
   //                        shared-clause |
   //                        copyin-clause |
   //                        reduction-clause |
   //                        proc-bind-clause
   case parser::OmpBlockDirective::Directive::Parallel: {
     // reserve for nesting check
     PushContext(beginDir.source, OmpDirective::PARALLEL);
-    OmpClauseSet allowed{OmpClause::DEFAULT, OmpClause::PRIVATE,
-        OmpClause::FIRSTPRIVATE, OmpClause::SHARED, OmpClause::COPYIN,
-        OmpClause::REDUCTION};
-    SetContextAllowed(allowed);
-    OmpClauseSet allowedOnce{
-        OmpClause::IF, OmpClause::NUM_THREADS, OmpClause::PROC_BIND};
-    SetContextAllowedOnce(allowedOnce);
+    SetContextAllowed(parallelAllowedClauses);
+    SetContextAllowedOnce(parallelAllowedOnceClauses);
   } break;
   // 2.7.3 single-clause -> private-clause |
   //                        firstprivate-clause
   case parser::OmpBlockDirective::Directive::Single:
     PushContext(beginDir.source, OmpDirective::SINGLE);
     SetContextAllowed({OmpClause::PRIVATE, OmpClause::FIRSTPRIVATE});
     break;
   // 2.7.4 workshare (no clauses are allowed)
   case parser::OmpBlockDirective::Directive::Workshare:
     PushContext(beginDir.source, OmpDirective::WORKSHARE);
     break;
+  // 2.11.3 parallel-workshare-clause -> parallel-clause
+  case parser::OmpBlockDirective::Directive::ParallelWorkshare: {
+    PushContext(beginDir.source, OmpDirective::PARALLEL_WORKSHARE);
+    SetContextAllowed(parallelAllowedClauses);
+    SetContextAllowedOnce(parallelAllowedOnceClauses);
+  } break;
     // 2.9.1 task-clause -> if-clause |
     //                      final-clause |
     //                      untied-clause |
     //                      default-clause |
     //                      mergeable-clause |
     //                      private-clause |
     //                      firstprivate-clause |
     //                      shared-clause |
void OmpStructureChecker::Enter(const parser::OpenMPBlockConstruct &x) {
   //                         firstprivate-clause |
   //                         map-clause |
   //                         is-device-ptr-clause |
   //                         defaultmap-clause |
   //                         nowait-clause |
   //                         depend-clause
   case parser::OmpBlockDirective::Directive::Target: {
     PushContext(beginDir.source, OmpDirective::TARGET);
-    OmpClauseSet allowed{OmpClause::IF, OmpClause::PRIVATE,
-        OmpClause::FIRSTPRIVATE, OmpClause::MAP, OmpClause::IS_DEVICE_PTR,
-        OmpClause::DEPEND};
-    SetContextAllowed(allowed);
-    OmpClauseSet allowedOnce{
-        OmpClause::DEVICE, OmpClause::DEFAULTMAP, OmpClause::NOWAIT};
-    SetContextAllowedOnce(allowedOnce);
+    SetContextAllowed(targetAllowedClauses);
+    SetContextAllowedOnce(targetAllowedOnceClauses);
   } break;
   // 2.10.7 teams-clause -> num-teams-clause |
   //                        thread-limit-clause |
   //                        default-clause |
   //                        private-clause |
   //                        firstprivate-clause |
   //                        shared-clause |
   //                        reduction-clause
   case parser::OmpBlockDirective::Directive::Teams: {
     PushContext(beginDir.source, OmpDirective::TEAMS);
-    OmpClauseSet allowed{OmpClause::PRIVATE, OmpClause::FIRSTPRIVATE,
-        OmpClause::SHARED, OmpClause::REDUCTION};
-    SetContextAllowed(allowed);
-    OmpClauseSet allowedOnce{
-        OmpClause::NUM_TEAMS, OmpClause::THREAD_LIMIT, OmpClause::DEFAULT};
-    SetContextAllowedOnce(allowedOnce);
+    SetContextAllowed(teamsAllowedClauses);
+    SetContextAllowedOnce(teamsAllowedOnceClauses);
+  } break;
+    // 2.11.9 target-teams -> target-clause |
+    //                        teams-clause
+  case parser::OmpBlockDirective::Directive::TargetTeams: {
+    PushContext(beginDir.source, OmpDirective::TARGET_TEAMS);
+    SetContextAllowed(targetAllowedClauses | teamsAllowedClauses);
+    SetContextAllowedOnce(targetAllowedOnceClauses | teamsAllowedOnceClauses);
   } break;
     // 2.10.1 target-data-clause -> if-clause |
     //                              device-clause |
     //                              map-clause |
     //                              use-device-ptr-clause
   case parser::OmpBlockDirective::Directive::TargetData: {
     PushContext(beginDir.source, OmpDirective::TARGET_DATA);
     OmpClauseSet allowed{
         OmpClause::IF, OmpClause::MAP, OmpClause::USE_DEVICE_PTR};
     SetContextAllowed(allowed);
     SetContextAllowedOnce({OmpClause::DEVICE});
     SetContextRequired({OmpClause::MAP});
   } break;
     // 2.13.1 master (no clauses are allowed)
   case parser::OmpBlockDirective::Directive::Master:
     PushContext(beginDir.source, OmpDirective::MASTER);
     break;
+    // 2.11.5 target-parallel-clause -> target-clause |
+    //                                  parallel-clause
+  case parser::OmpBlockDirective::Directive::TargetParallel: {
+    PushContext(beginDir.source, OmpDirective::TARGET_PARALLEL);
+    SetContextAllowed(
+        (targetAllowedClauses | parallelAllowedClauses) - OmpClause::COPYIN);
+    SetContextAllowedOnce(
+        targetAllowedOnceClauses | parallelAllowedOnceClauses);
+  } break;
   default:
     // TODO others
     break;
   }
 }
 
 void OmpStructureChecker::Leave(const parser::OpenMPBlockConstruct &) {
   ompContext_.pop_back();
 }
 
 void OmpStructureChecker::Enter(const parser::OpenMPSectionsConstruct &x) {
   const auto &beginSectionsDir{
       std::get<parser::OmpBeginSectionsDirective>(x.t)};
   const auto &endSectionsDir{std::get<parser::OmpEndSectionsDirective>(x.t)};
   const auto &beginDir{CheckMatching<parser::OmpSectionsDirective>(
       beginSectionsDir, endSectionsDir)};
 
   switch (beginDir.v) {
   // 2.7.2 sections-clause -> private-clause |
   //                          firstprivate-clause |
   //                          lastprivate-clause |
   //                          reduction-clause
   case parser::OmpSectionsDirective::Directive::Sections: {
     PushContext(beginDir.source, OmpDirective::SECTIONS);
-    OmpClauseSet allowed{OmpClause::PRIVATE, OmpClause::FIRSTPRIVATE,
-        OmpClause::LASTPRIVATE, OmpClause::REDUCTION};
-    SetContextAllowed(allowed);
+    SetContextAllowed(sectionsAllowedClauses);
   } break;
+    // 2.11.2 -> parallel-sections-clause -> parallel-clause |
+    //                                       sections-clause
   case parser::OmpSectionsDirective::Directive::ParallelSections: {
     PushContext(beginDir.source, OmpDirective::PARALLEL_SECTIONS);
-    OmpClauseSet allowed{OmpClause::DEFAULT, OmpClause::PRIVATE,
-        OmpClause::FIRSTPRIVATE, OmpClause::LASTPRIVATE, OmpClause::SHARED,
-        OmpClause::COPYIN, OmpClause::REDUCTION};
-    SetContextAllowed(allowed);
-    OmpClauseSet allowedOnce{
-        OmpClause::IF, OmpClause::NUM_THREADS, OmpClause::PROC_BIND};
-    SetContextAllowedOnce(allowedOnce);
+    SetContextAllowed(parallelAllowedClauses | sectionsAllowedClauses);
+    SetContextAllowedOnce(parallelAllowedOnceClauses);
   } break;
   }
 }
 
 void OmpStructureChecker::Leave(const parser::OpenMPSectionsConstruct &) {
   ompContext_.pop_back();
 }
 

 }
 void OmpStructureChecker::Enter(const parser::OmpMapClause &x) {
   CheckAllowed(OmpClause::MAP);
   if (const auto &maptype{std::get<std::optional<parser::OmpMapType>>(x.t)}) {
     using Type = parser::OmpMapType::Type;
     const Type &type{std::get<Type>(maptype->t)};
     switch (GetContext().directive) {
     case OmpDirective::TARGET:
+    case OmpDirective::TARGET_TEAMS:
+    case OmpDirective::TARGET_TEAMS_DISTRIBUTE:
+    case OmpDirective::TARGET_TEAMS_DISTRIBUTE_SIMD:
+    case OmpDirective::TARGET_TEAMS_DISTRIBUTE_PARALLEL_DO:
+    case OmpDirective::TARGET_TEAMS_DISTRIBUTE_PARALLEL_DO_SIMD:
     case OmpDirective::TARGET_DATA: {
       if (type != Type::To && type != Type::From && type != Type::Tofrom &&
           type != Type::Alloc) {
         context_.Say(GetContext().clauseSource,
             "Only the TO, FROM, TOFROM, or ALLOC map types are permitted "
             "for MAP clauses on the %s directive"_err_en_US,
             ContextDirectiveAsFortran());
       }

flang/lib/Semantics/resolve-names.cpp

case parser::OmpBlockDirective::Directive::Task:
     PushContext(beginDir.source, OmpDirective::TASK);
     break;
   case parser::OmpBlockDirective::Directive::Teams:
     PushContext(beginDir.source, OmpDirective::TEAMS);
     break;
   case parser::OmpBlockDirective::Directive::Workshare:
     PushContext(beginDir.source, OmpDirective::WORKSHARE);
     break;
+  case parser::OmpBlockDirective::Directive::ParallelWorkshare:
+    PushContext(beginDir.source, OmpDirective::PARALLEL_WORKSHARE);
+    break;
+  case parser::OmpBlockDirective::Directive::TargetTeams:
+    PushContext(beginDir.source, OmpDirective::TARGET_TEAMS);
+    break;
+  case parser::OmpBlockDirective::Directive::TargetParallel:
+    PushContext(beginDir.source, OmpDirective::TARGET_PARALLEL);
+    break;
   default:
     // TODO others
     break;
   }
   ClearDataSharingAttributeObjects();
   return true;
 }
 

flang/test/Semantics/omp-combined-constructs.f90

+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
+! OPTIONS: -fopenmp
+
+program main
+  implicit none
+  integer :: N
+  integer :: i
+  real(8) :: a(256), b(256)
+  N = 256
+
+  !$omp distribute simd
+  do i = 1, N
+     a(i) = 3.14
+  enddo
+  !$omp end distribute simd
+
+  !$omp target parallel device(0)
+  do i = 1, N
+     a(i) = 3.14
+  enddo
+  !$omp end target parallel
+
+  !ERROR: At most one DEVICE clause can appear on the TARGET PARALLEL directive
+  !$omp target parallel device(0) device(1)
+  do i = 1, N
+     a(i) = 3.14
+  enddo
+  !$omp end target parallel
+
+  !$omp target parallel defaultmap(tofrom:scalar)
+  do i = 1, N
+     a(i) = 3.14
+  enddo
+  !$omp end target parallel
+
+  !ERROR: The argument TOFROM:SCALAR must be specified on the DEFAULTMAP clause
+  !$omp target parallel defaultmap(tofrom)
+  do i = 1, N
+     a(i) = 3.14
+  enddo
+  !$omp end target parallel
+
+  !ERROR: At most one DEFAULTMAP clause can appear on the TARGET PARALLEL directive
+  !$omp target parallel defaultmap(tofrom:scalar) defaultmap(tofrom:scalar)
+  do i = 1, N
+     a(i) = 3.14
+  enddo
+  !$omp end target parallel
+
+  !$omp target parallel map(tofrom:a)
+  do i = 1, N
+     a(i) = 3.14
+  enddo
+  !$omp end target parallel
+
+  !ERROR: COPYIN clause is not allowed on the TARGET PARALLEL directive
+  !$omp target parallel copyin(a)
+  do i = 1, N
+     a(i) = 3.14
+  enddo
+  !$omp end target parallel
+
+  !$omp target parallel do device(0)
+  do i = 1, N
+     a(i) = 3.14
+  enddo
+  !$omp end target parallel do
+
+  !ERROR: At most one DEVICE clause can appear on the TARGET PARALLEL DO directive
+  !$omp target parallel do device(0) device(1)
+  do i = 1, N
+     a(i) = 3.14
+  enddo
+  !$omp end target parallel do
+
+  !$omp target parallel do defaultmap(tofrom:scalar)
+  do i = 1, N
+     a(i) = 3.14
+  enddo
+  !$omp end target parallel do
+
+  !ERROR: The argument TOFROM:SCALAR must be specified on the DEFAULTMAP clause
+  !$omp target parallel do defaultmap(tofrom)
+  do i = 1, N
+     a(i) = 3.14
+  enddo
+  !$omp end target parallel do
+
+  !ERROR: At most one DEFAULTMAP clause can appear on the TARGET PARALLEL DO directive
+  !$omp target parallel do defaultmap(tofrom:scalar) defaultmap(tofrom:scalar)
+  do i = 1, N
+     a(i) = 3.14
+  enddo
+  !$omp end target parallel do
+
+  !$omp target parallel do map(tofrom:a)
+  do i = 1, N
+     a(i) = 3.14
+  enddo
+  !$omp end target parallel do
+
+  !$omp target parallel do copyin(a)
+  do i = 1, N
+     a(i) = 3.14
+  enddo
+  !$omp end target parallel do
+
+  !$omp target teams map(a)
+  do i = 1, N
+     a(i) = 3.14
+  enddo
+  !$omp end target teams
+
+  !$omp target teams device(0)
+  do i = 1, N
+     a(i) = 3.14
+  enddo
+  !$omp end target teams
+
+  !ERROR: At most one DEVICE clause can appear on the TARGET TEAMS directive
+  !$omp target teams device(0) device(1)
+  do i = 1, N
+     a(i) = 3.14
+  enddo
+  !$omp end target teams
+
+  !ERROR: SCHEDULE clause is not allowed on the TARGET TEAMS directive
+  !$omp target teams schedule(static)
+  do i = 1, N
+     a(i) = 3.14
+  enddo
+  !$omp end target teams
+
+  !$omp target teams defaultmap(tofrom:scalar)
+  do i = 1, N
+     a(i) = 3.14
+  enddo
+  !$omp end target teams
+
+  !ERROR: The argument TOFROM:SCALAR must be specified on the DEFAULTMAP clause
+  !$omp target teams defaultmap(tofrom)
+  do i = 1, N
+     a(i) = 3.14
+  enddo
+  !$omp end target teams
+
+  !ERROR: At most one DEFAULTMAP clause can appear on the TARGET TEAMS directive
+  !$omp target teams defaultmap(tofrom:scalar) defaultmap(tofrom:scalar)
+  do i = 1, N
+     a(i) = 3.14
+  enddo
+  !$omp end target teams
+
+  !$omp target teams num_teams(3) thread_limit(10) default(shared) private(i) shared(a)
+  do i = 1, N
+     a(i) = 3.14
+  enddo
+  !$omp end target teams
+
+  !ERROR: At most one NUM_TEAMS clause can appear on the TARGET TEAMS directive
+  !$omp target teams num_teams(2) num_teams(3)
+  do i = 1, N
+     a(i) = 3.14
+  enddo
+  !$omp end target teams
+
+  !ERROR: The parameter of the NUM_TEAMS clause must be a positive integer expression
+  !$omp target teams num_teams(-1)
+  do i = 1, N
+     a(i) = 3.14
+  enddo
+  !$omp end target teams
+
+  !ERROR: At most one THREAD_LIMIT clause can appear on the TARGET TEAMS directive
+  !$omp target teams thread_limit(2) thread_limit(3)
+  do i = 1, N
+     a(i) = 3.14
+  enddo
+  !$omp end target teams
+
+  !ERROR: The parameter of the THREAD_LIMIT clause must be a positive integer expression
+  !$omp target teams thread_limit(-1)
+  do i = 1, N
+     a(i) = 3.14
+  enddo
+  !$omp end target teams
+
+  !ERROR: At most one DEFAULT clause can appear on the TARGET TEAMS directive
+  !$omp target teams default(shared) default(private)
+  do i = 1, N
+     a(i) = 3.14
+  enddo
+  !$omp end target teams
+
+  !$omp target teams num_teams(2) defaultmap(tofrom:scalar)
+  do i = 1, N
+      a(i) = 3.14
+  enddo
+  !$omp end target teams
+
+  !$omp target teams map(tofrom:a)
+  do i = 1, N
+     a(i) = 3.14
+  enddo
+  !$omp end target teams
+
+  !ERROR: Only the TO, FROM, TOFROM, or ALLOC map types are permitted for MAP clauses on the TARGET TEAMS directive
+  !$omp target teams map(delete:a)
+  do i = 1, N
+     a(i) = 3.14
+  enddo
+  !$omp end target teams
+
+
+  !$omp target teams distribute map(a)
+  do i = 1, N
+     a(i) = 3.14
+  enddo
+  !$omp end target teams distribute
+
+  !$omp target teams distribute device(0)
+  do i = 1, N
+     a(i) = 3.14
+  enddo
+  !$omp end target teams distribute
+
+  !ERROR: At most one DEVICE clause can appear on the TARGET TEAMS DISTRIBUTE directive
+  !$omp target teams distribute device(0) device(1)
+  do i = 1, N
+     a(i) = 3.14
+  enddo
+  !$omp end target teams distribute
+
+  !$omp target teams distribute defaultmap(tofrom:scalar)
+  do i = 1, N
+     a(i) = 3.14
+  enddo
+  !$omp end target teams distribute
+
+  !ERROR: The argument TOFROM:SCALAR must be specified on the DEFAULTMAP clause
+  !$omp target teams distribute defaultmap(tofrom)
+  do i = 1, N
+     a(i) = 3.14
+  enddo
+  !$omp end target teams distribute
+
+  !ERROR: At most one DEFAULTMAP clause can appear on the TARGET TEAMS DISTRIBUTE directive
+  !$omp target teams distribute defaultmap(tofrom:scalar) defaultmap(tofrom:scalar)
+  do i = 1, N
+     a(i) = 3.14
+  enddo
+  !$omp end target teams distribute
+
+  !$omp target teams distribute num_teams(3) thread_limit(10) default(shared) private(i) shared(a)
+  do i = 1, N
+     a(i) = 3.14
+  enddo
+  !$omp end target teams distribute
+
+  !ERROR: At most one NUM_TEAMS clause can appear on the TARGET TEAMS DISTRIBUTE directive
+  !$omp target teams distribute num_teams(2) num_teams(3)
+  do i = 1, N
+     a(i) = 3.14
+  enddo
+  !$omp end target teams distribute
+
+  !ERROR: The parameter of the NUM_TEAMS clause must be a positive integer expression
+  !$omp target teams distribute num_teams(-1)
+  do i = 1, N
+     a(i) = 3.14
+  enddo
+  !$omp end target teams distribute
+
+  !ERROR: At most one THREAD_LIMIT clause can appear on the TARGET TEAMS DISTRIBUTE directive
+  !$omp target teams distribute thread_limit(2) thread_limit(3)
+  do i = 1, N
+     a(i) = 3.14
+  enddo
+  !$omp end target teams distribute
+
+  !ERROR: The parameter of the THREAD_LIMIT clause must be a positive integer expression
+  !$omp target teams distribute thread_limit(-1)
+  do i = 1, N
+     a(i) = 3.14
+  enddo
+  !$omp end target teams distribute
+
+  !ERROR: At most one DEFAULT clause can appear on the TARGET TEAMS DISTRIBUTE directive
+  !$omp target teams distribute default(shared) default(private)
+  do i = 1, N
+     a(i) = 3.14
+  enddo
+  !$omp end target teams distribute
+
+  !$omp target teams distribute num_teams(2) defaultmap(tofrom:scalar)
+  do i = 1, N
+      a(i) = 3.14
+  enddo
+  !$omp end target teams distribute
+
+  !$omp target teams distribute map(tofrom:a)
+  do i = 1, N
+     a(i) = 3.14
+  enddo
+  !$omp end target teams distribute
+
+  !ERROR: Only the TO, FROM, TOFROM, or ALLOC map types are permitted for MAP clauses on the TARGET TEAMS DISTRIBUTE directive
+  !$omp target teams distribute map(delete:a)
+  do i = 1, N
+     a(i) = 3.14
+  enddo
+  !$omp end target teams distribute
+
+  !$omp target teams distribute parallel do device(0)
+  do i = 1, N
+     a(i) = 3.14
+  enddo
+  !$omp end target teams distribute parallel do
+
+  !ERROR: At most one DEVICE clause can appear on the TARGET TEAMS DISTRIBUTE PARALLEL DO directive
+  !$omp target teams distribute parallel do device(0) device(1)
+  do i = 1, N
+     a(i) = 3.14
+  enddo
+  !$omp end target teams distribute parallel do
+
+  !$omp target teams distribute parallel do defaultmap(tofrom:scalar)
+  do i = 1, N
+     a(i) = 3.14
+  enddo
+  !$omp end target teams distribute parallel do
+
+  !ERROR: The argument TOFROM:SCALAR must be specified on the DEFAULTMAP clause
+  !$omp target teams distribute parallel do defaultmap(tofrom)
+  do i = 1, N
+     a(i) = 3.14
+  enddo
+  !$omp end target teams distribute parallel do
+
+  !ERROR: At most one DEFAULTMAP clause can appear on the TARGET TEAMS DISTRIBUTE PARALLEL DO directive
+  !$omp target teams distribute parallel do defaultmap(tofrom:scalar) defaultmap(tofrom:scalar)
+  do i = 1, N
+     a(i) = 3.14
+  enddo
+  !$omp end target teams distribute parallel do
+
+  !$omp target teams distribute parallel do num_teams(3) thread_limit(10) default(shared) private(i) shared(a)
+  do i = 1, N
+     a(i) = 3.14
+  enddo
+  !$omp end target teams distribute parallel do
+
+  !ERROR: At most one NUM_TEAMS clause can appear on the TARGET TEAMS DISTRIBUTE PARALLEL DO directive
+  !$omp target teams distribute parallel do num_teams(2) num_teams(3)
+  do i = 1, N
+     a(i) = 3.14
+  enddo
+  !$omp end target teams distribute parallel do
+
+  !ERROR: The parameter of the NUM_TEAMS clause must be a positive integer expression
+  !$omp target teams distribute parallel do num_teams(-1)
+  do i = 1, N
+     a(i) = 3.14
+  enddo
+  !$omp end target teams distribute parallel do
+
+  !ERROR: At most one THREAD_LIMIT clause can appear on the TARGET TEAMS DISTRIBUTE PARALLEL DO directive
+  !$omp target teams distribute parallel do thread_limit(2) thread_limit(3)
+  do i = 1, N
+     a(i) = 3.14
+  enddo
+  !$omp end target teams distribute parallel do
+
+  !ERROR: The parameter of the THREAD_LIMIT clause must be a positive integer expression
+  !$omp target teams distribute parallel do thread_limit(-1)
+  do i = 1, N
+     a(i) = 3.14
+  enddo
+  !$omp end target teams distribute parallel do
+
+  !ERROR: At most one DEFAULT clause can appear on the TARGET TEAMS DISTRIBUTE PARALLEL DO directive
+  !$omp target teams distribute parallel do default(shared) default(private)
+  do i = 1, N
+     a(i) = 3.14
+  enddo
+  !$omp end target teams distribute parallel do
+
+  !$omp target teams distribute parallel do num_teams(2) defaultmap(tofrom:scalar)
+  do i = 1, N
+      a(i) = 3.14
+  enddo
+  !$omp end target teams distribute parallel do
+
+  !$omp target teams distribute parallel do map(tofrom:a)
+  do i = 1, N
+     a(i) = 3.14
+  enddo
+  !$omp end target teams distribute parallel do
+
+  !ERROR: Only the TO, FROM, TOFROM, or ALLOC map types are permitted for MAP clauses on the TARGET TEAMS DISTRIBUTE PARALLEL DO directive
+  !$omp target teams distribute parallel do map(delete:a)
+  do i = 1, N
+     a(i) = 3.14
+  enddo
+  !$omp end target teams distribute parallel do
+
+
+  !$omp target teams distribute parallel do simd map(a)
+  do i = 1, N
+     a(i) = 3.14
+  enddo
+  !$omp end target teams distribute parallel do simd
+
+  !$omp target teams distribute parallel do simd device(0)
+  do i = 1, N
+     a(i) = 3.14
+  enddo
+  !$omp end target teams distribute parallel do simd
+
+  !ERROR: At most one DEVICE clause can appear on the TARGET TEAMS DISTRIBUTE PARALLEL DO SIMD directive
+  !$omp target teams distribute parallel do simd device(0) device(1)
+  do i = 1, N
+     a(i) = 3.14
+  enddo
+  !$omp end target teams distribute parallel do simd
+
+  !$omp target teams distribute parallel do simd defaultmap(tofrom:scalar)
+  do i = 1, N
+     a(i) = 3.14
+  enddo
+  !$omp end target teams distribute parallel do simd
+
+  !ERROR: The argument TOFROM:SCALAR must be specified on the DEFAULTMAP clause
+  !$omp target teams distribute parallel do simd defaultmap(tofrom)
+  do i = 1, N
+     a(i) = 3.14
+  enddo
+  !$omp end target teams distribute parallel do simd
+
+  !ERROR: At most one DEFAULTMAP clause can appear on the TARGET TEAMS DISTRIBUTE PARALLEL DO SIMD directive
+  !$omp target teams distribute parallel do simd defaultmap(tofrom:scalar) defaultmap(tofrom:scalar)
+  do i = 1, N
+     a(i) = 3.14
+  enddo
+  !$omp end target teams distribute parallel do simd
+
+  !$omp target teams distribute parallel do simd num_teams(3) thread_limit(10) default(shared) private(i) shared(a)
+  do i = 1, N
+     a(i) = 3.14
+  enddo
+  !$omp end target teams distribute parallel do simd
+
+  !ERROR: At most one NUM_TEAMS clause can appear on the TARGET TEAMS DISTRIBUTE PARALLEL DO SIMD directive
+  !$omp target teams distribute parallel do simd num_teams(2) num_teams(3)
+  do i = 1, N
+     a(i) = 3.14
+  enddo
+  !$omp end target teams distribute parallel do simd
+
+  !ERROR: The parameter of the NUM_TEAMS clause must be a positive integer expression
+  !$omp target teams distribute parallel do simd num_teams(-1)
+  do i = 1, N
+     a(i) = 3.14
+  enddo
+  !$omp end target teams distribute parallel do simd
+
+  !ERROR: At most one THREAD_LIMIT clause can appear on the TARGET TEAMS DISTRIBUTE PARALLEL DO SIMD directive
+  !$omp target teams distribute parallel do simd thread_limit(2) thread_limit(3)
+  do i = 1, N
+     a(i) = 3.14
+  enddo
+  !$omp end target teams distribute parallel do simd
+
+  !ERROR: The parameter of the THREAD_LIMIT clause must be a positive integer expression
+  !$omp target teams distribute parallel do simd thread_limit(-1)
+  do i = 1, N
+     a(i) = 3.14
+  enddo
+  !$omp end target teams distribute parallel do simd
+
+  !ERROR: At most one DEFAULT clause can appear on the TARGET TEAMS DISTRIBUTE PARALLEL DO SIMD directive
+  !$omp target teams distribute parallel do simd default(shared) default(private)
+  do i = 1, N
+     a(i) = 3.14
+  enddo
+  !$omp end target teams distribute parallel do simd
+
+  !$omp target teams distribute parallel do simd num_teams(2) defaultmap(tofrom:scalar)
+  do i = 1, N
+      a(i) = 3.14
+  enddo
+  !$omp end target teams distribute parallel do simd
+
+  !$omp target teams distribute parallel do simd map(tofrom:a)
+  do i = 1, N
+     a(i) = 3.14
+  enddo
+  !$omp end target teams distribute parallel do simd
+
+  !ERROR: Only the TO, FROM, TOFROM, or ALLOC map types are permitted for MAP clauses on the TARGET TEAMS DISTRIBUTE PARALLEL DO SIMD directive
+  !$omp target teams distribute parallel do simd map(delete:a)
+  do i = 1, N
+     a(i) = 3.14
+  enddo
+  !$omp end target teams distribute parallel do simd
+
+
+end program main
+

flang/test/Semantics/omp-device-constructs.f90

program main
 
   !ERROR: At most one DEFAULT clause can appear on the TEAMS directive
   !$omp teams default(shared) default(private)
   do i = 1, N
      a = 3.14
   enddo
   !$omp end teams
 
+  !$omp target teams num_teams(2) defaultmap(tofrom:scalar)
+  do i = 1, N
+      a = 3.14
+  enddo
+  !$omp end target teams
+
   !$omp target map(tofrom:a)
   do i = 1, N
      a = 3.14
   enddo
   !$omp end target
 
   !ERROR: Only the TO, FROM, TOFROM, or ALLOC map types are permitted for MAP clauses on the TARGET directive
   !$omp target map(delete:a)