[Flang][OpenMP] Improve support for `if` clause on combined constructs

[skatrak]

Summary

This patch adds support for matching multiple OpenMP if clauses to their specified directive in a combined construct. It also enables this clause to be attached by name to simd and teams directives, in addition to the others that were already supported.

This patch on its own cannot yet be tested because there is currently no lowering to MLIR support for any combined construct containing two or more OpenMP directives that can have an if clause attached.

Depends on D155981.

[kiranchandramohan]

Please add tests for the parser/semantics changes.

[skatrak]

Add parser/semantics unit test for all supported combined constructs. Fix some parser/semantics issues uncovered by testing.

[skatrak]

Rebase.

[kiranchandramohan]

Please add debug-dump-unparse or a debug-dump-parse-tree tests for the modifications in the parse-tree or the parser before you submit.

flang/lib/Lower/OpenMP.cpp

2483

Nit: While you are here, could you check whether it is possible to print the name of the directive?

[skatrak]

Add parser unit tests.

[skatrak]

flang/lib/Lower/OpenMP.cpp

2483

I looked into it and the only place where I saw that the llvm::omp::Directive enum is translated to a text representation is Unparse(). I suppose it would be possible to expose another specialization of that template function in unparse.h to allow printing that here, but it doesn't seem like a very good idea. Also creating a big switch with all options here doesn't seem right either.

I was looking into TableGen's DirectiveEmitter, and it looks like it would be possible to generate some sort of {stringify,symbolize}<Enum Name>() for the Directive and Clause enums, like it's done for MLIR EnumAttrs. That would make the string representation easily available. Let me know if this is a feasible solution, and I'll try to create a separate patch for it.

[skatrak]

Print name of unhandled block directives.

[skatrak]

Thank you Kiran for looking into this, I think it's ready to land now.

flang/lib/Lower/OpenMP.cpp

2483

Sorry, nevermind. I missed the fact that such a function was already being generated there. This comment is addressed now.

[kiranchandramohan]

LG.

flang/include/flang/Parser/parse-tree.h

 struct OmpDeviceTypeClause {
   ENUM_CLASS(Type, Any, Host, Nohost)
   WRAPPER_CLASS_BOILERPLATE(OmpDeviceTypeClause, Type);
 };
 
 // 2.12 if-clause -> IF ([ directive-name-modifier :] scalar-logical-expr)
 struct OmpIfClause {
   TUPLE_CLASS_BOILERPLATE(OmpIfClause);
-  ENUM_CLASS(DirectiveNameModifier, Parallel, Target, TargetEnterData,
-      TargetExitData, TargetData, TargetUpdate, Taskloop, Task)
+  ENUM_CLASS(DirectiveNameModifier, Parallel, Simd, Target, TargetData,
+      TargetEnterData, TargetExitData, TargetUpdate, Task, Taskloop, Teams)
   std::tuple<std::optional<DirectiveNameModifier>, ScalarLogicalExpr> t;
 };
 
 // 2.8.1 aligned-clause -> ALIGNED (variable-name-list[ : scalar-constant])
 struct OmpAlignedClause {
   TUPLE_CLASS_BOILERPLATE(OmpAlignedClause);
   CharBlock source;
   std::tuple<OmpObjectList, std::optional<ScalarIntConstantExpr>> t;

flang/lib/Lower/OpenMP.cpp

public:
 
   // 'Repeatable' clauses: They can appear multiple times in the clause list.
   bool
   processAllocate(llvm::SmallVectorImpl<mlir::Value> &allocatorOperands,
                   llvm::SmallVectorImpl<mlir::Value> &allocateOperands) const;
   bool processCopyin() const;
   bool processDepend(llvm::SmallVectorImpl<mlir::Attribute> &dependTypeOperands,
                      llvm::SmallVectorImpl<mlir::Value> &dependOperands) const;
-  bool processIf(Fortran::lower::StatementContext &stmtCtx,
-                 mlir::Value &result) const;
+  bool
+  processIf(Fortran::lower::StatementContext &stmtCtx,
+            Fortran::parser::OmpIfClause::DirectiveNameModifier directiveName,
   bool
   processLink(llvm::SmallVectorImpl<DeclareTargetCapturePair> &result) const;
   bool processMap(llvm::SmallVectorImpl<mlir::Value> &mapOperands,
                   llvm::SmallVectorImpl<mlir::IntegerAttr> &mapTypes) const;
   bool processReduction(
       mlir::Location currentLocation,
       llvm::SmallVectorImpl<mlir::Value> &reductionVars,
       llvm::SmallVectorImpl<mlir::Attribute> &reductionDeclSymbols) const;
genDependKindAttr(fir::FirOpBuilder &firOpBuilder,
   default:
     llvm_unreachable("unknown parser task dependence type");
     break;
   }
   return mlir::omp::ClauseTaskDependAttr::get(firOpBuilder.getContext(),
                                               pbKind);
 }
 
-static mlir::Value
-getIfClauseOperand(Fortran::lower::AbstractConverter &converter,
-                   Fortran::lower::StatementContext &stmtCtx,
-                   const Fortran::parser::OmpClause::If *ifClause,
-                   mlir::Location clauseLocation) {
+static mlir::Value getIfClauseOperand(
+    Fortran::lower::AbstractConverter &converter,
+    Fortran::parser::OmpIfClause::DirectiveNameModifier directiveName,
+  // Only consider the clause if it's intended for the given directive.
+  auto &directive = std::get<
+      std::optional<Fortran::parser::OmpIfClause::DirectiveNameModifier>>(
+      ifClause->v.t);
+  if (directive && directive.value() != directiveName)
+    return nullptr;
+
   fir::FirOpBuilder &firOpBuilder = converter.getFirOpBuilder();
   auto &expr = std::get<Fortran::parser::ScalarLogicalExpr>(ifClause->v.t);
   mlir::Value ifVal = fir::getBase(
       converter.genExprValue(*Fortran::semantics::GetExpr(expr), stmtCtx));
   return firOpBuilder.createConvert(clauseLocation, firOpBuilder.getI1Type(),
                                     ifVal);
 }
 
return findRepeatableClause<ClauseTy::Depend>(
                   }},
               (ompObject).u);
           const mlir::Value variable = converter.getSymbolAddress(*sym);
           dependOperands.push_back(variable);
         }
       });
 }
 
-bool ClauseProcessor::processIf(Fortran::lower::StatementContext &stmtCtx,
-                                mlir::Value &result) const {
-  return findRepeatableClause<ClauseTy::If>(
+bool ClauseProcessor::processIf(
+    Fortran::lower::StatementContext &stmtCtx,
+    Fortran::parser::OmpIfClause::DirectiveNameModifier directiveName,
+  bool found = false;
+  findRepeatableClause<ClauseTy::If>(
       [&](const ClauseTy::If *ifClause,
           const Fortran::parser::CharBlock &source) {
         mlir::Location clauseLocation = converter.genLocation(source);
-        // TODO Consider DirectiveNameModifier of the `ifClause` to only search
-        // for an applicable 'if' clause.
-        result =
-            getIfClauseOperand(converter, stmtCtx, ifClause, clauseLocation);
+        mlir::Value operand = getIfClauseOperand(converter, stmtCtx, ifClause,
+                                                 directiveName, clauseLocation);
+        // Assume that, at most, a single 'if' clause will be applicable to the
+        // given directive.
+        if (operand) {
+          result = operand;
+          found = true;
+        }
       });
+  return found;
 }
 
 bool ClauseProcessor::processLink(
     llvm::SmallVectorImpl<DeclareTargetCapturePair> &result) const {
   return findRepeatableClause<ClauseTy::Link>(
       [&](const ClauseTy::Link *linkClause,
           const Fortran::parser::CharBlock &) {
         // Case: declare target link(var1, var2)...
static void createTargetOp(Fortran::lower::AbstractConverter &converter,
   mlir::UnitAttr nowaitAttr;
   llvm::SmallVector<mlir::Value> mapOperands, devicePtrOperands,
       deviceAddrOperands;
   llvm::SmallVector<mlir::IntegerAttr> mapTypes;
   llvm::SmallVector<mlir::Type> useDeviceTypes;
   llvm::SmallVector<mlir::Location> useDeviceLocs;
   llvm::SmallVector<const Fortran::semantics::Symbol *> useDeviceSymbols;
 
+  Fortran::parser::OmpIfClause::DirectiveNameModifier directiveName;
+  switch (directive) {
+  case llvm::omp::Directive::OMPD_target:
+    directiveName = Fortran::parser::OmpIfClause::DirectiveNameModifier::Target;
+    break;
+  case llvm::omp::Directive::OMPD_target_data:
+    directiveName =
+        Fortran::parser::OmpIfClause::DirectiveNameModifier::TargetData;
+    break;
+  case llvm::omp::Directive::OMPD_target_enter_data:
+    directiveName =
+        Fortran::parser::OmpIfClause::DirectiveNameModifier::TargetEnterData;
+    break;
+  case llvm::omp::Directive::OMPD_target_exit_data:
+    directiveName =
+        Fortran::parser::OmpIfClause::DirectiveNameModifier::TargetExitData;
+    break;
+  default:
+    TODO(currentLocation, "OMPD_target directive unknown");
+    break;
+  }
+
   ClauseProcessor cp(converter, opClauseList);
-  cp.processIf(stmtCtx, ifClauseOperand);
+  cp.processIf(stmtCtx, directiveName, ifClauseOperand);
   cp.processDevice(stmtCtx, deviceOperand);
   cp.processThreadLimit(stmtCtx, threadLmtOperand);
   cp.processNowait(nowaitAttr);
   cp.processUseDevicePtr(devicePtrOperands, useDeviceTypes, useDeviceLocs,
                          useDeviceSymbols);
   cp.processUseDeviceAddr(deviceAddrOperands, useDeviceTypes, useDeviceLocs,
                           useDeviceSymbols);
   cp.processMap(mapOperands, mapTypes);
static void createTargetOp(Fortran::lower::AbstractConverter &converter,
   } else if (directive == llvm::omp::Directive::OMPD_target_enter_data) {
     firOpBuilder.create<mlir::omp::EnterDataOp>(
         currentLocation, ifClauseOperand, deviceOperand, nowaitAttr,
         mapOperands, mapTypesArrayAttr);
   } else if (directive == llvm::omp::Directive::OMPD_target_exit_data) {
     firOpBuilder.create<mlir::omp::ExitDataOp>(currentLocation, ifClauseOperand,
                                                deviceOperand, nowaitAttr,
                                                mapOperands, mapTypesArrayAttr);
-  } else {
-    TODO(currentLocation, "OMPD_target directive unknown");
   }
 }
 
 static void genOMP(Fortran::lower::AbstractConverter &converter,
                    Fortran::lower::pft::Evaluation &eval,
                    const Fortran::parser::OpenMPSimpleStandaloneConstruct
                        &simpleStandaloneConstruct) {
   const auto &directive =
createCombinedParallelOp(Fortran::lower::AbstractConverter &converter,
   llvm::SmallVector<mlir::Value> allocatorOperands, allocateOperands;
   mlir::omp::ClauseProcBindKindAttr procBindKindAttr;
   const auto &opClauseList =
       std::get<Fortran::parser::OmpClauseList>(directive.t);
   // TODO: Handle the following clauses
   // 1. default
   // Note: rest of the clauses are handled when the inner operation is created
   ClauseProcessor cp(converter, opClauseList);
-  cp.processIf(stmtCtx, ifClauseOperand);
+  cp.processIf(stmtCtx,
+               Fortran::parser::OmpIfClause::DirectiveNameModifier::Parallel,
+               ifClauseOperand);
   cp.processNumThreads(stmtCtx, numThreadsClauseOperand);
   cp.processProcBind(procBindKindAttr);
 
   // Create and insert the operation.
   auto parallelOp = firOpBuilder.create<mlir::omp::ParallelOp>(
       currentLocation, argTy, ifClauseOperand, numThreadsClauseOperand,
       allocateOperands, allocatorOperands,
       /*reduction_vars=*/mlir::ValueRange(),
static void genOMP(Fortran::lower::AbstractConverter &converter,
 
   DataSharingProcessor dsp(converter, loopOpClauseList, eval);
   dsp.processStep1();
 
   ClauseProcessor cp(converter, loopOpClauseList);
   cp.processCollapse(currentLocation, eval, lowerBound, upperBound, step, iv,
                      loopVarTypeSize);
   cp.processScheduleChunk(stmtCtx, scheduleChunkClauseOperand);
-  cp.processIf(stmtCtx, ifClauseOperand);
+  cp.processIf(stmtCtx,
+               Fortran::parser::OmpIfClause::DirectiveNameModifier::Simd,
+               ifClauseOperand);
   cp.processReduction(currentLocation, reductionVars, reductionDeclSymbols);
   cp.processSimdlen(simdlenClauseOperand);
   cp.processSafelen(safelenClauseOperand);
 
   // The types of lower bound, upper bound, and step are converted into the
   // type of the loop variable if necessary.
   mlir::Type loopVarType = getLoopVarType(converter, loopVarTypeSize);
   for (unsigned it = 0; it < (unsigned)lowerBound.size(); it++) {
genOMP(Fortran::lower::AbstractConverter &converter,
   mlir::Value ifClauseOperand, numThreadsClauseOperand, finalClauseOperand,
       priorityClauseOperand;
   mlir::omp::ClauseProcBindKindAttr procBindKindAttr;
   llvm::SmallVector<mlir::Value> allocateOperands, allocatorOperands,
       dependOperands, reductionVars;
   llvm::SmallVector<mlir::Attribute> dependTypeOperands, reductionDeclSymbols;
   mlir::UnitAttr nowaitAttr, untiedAttr, mergeableAttr;
 
+  // Use placeholder value to avoid uninitialized `directiveName` compiler
+  // errors. The 'if clause' obtained won't be used for these directives.
+  Fortran::parser::OmpIfClause::DirectiveNameModifier directiveName =
+      Fortran::parser::OmpIfClause::DirectiveNameModifier::Parallel;
+  switch (blockDirective.v) {
+  case llvm::omp::OMPD_parallel:
+    directiveName =
+        Fortran::parser::OmpIfClause::DirectiveNameModifier::Parallel;
+    break;
+  case llvm::omp::OMPD_task:
+    directiveName = Fortran::parser::OmpIfClause::DirectiveNameModifier::Task;
+    break;
+  // Target-related 'if' clauses handled by createTargetOp().
+  case llvm::omp::OMPD_target:
+  case llvm::omp::OMPD_target_data:
+  // These block directives do not accept an 'if' clause.
+  case llvm::omp::OMPD_master:
+  case llvm::omp::OMPD_single:
+  case llvm::omp::OMPD_ordered:
+  case llvm::omp::OMPD_taskgroup:
+    break;
+  default:
+    TODO(currentLocation,
+         "Unhandled block directive (" +
+             llvm::omp::getOpenMPDirectiveName(blockDirective.v) + ")");
+    break;
+  }
+
   const auto &opClauseList =
       std::get<Fortran::parser::OmpClauseList>(beginBlockDirective.t);
   ClauseProcessor cp(converter, opClauseList);
-  cp.processIf(stmtCtx, ifClauseOperand);
+  cp.processIf(stmtCtx, directiveName, ifClauseOperand);
   cp.processNumThreads(stmtCtx, numThreadsClauseOperand);
   cp.processProcBind(procBindKindAttr);
   cp.processAllocate(allocatorOperands, allocateOperands);
   cp.processDefault();
   cp.processFinal(stmtCtx, finalClauseOperand);
   cp.processUntied(untiedAttr);
   cp.processMergeable(mergeableAttr);
   cp.processPriority(stmtCtx, priorityClauseOperand);
if (blockDirective.v == llvm::omp::OMPD_parallel) {
     createBodyOfOp(taskGroupOp, converter, currentLocation, eval,
                    &opClauseList);
   } else if (blockDirective.v == llvm::omp::OMPD_target) {
     createTargetOp(converter, opClauseList, blockDirective.v, currentLocation,
                    &eval);
   } else if (blockDirective.v == llvm::omp::OMPD_target_data) {
     createTargetOp(converter, opClauseList, blockDirective.v, currentLocation,
                    &eval);
-  } else {
-    TODO(currentLocation, "Unhandled block directive");
   }
 }
 
 static void
 genOMP(Fortran::lower::AbstractConverter &converter,
        Fortran::lower::pft::Evaluation &eval,
        const Fortran::parser::OpenMPCriticalConstruct &criticalConstruct) {
   fir::FirOpBuilder &firOpBuilder = converter.getFirOpBuilder();

flang/lib/Parser/openmp-parsers.cpp

TYPE_PARSER(construct<OmpDeviceTypeClause>(
     "ANY" >> pure(OmpDeviceTypeClause::Type::Any) ||
     "HOST" >> pure(OmpDeviceTypeClause::Type::Host) ||
     "NOHOST" >> pure(OmpDeviceTypeClause::Type::Nohost)))
 
 // 2.12 IF (directive-name-modifier: scalar-logical-expr)
 TYPE_PARSER(construct<OmpIfClause>(
     maybe(
         ("PARALLEL" >> pure(OmpIfClause::DirectiveNameModifier::Parallel) ||
+            "SIMD" >> pure(OmpIfClause::DirectiveNameModifier::Simd) ||
             "TARGET ENTER DATA" >>
                 pure(OmpIfClause::DirectiveNameModifier::TargetEnterData) ||
             "TARGET EXIT DATA" >>
                 pure(OmpIfClause::DirectiveNameModifier::TargetExitData) ||
             "TARGET DATA" >>
                 pure(OmpIfClause::DirectiveNameModifier::TargetData) ||
             "TARGET UPDATE" >>
                 pure(OmpIfClause::DirectiveNameModifier::TargetUpdate) ||
             "TARGET" >> pure(OmpIfClause::DirectiveNameModifier::Target) ||
             "TASK"_id >> pure(OmpIfClause::DirectiveNameModifier::Task) ||
-            "TASKLOOP" >> pure(OmpIfClause::DirectiveNameModifier::Taskloop)) /
+            "TASKLOOP" >> pure(OmpIfClause::DirectiveNameModifier::Taskloop) ||
+            "TEAMS" >> pure(OmpIfClause::DirectiveNameModifier::Teams)) /
         ":"),
     scalarLogicalExpr))
 
 // 2.15.3.6 REDUCTION (reduction-identifier: variable-name-list)
 TYPE_PARSER(construct<OmpReductionOperator>(Parser<DefinedOperator>{}) ||
     construct<OmpReductionOperator>(Parser<ProcedureDesignator>{}))
 
 TYPE_PARSER(construct<OmpReductionClause>(

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

OmpDirectiveSet{Directive::OMPD_workshare,
         Directive::OMPD_sections, Directive::OMPD_single} |
     doSet};
 static OmpDirectiveSet taskloopSet{
     Directive::OMPD_taskloop, Directive::OMPD_taskloop_simd};
 static OmpDirectiveSet targetSet{Directive::OMPD_target,
     Directive::OMPD_target_parallel, Directive::OMPD_target_parallel_do,
     Directive::OMPD_target_parallel_do_simd, Directive::OMPD_target_simd,
     Directive::OMPD_target_teams, Directive::OMPD_target_teams_distribute,
+    Directive::OMPD_target_teams_distribute_parallel_do,
+    Directive::OMPD_target_teams_distribute_parallel_do_simd,
     Directive::OMPD_target_teams_distribute_simd};
 static OmpDirectiveSet simdSet{Directive::OMPD_distribute_parallel_do_simd,
-    Directive::OMPD_distribute_simd, Directive::OMPD_parallel_do_simd,
-    Directive::OMPD_do_simd, Directive::OMPD_simd,
-    Directive::OMPD_target_parallel_do_simd,
+    Directive::OMPD_distribute_simd, Directive::OMPD_do_simd,
+    Directive::OMPD_parallel_do_simd, Directive::OMPD_simd,
+    Directive::OMPD_target_parallel_do_simd, Directive::OMPD_target_simd,
     Directive::OMPD_target_teams_distribute_parallel_do_simd,
-    Directive::OMPD_target_teams_distribute_simd, Directive::OMPD_target_simd,
-    Directive::OMPD_taskloop_simd,
+    Directive::OMPD_target_teams_distribute_simd, Directive::OMPD_taskloop_simd,
     Directive::OMPD_teams_distribute_parallel_do_simd,
     Directive::OMPD_teams_distribute_simd};
 static OmpDirectiveSet teamSet{Directive::OMPD_teams,
     Directive::OMPD_teams_distribute,
     Directive::OMPD_teams_distribute_parallel_do,
     Directive::OMPD_teams_distribute_parallel_do_simd,
-    Directive::OMPD_teams_distribute_parallel_for,
-    Directive::OMPD_teams_distribute_parallel_for_simd,
     Directive::OMPD_teams_distribute_simd};
 static OmpDirectiveSet taskGeneratingSet{
     OmpDirectiveSet{Directive::OMPD_task} | taskloopSet};
 static OmpDirectiveSet nestedOrderedErrSet{Directive::OMPD_critical,
     Directive::OMPD_ordered, Directive::OMPD_atomic, Directive::OMPD_task,
     Directive::OMPD_taskloop};
 static OmpDirectiveSet nestedWorkshareErrSet{
     OmpDirectiveSet{Directive::OMPD_task, Directive::OMPD_taskloop,

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

if (!std::get<std::optional<VariableCategory>>(x.v.t)) {
     context_.Say(GetContext().clauseSource,
         "The argument TOFROM:SCALAR must be specified on the DEFAULTMAP "
         "clause"_err_en_US);
   }
 }
 void OmpStructureChecker::Enter(const parser::OmpClause::If &x) {
   CheckAllowed(llvm::omp::Clause::OMPC_if);
   using dirNameModifier = parser::OmpIfClause::DirectiveNameModifier;
+  // TODO Check that, when multiple 'if' clauses are applied to a combined
+  // construct, at most one of them applies to each directive.
+  // Need to define set here because llvm::omp::teamSet does not include target
+  // teams combined constructs.
+  OmpDirectiveSet teamSet{llvm::omp::Directive::OMPD_target_teams,
+      llvm::omp::Directive::OMPD_target_teams_distribute,
+      llvm::omp::Directive::OMPD_target_teams_distribute_parallel_do,
+      llvm::omp::Directive::OMPD_target_teams_distribute_parallel_do_simd,
+      llvm::omp::Directive::OMPD_target_teams_distribute_simd,
+      llvm::omp::Directive::OMPD_teams,
+      llvm::omp::Directive::OMPD_teams_distribute,
+      llvm::omp::Directive::OMPD_teams_distribute_parallel_do,
+      llvm::omp::Directive::OMPD_teams_distribute_parallel_do_simd,
+      llvm::omp::Directive::OMPD_teams_distribute_simd};
   static std::unordered_map<dirNameModifier, OmpDirectiveSet>
       dirNameModifierMap{{dirNameModifier::Parallel, llvm::omp::parallelSet},
+          {dirNameModifier::Simd, llvm::omp::simdSet},
           {dirNameModifier::Target, llvm::omp::targetSet},
+          {dirNameModifier::TargetData,
+              {llvm::omp::Directive::OMPD_target_data}},
           {dirNameModifier::TargetEnterData,
               {llvm::omp::Directive::OMPD_target_enter_data}},
           {dirNameModifier::TargetExitData,
               {llvm::omp::Directive::OMPD_target_exit_data}},
-          {dirNameModifier::TargetData,
-              {llvm::omp::Directive::OMPD_target_data}},
           {dirNameModifier::TargetUpdate,
               {llvm::omp::Directive::OMPD_target_update}},
           {dirNameModifier::Task, {llvm::omp::Directive::OMPD_task}},
-          {dirNameModifier::Taskloop, llvm::omp::taskloopSet}};
+          {dirNameModifier::Taskloop, llvm::omp::taskloopSet},
+          {dirNameModifier::Teams, teamSet}};
   if (const auto &directiveName{
           std::get<std::optional<dirNameModifier>>(x.v.t)}) {
     auto search{dirNameModifierMap.find(*directiveName)};
     if (search == dirNameModifierMap.end() ||
         !search->second.test(GetContext().directive)) {
       context_
           .Say(GetContext().clauseSource,
               "Unmatched directive name modifier %s on the IF clause"_err_en_US,

flang/test/Parser/OpenMP/if-clause-unparse.f90

+! RUN: %flang_fc1 -fdebug-unparse-no-sema -fopenmp %s | FileCheck %s
+! Check Unparsing of OpenMP IF clause
+
+program if_unparse
+  logical :: cond
+  integer :: i
+
+  ! CHECK: !$OMP TARGET UPDATE
+  ! CHECK-SAME: IF(cond)
+  !$omp target update if(cond)
+
+  ! CHECK: !$OMP TARGET UPDATE
+  ! CHECK-SAME: IF(TARGETUPDATE:cond)
+  !$omp target update if(target update: cond)
+  
+  ! CHECK: !$OMP TARGET UPDATE
+  ! CHECK-SAME: IF(TARGETUPDATE:cond)
+  !$omp target update if(targetupdate: cond)
+
+  ! CHECK: !$OMP TARGET ENTER DATA
+  ! CHECK-SAME: IF(TARGETENTERDATA:cond)
+  !$omp target enter data map(to: i) if(target enter data: cond)
+
+  ! CHECK: !$OMP TARGET EXIT DATA
+  ! CHECK-SAME: IF(TARGETEXITDATA:cond)
+  !$omp target exit data map(from: i) if(target exit data: cond)
+
+  ! CHECK: !$OMP TARGET DATA
+  ! CHECK-SAME: IF(TARGETDATA:cond)
+  !$omp target data map(tofrom: i) if(target data: cond)
+  !$omp end target data
+
+  ! CHECK: !$OMP TARGET
+  ! CHECK-SAME: IF(TARGET:cond)
+  !$omp target if(target: cond)
+  !$omp end target
+
+  ! CHECK: !$OMP TEAMS
+  ! CHECK-SAME: IF(TEAMS:cond)
+  !$omp teams if(teams: cond)
+  !$omp end teams
+
+  ! CHECK: !$OMP PARALLEL DO SIMD
+  ! CHECK-SAME: IF(PARALLEL:i<10) IF(SIMD:.FALSE.)
+  !$omp parallel do simd if(parallel: i < 10) if(simd: .false.)
+  do i = 1, 10
+  end do
+  !$omp end parallel do simd
+
+  ! CHECK: !$OMP TASK
+  ! CHECK-SAME: IF(TASK:cond)
+  !$omp task if(task: cond)
+  !$omp end task
+
+  ! CHECK: !$OMP TASKLOOP
+  ! CHECK-SAME: IF(TASKLOOP:cond)
+  !$omp taskloop if(taskloop: cond)
+  do i = 1, 10
+  end do
+  !$omp end taskloop
+end program if_unparse

flang/test/Parser/OpenMP/if-clause.f90

+! RUN: %flang_fc1 -fdebug-dump-parse-tree -fopenmp %s | FileCheck %s
+
+program openmp_parse_if
+  logical :: cond
+  integer :: i
+
+  ! CHECK: OmpSimpleStandaloneDirective -> llvm::omp::Directive = target update
+  ! CHECK-NEXT: OmpClause -> If -> OmpIfClause
+  ! CHECK-NOT: DirectiveNameModifier
+  !$omp target update if(cond)
+
+  ! CHECK: OmpSimpleStandaloneDirective -> llvm::omp::Directive = target update
+  ! CHECK-NEXT: OmpClause -> If -> OmpIfClause
+  ! CHECK-NEXT: DirectiveNameModifier = TargetUpdate
+  !$omp target update if(target update: cond)
+
+  ! CHECK: OmpSimpleStandaloneDirective -> llvm::omp::Directive = target enter data
+  ! CHECK: OmpClause -> If -> OmpIfClause
+  ! CHECK-NEXT: DirectiveNameModifier = TargetEnterData
+  !$omp target enter data map(to: i) if(target enter data: cond)
+
+  ! CHECK: OmpSimpleStandaloneDirective -> llvm::omp::Directive = target exit data
+  ! CHECK: OmpClause -> If -> OmpIfClause
+  ! CHECK-NEXT: DirectiveNameModifier = TargetExitData
+  !$omp target exit data map(from: i) if(target exit data: cond)
+
+  ! CHECK: OmpBlockDirective -> llvm::omp::Directive = target data
+  ! CHECK: OmpClause -> If -> OmpIfClause
+  ! CHECK-NEXT: DirectiveNameModifier = TargetData
+  !$omp target data map(tofrom: i) if(target data: cond)
+  !$omp end target data
+
+  ! CHECK: OmpLoopDirective -> llvm::omp::Directive = target teams distribute parallel do simd
+  ! CHECK: OmpClause -> If -> OmpIfClause
+  ! CHECK-NEXT: DirectiveNameModifier = Target
+  ! CHECK: OmpClause -> If -> OmpIfClause
+  ! CHECK-NEXT: DirectiveNameModifier = Teams
+  ! CHECK: OmpClause -> If -> OmpIfClause
+  ! CHECK-NEXT: DirectiveNameModifier = Parallel
+  ! CHECK: OmpClause -> If -> OmpIfClause
+  ! CHECK-NEXT: DirectiveNameModifier = Simd
+  !$omp target teams distribute parallel do simd if(target: cond) &
+  !$omp&    if(teams: cond) if(parallel: cond) if(simd: cond)
+  do i = 1, 10
+  end do
+  !$omp end target teams distribute parallel do simd
+
+  ! CHECK: OmpBlockDirective -> llvm::omp::Directive = task
+  ! CHECK-NEXT: OmpClause -> If -> OmpIfClause
+  ! CHECK-NEXT: DirectiveNameModifier = Task
+  !$omp task if(task: cond)
+  !$omp end task
+
+  ! CHECK: OmpLoopDirective -> llvm::omp::Directive = taskloop
+  ! CHECK-NEXT: OmpClause -> If -> OmpIfClause
+  ! CHECK-NEXT: DirectiveNameModifier = Taskloop
+  !$omp taskloop if(taskloop: cond)
+  do i = 1, 10
+  end do
+  !$omp end taskloop
+end program openmp_parse_if

flang/test/Semantics/OpenMP/if-clause.f90

+! RUN: %python %S/../test_errors.py %s %flang -fopenmp
+! Check OpenMP 'if' clause validity for all directives that can have it
+
+program main
+  integer :: i
+
+  ! ----------------------------------------------------------------------------
+  ! DISTRIBUTE PARALLEL DO
+  ! ----------------------------------------------------------------------------
+  !$omp teams
+  !$omp distribute parallel do if(.true.)
+  do i = 1, 10
+  end do
+  !$omp end distribute parallel do
+
+  !$omp distribute parallel do if(parallel: .true.)
+  do i = 1, 10
+  end do
+  !$omp end distribute parallel do
+
+  !ERROR: Unmatched directive name modifier TARGET on the IF clause
+  !$omp distribute parallel do if(target: .true.)
+  do i = 1, 10
+  end do
+  !$omp end distribute parallel do
+
+  !ERROR: At most one IF clause can appear on the DISTRIBUTE PARALLEL DO directive
+  !$omp distribute parallel do if(.true.) if(parallel: .false.)
+  do i = 1, 10
+  end do
+  !$omp end distribute parallel do
+  !$omp end teams
+
+  ! ----------------------------------------------------------------------------
+  ! DISTRIBUTE PARALLEL DO SIMD
+  ! ----------------------------------------------------------------------------
+  !$omp teams
+  !$omp distribute parallel do simd if(.true.)
+  do i = 1, 10
+  end do
+  !$omp end distribute parallel do simd
+
+  !$omp distribute parallel do simd if(parallel: .true.) if(simd: .false.)
+  do i = 1, 10
+  end do
+  !$omp end distribute parallel do simd
+
+  !ERROR: Unmatched directive name modifier TARGET on the IF clause
+  !$omp distribute parallel do simd if(target: .true.)
+  do i = 1, 10
+  end do
+  !$omp end distribute parallel do simd
+  !$omp end teams
+
+  ! ----------------------------------------------------------------------------
+  ! DISTRIBUTE SIMD
+  ! ----------------------------------------------------------------------------
+  !$omp teams
+  !$omp distribute simd if(.true.)
+  do i = 1, 10
+  end do
+  !$omp end distribute simd
+
+  !$omp distribute simd if(simd: .true.)
+  do i = 1, 10
+  end do
+  !$omp end distribute simd
+
+  !ERROR: Unmatched directive name modifier TARGET on the IF clause
+  !$omp distribute simd if(target: .true.)
+  do i = 1, 10
+  end do
+  !$omp end distribute simd
+
+  !ERROR: At most one IF clause can appear on the DISTRIBUTE SIMD directive
+  !$omp distribute simd if(.true.) if(simd: .false.)
+  do i = 1, 10
+  end do
+  !$omp end distribute simd
+  !$omp end teams
+
+  ! ----------------------------------------------------------------------------
+  ! DO SIMD
+  ! ----------------------------------------------------------------------------
+  !$omp do simd if(.true.)
+  do i = 1, 10
+  end do
+  !$omp end do simd
+
+  !$omp do simd if(simd: .true.)
+  do i = 1, 10
+  end do
+  !$omp end do simd
+
+  !ERROR: Unmatched directive name modifier TARGET on the IF clause
+  !$omp do simd if(target: .true.)
+  do i = 1, 10
+  end do
+  !$omp end do simd
+
+  !ERROR: At most one IF clause can appear on the DO SIMD directive
+  !$omp do simd if(.true.) if(simd: .false.)
+  do i = 1, 10
+  end do
+  !$omp end do simd
+
+  ! ----------------------------------------------------------------------------
+  ! PARALLEL
+  ! ----------------------------------------------------------------------------
+  !$omp parallel if(.true.)
+  !$omp end parallel
+
+  !$omp parallel if(parallel: .true.)
+  !$omp end parallel
+
+  !ERROR: Unmatched directive name modifier TARGET on the IF clause
+  !$omp parallel if(target: .true.)
+  !$omp end parallel
+
+  !ERROR: At most one IF clause can appear on the PARALLEL directive
+  !$omp parallel if(.true.) if(parallel: .false.)
+  !$omp end parallel
+
+  ! ----------------------------------------------------------------------------
+  ! PARALLEL DO
+  ! ----------------------------------------------------------------------------
+  !$omp parallel do if(.true.)
+  do i = 1, 10
+  end do
+  !$omp end parallel do
+
+  !$omp parallel do if(parallel: .true.)
+  do i = 1, 10
+  end do
+  !$omp end parallel do
+
+  !ERROR: Unmatched directive name modifier TARGET on the IF clause
+  !$omp parallel do if(target: .true.)
+  do i = 1, 10
+  end do
+  !$omp end parallel do
+
+  !ERROR: At most one IF clause can appear on the PARALLEL DO directive
+  !$omp parallel do if(.true.) if(parallel: .false.)
+  do i = 1, 10
+  end do
+  !$omp end parallel do
+
+  ! ----------------------------------------------------------------------------
+  ! PARALLEL DO SIMD
+  ! ----------------------------------------------------------------------------
+  !$omp parallel do simd if(.true.)
+  do i = 1, 10
+  end do
+  !$omp end parallel do simd
+
+  !$omp parallel do simd if(parallel: .true.) if(simd: .false.)
+  do i = 1, 10
+  end do
+  !$omp end parallel do simd
+
+  !ERROR: Unmatched directive name modifier TARGET on the IF clause
+  !$omp parallel do simd if(target: .true.)
+  do i = 1, 10
+  end do
+  !$omp end parallel do simd
+
+  ! ----------------------------------------------------------------------------
+  ! PARALLEL SECTIONS
+  ! ----------------------------------------------------------------------------
+  !$omp parallel sections if(.true.)
+  !$omp end parallel sections
+
+  !$omp parallel sections if(parallel: .true.)
+  !$omp end parallel sections
+
+  !ERROR: Unmatched directive name modifier TARGET on the IF clause
+  !$omp parallel sections if(target: .true.)
+  !$omp end parallel sections
+
+  !ERROR: At most one IF clause can appear on the PARALLEL SECTIONS directive
+  !$omp parallel sections if(.true.) if(parallel: .false.)
+  !$omp end parallel sections
+
+  ! ----------------------------------------------------------------------------
+  ! PARALLEL WORKSHARE
+  ! ----------------------------------------------------------------------------
+  !$omp parallel workshare if(.true.)
+  !$omp end parallel workshare
+
+  !$omp parallel workshare if(parallel: .true.)
+  !$omp end parallel workshare
+
+  !ERROR: Unmatched directive name modifier TARGET on the IF clause
+  !$omp parallel workshare if(target: .true.)
+  !$omp end parallel workshare
+
+  !ERROR: At most one IF clause can appear on the PARALLEL WORKSHARE directive
+  !$omp parallel workshare if(.true.) if(parallel: .false.)
+  !$omp end parallel workshare
+
+  ! ----------------------------------------------------------------------------
+  ! SIMD
+  ! ----------------------------------------------------------------------------
+  !$omp simd if(.true.)
+  do i = 1, 10
+  end do
+  !$omp end simd
+
+  !$omp simd if(simd: .true.)
+  do i = 1, 10
+  end do
+  !$omp end simd
+
+  !ERROR: Unmatched directive name modifier TARGET on the IF clause
+  !$omp simd if(target: .true.)
+  do i = 1, 10
+  end do
+  !$omp end simd
+
+  !ERROR: At most one IF clause can appear on the SIMD directive
+  !$omp simd if(.true.) if(simd: .false.)
+  do i = 1, 10
+  end do
+  !$omp end simd
+
+  ! ----------------------------------------------------------------------------
+  ! TARGET
+  ! ----------------------------------------------------------------------------
+  !$omp target if(.true.)
+  !$omp end target
+
+  !$omp target if(target: .true.)
+  !$omp end target
+
+  !ERROR: Unmatched directive name modifier PARALLEL on the IF clause
+  !$omp target if(parallel: .true.)
+  !$omp end target
+
+  !ERROR: At most one IF clause can appear on the TARGET directive
+  !$omp target if(.true.) if(target: .false.)
+  !$omp end target
+
+  ! ----------------------------------------------------------------------------
+  ! TARGET DATA
+  ! ----------------------------------------------------------------------------
+  !$omp target data map(tofrom: i) if(.true.)
+  !$omp end target data
+
+  !$omp target data map(tofrom: i) if(target data: .true.)
+  !$omp end target data
+
+  !ERROR: Unmatched directive name modifier TARGET on the IF clause
+  !$omp target data map(tofrom: i) if(target: .true.)
+  !$omp end target data
+
+  !ERROR: At most one IF clause can appear on the TARGET DATA directive
+  !$omp target data map(tofrom: i) if(.true.) if(target data: .false.)
+  !$omp end target data
+
+  ! ----------------------------------------------------------------------------
+  ! TARGET ENTER DATA
+  ! ----------------------------------------------------------------------------
+  !$omp target enter data map(to: i) if(.true.)
+
+  !$omp target enter data map(to: i) if(target enter data: .true.)
+
+  !ERROR: Unmatched directive name modifier TARGET on the IF clause
+  !$omp target enter data map(to: i) if(target: .true.)
+
+  !ERROR: At most one IF clause can appear on the TARGET ENTER DATA directive
+  !$omp target enter data map(to: i) if(.true.) if(target enter data: .false.)
+
+  ! ----------------------------------------------------------------------------
+  ! TARGET EXIT DATA
+  ! ----------------------------------------------------------------------------
+  !$omp target exit data map(from: i) if(.true.)
+
+  !$omp target exit data map(from: i) if(target exit data: .true.)
+
+  !ERROR: Unmatched directive name modifier TARGET on the IF clause
+  !$omp target exit data map(from: i) if(target: .true.)
+  
+  !ERROR: At most one IF clause can appear on the TARGET EXIT DATA directive
+  !$omp target exit data map(from: i) if(.true.) if(target exit data: .false.)
+
+  ! ----------------------------------------------------------------------------
+  ! TARGET PARALLEL
+  ! ----------------------------------------------------------------------------
+  !$omp target parallel if(.true.)
+  !$omp end target parallel
+
+  !$omp target parallel if(target: .true.) if(parallel: .false.)
+  !$omp end target parallel
+
+  !ERROR: Unmatched directive name modifier SIMD on the IF clause
+  !$omp target parallel if(simd: .true.)
+  !$omp end target parallel
+
+  ! ----------------------------------------------------------------------------
+  ! TARGET PARALLEL DO
+  ! ----------------------------------------------------------------------------
+  !$omp target parallel do if(.true.)
+  do i = 1, 10
+  end do
+  !$omp end target parallel do
+
+  !$omp target parallel do if(target: .true.) if(parallel: .false.)
+  do i = 1, 10
+  end do
+  !$omp end target parallel do
+
+  !ERROR: Unmatched directive name modifier SIMD on the IF clause
+  !$omp target parallel do if(simd: .true.)
+  do i = 1, 10
+  end do
+  !$omp end target parallel do
+
+  ! ----------------------------------------------------------------------------
+  ! TARGET PARALLEL DO SIMD
+  ! ----------------------------------------------------------------------------
+  !$omp target parallel do simd if(.true.)
+  do i = 1, 10
+  end do
+  !$omp end target parallel do simd
+
+  !$omp target parallel do simd if(target: .true.) if(parallel: .false.) &
+  !$omp&                        if(simd: .true.)
+  do i = 1, 10
+  end do
+  !$omp end target parallel do simd
+
+  !ERROR: Unmatched directive name modifier TEAMS on the IF clause
+  !$omp target parallel do simd if(teams: .true.)
+  do i = 1, 10
+  end do
+  !$omp end target parallel do simd
+
+  ! ----------------------------------------------------------------------------
+  ! TARGET SIMD
+  ! ----------------------------------------------------------------------------
+  !$omp target simd if(.true.)
+  do i = 1, 10
+  end do
+  !$omp end target simd
+
+  !$omp target simd if(target: .true.) if(simd: .false.)
+  do i = 1, 10
+  end do
+  !$omp end target simd
+
+  !ERROR: Unmatched directive name modifier PARALLEL on the IF clause
+  !$omp target simd if(parallel: .true.)
+  do i = 1, 10
+  end do
+  !$omp end target simd
+
+  ! ----------------------------------------------------------------------------
+  ! TARGET TEAMS
+  ! ----------------------------------------------------------------------------
+  !$omp target teams if(.true.)
+  !$omp end target teams
+
+  !$omp target teams if(target: .true.) if(teams: .false.)
+  !$omp end target teams
+
+  !ERROR: Unmatched directive name modifier PARALLEL on the IF clause
+  !$omp target teams if(parallel: .true.)
+  !$omp end target teams
+
+  ! ----------------------------------------------------------------------------
+  ! TARGET TEAMS DISTRIBUTE
+  ! ----------------------------------------------------------------------------
+  !$omp target teams distribute if(.true.)
+  do i = 1, 10
+  end do
+  !$omp end target teams distribute
+
+  !$omp target teams distribute if(target: .true.) if(teams: .false.)
+  do i = 1, 10
+  end do
+  !$omp end target teams distribute
+
+  !ERROR: Unmatched directive name modifier PARALLEL on the IF clause
+  !$omp target teams distribute if(parallel: .true.)
+  do i = 1, 10
+  end do
+  !$omp end target teams distribute
+
+  ! ----------------------------------------------------------------------------
+  ! TARGET TEAMS DISTRIBUTE PARALLEL DO
+  ! ----------------------------------------------------------------------------
+  !$omp target teams distribute parallel do if(.true.)
+  do i = 1, 10
+  end do
+  !$omp end target teams distribute parallel do
+
+  !$omp target teams distribute parallel do &
+  !$omp&   if(target: .true.) if(teams: .false.) if(parallel: .true.)
+  do i = 1, 10
+  end do
+  !$omp end target teams distribute parallel do
+
+  !ERROR: Unmatched directive name modifier SIMD on the IF clause
+  !$omp target teams distribute parallel do if(simd: .true.)
+  do i = 1, 10
+  end do
+  !$omp end target teams distribute parallel do
+
+  ! ----------------------------------------------------------------------------
+  ! TARGET TEAMS DISTRIBUTE PARALLEL DO SIMD
+  ! ----------------------------------------------------------------------------
+  !$omp target teams distribute parallel do simd if(.true.)
+  do i = 1, 10
+  end do
+  !$omp end target teams distribute parallel do simd
+
+  !$omp target teams distribute parallel do simd &
+  !$omp&   if(target: .true.) if(teams: .false.) if(parallel: .true.) &
+  !$omp&   if(simd: .false.)
+  do i = 1, 10
+  end do
+  !$omp end target teams distribute parallel do simd
+
+  !ERROR: Unmatched directive name modifier TASK on the IF clause
+  !$omp target teams distribute parallel do simd if(task: .true.)
+  do i = 1, 10
+  end do
+  !$omp end target teams distribute parallel do simd
+
+  ! ----------------------------------------------------------------------------
+  ! TARGET TEAMS DISTRIBUTE SIMD
+  ! ----------------------------------------------------------------------------
+  !$omp target teams distribute simd if(.true.)
+  do i = 1, 10
+  end do
+  !$omp end target teams distribute simd
+
+  !$omp target teams distribute simd &
+  !$omp&   if(target: .true.) if(teams: .false.) if(simd: .true.)
+  do i = 1, 10
+  end do
+  !$omp end target teams distribute simd
+
+  !ERROR: Unmatched directive name modifier PARALLEL on the IF clause
+  !$omp target teams distribute simd if(parallel: .true.)
+  do i = 1, 10
+  end do
+  !$omp end target teams distribute simd
+
+  ! ----------------------------------------------------------------------------
+  ! TARGET UPDATE
+  ! ----------------------------------------------------------------------------
+  !$omp target update if(.true.)
+  
+  !$omp target update if(target update: .true.)
+
+  !ERROR: Unmatched directive name modifier TARGET on the IF clause
+  !$omp target update if(target: .true.)
+
+  !ERROR: At most one IF clause can appear on the TARGET UPDATE directive
+  !$omp target update if(.true.) if(target update: .false.)
+
+  ! ----------------------------------------------------------------------------
+  ! TASK
+  ! ----------------------------------------------------------------------------
+  !$omp task if(.true.)
+  !$omp end task
+
+  !$omp task if(task: .true.)
+  !$omp end task
+
+  !ERROR: Unmatched directive name modifier TARGET on the IF clause
+  !$omp task if(target: .true.)
+  !$omp end task
+
+  !ERROR: At most one IF clause can appear on the TASK directive
+  !$omp task if(.true.) if(task: .false.)
+  !$omp end task
+
+  ! ----------------------------------------------------------------------------
+  ! TASKLOOP
+  ! ----------------------------------------------------------------------------
+  !$omp taskloop if(.true.)
+  do i = 1, 10
+  end do
+  !$omp end taskloop
+
+  !$omp taskloop if(taskloop: .true.)
+  do i = 1, 10
+  end do
+  !$omp end taskloop
+
+  !ERROR: Unmatched directive name modifier TARGET on the IF clause
+  !$omp taskloop if(target: .true.)
+  do i = 1, 10
+  end do
+  !$omp end taskloop
+
+  !ERROR: At most one IF clause can appear on the TASKLOOP directive
+  !$omp taskloop if(.true.) if(taskloop: .false.)
+  do i = 1, 10
+  end do
+  !$omp end taskloop
+
+  ! ----------------------------------------------------------------------------
+  ! TASKLOOP SIMD
+  ! ----------------------------------------------------------------------------
+  !$omp taskloop simd if(.true.)
+  do i = 1, 10
+  end do
+  !$omp end taskloop simd
+
+  !$omp taskloop simd if(taskloop: .true.) if(simd: .false.)
+  do i = 1, 10
+  end do
+  !$omp end taskloop simd
+
+  !ERROR: Unmatched directive name modifier TARGET on the IF clause
+  !$omp taskloop simd if(target: .true.)
+  do i = 1, 10
+  end do
+  !$omp end taskloop simd
+
+  ! ----------------------------------------------------------------------------
+  ! TEAMS
+  ! ----------------------------------------------------------------------------
+  !$omp teams if(.true.)
+  !$omp end teams
+
+  !$omp teams if(teams: .true.)
+  !$omp end teams
+
+  !ERROR: Unmatched directive name modifier TARGET on the IF clause
+  !$omp teams if(target: .true.)
+  !$omp end teams
+
+  !ERROR: At most one IF clause can appear on the TEAMS directive
+  !$omp teams if(.true.) if(teams: .false.)
+  !$omp end teams
+
+  ! ----------------------------------------------------------------------------
+  ! TEAMS DISTRIBUTE
+  ! ----------------------------------------------------------------------------
+  !$omp teams distribute if(.true.)
+  do i = 1, 10
+  end do
+  !$omp end teams distribute
+
+  !$omp teams distribute if(teams: .true.)
+  do i = 1, 10
+  end do
+  !$omp end teams distribute
+
+  !ERROR: Unmatched directive name modifier TARGET on the IF clause
+  !$omp teams distribute if(target: .true.)
+  do i = 1, 10
+  end do
+  !$omp end teams distribute
+
+  !ERROR: At most one IF clause can appear on the TEAMS DISTRIBUTE directive
+  !$omp teams distribute if(.true.) if(teams: .true.)
+  do i = 1, 10
+  end do
+  !$omp end teams distribute
+
+  ! ----------------------------------------------------------------------------
+  ! TEAMS DISTRIBUTE PARALLEL DO
+  ! ----------------------------------------------------------------------------
+  !$omp teams distribute parallel do if(.true.)
+  do i = 1, 10
+  end do
+  !$omp end teams distribute parallel do
+
+  !$omp teams distribute parallel do if(teams: .true.) if(parallel: .false.)
+  do i = 1, 10
+  end do
+  !$omp end teams distribute parallel do
+
+  !ERROR: Unmatched directive name modifier TARGET on the IF clause
+  !$omp teams distribute parallel do if(target: .true.)
+  do i = 1, 10
+  end do
+  !$omp end teams distribute parallel do
+
+  ! ----------------------------------------------------------------------------
+  ! TEAMS DISTRIBUTE PARALLEL DO SIMD
+  ! ----------------------------------------------------------------------------
+  !$omp teams distribute parallel do simd if(.true.)
+  do i = 1, 10
+  end do
+  !$omp end teams distribute parallel do simd
+
+  !$omp teams distribute parallel do simd &
+  !$omp&   if(teams: .true.) if(parallel: .true.) if(simd: .true.)
+  do i = 1, 10
+  end do
+  !$omp end teams distribute parallel do simd
+
+  !ERROR: Unmatched directive name modifier TARGET on the IF clause
+  !$omp teams distribute parallel do simd if(target: .true.)
+  do i = 1, 10
+  end do
+  !$omp end teams distribute parallel do simd
+
+  ! ----------------------------------------------------------------------------
+  ! TEAMS DISTRIBUTE SIMD
+  ! ----------------------------------------------------------------------------
+  !$omp teams distribute simd if(.true.)
+  do i = 1, 10
+  end do
+  !$omp end teams distribute simd
+
+  !$omp teams distribute simd if(teams: .true.) if(simd: .true.)
+  do i = 1, 10
+  end do
+  !$omp end teams distribute simd
+
+  !ERROR: Unmatched directive name modifier TARGET on the IF clause
+  !$omp teams distribute simd if(target: .true.)
+  do i = 1, 10
+  end do
+  !$omp end teams distribute simd
+end program main

llvm/include/llvm/Frontend/OpenMP/OMP.td

let allowedOnceClauses = [
     VersionedClause<OMPC_Acquire, 50>,
     VersionedClause<OMPC_Release, 50>,
     VersionedClause<OMPC_Relaxed, 50>,
     VersionedClause<OMPC_Hint, 50>
   ];
 }
 def OMP_Target : Directive<"target"> {
   let allowedClauses = [
-    VersionedClause<OMPC_If>,
     VersionedClause<OMPC_Map>,
     VersionedClause<OMPC_Private>,
     VersionedClause<OMPC_Depend>,
     VersionedClause<OMPC_FirstPrivate>,
     VersionedClause<OMPC_IsDevicePtr>,
     VersionedClause<OMPC_HasDeviceAddr, 51>,
     VersionedClause<OMPC_Reduction>,
     VersionedClause<OMPC_InReduction, 50>,
     VersionedClause<OMPC_Allocate>,
     VersionedClause<OMPC_UsesAllocators, 50>,
     VersionedClause<OMPC_OMPX_Attribute>,
   ];
   let allowedOnceClauses = [
+    VersionedClause<OMPC_If>,
     VersionedClause<OMPC_Device>,
     VersionedClause<OMPC_ThreadLimit, 51>,
     VersionedClause<OMPC_DefaultMap>,
     VersionedClause<OMPC_NoWait>,
     VersionedClause<OMPC_OMPX_DynCGroupMem>,
   ];
 }
 def OMP_Teams : Directive<"teams"> {
   let allowedClauses = [
     VersionedClause<OMPC_Private>,
     VersionedClause<OMPC_FirstPrivate>,
     VersionedClause<OMPC_Shared>,
     VersionedClause<OMPC_Reduction>,
     VersionedClause<OMPC_Allocate>,
     VersionedClause<OMPC_OMPX_Attribute>,
   ];
   let allowedOnceClauses = [
     VersionedClause<OMPC_Default>,
+    VersionedClause<OMPC_If>,
     VersionedClause<OMPC_NumTeams>,
     VersionedClause<OMPC_ThreadLimit>
   ];
 }
 def OMP_Cancel : Directive<"cancel"> {
-  let allowedClauses = [
+  let allowedOnceClauses = [
     VersionedClause<OMPC_If>
   ];
 }
 def OMP_Requires : Directive<"requires"> {
   let allowedOnceClauses = [
     VersionedClause<OMPC_UnifiedAddress>,
     VersionedClause<OMPC_UnifiedSharedMemory>,
     // OpenMP 5.2 Spec: If an implementation is not supporting a requirement
let allowedOnceClauses = [
     VersionedClause<OMPC_NoWait>
   ];
   let requiredClauses = [
     VersionedClause<OMPC_Map>
   ];
 }
 def OMP_TargetParallel : Directive<"target parallel"> {
   let allowedClauses = [
+    VersionedClause<OMPC_If>,
     VersionedClause<OMPC_Map>,
     VersionedClause<OMPC_NoWait>,
     VersionedClause<OMPC_Depend>,
     VersionedClause<OMPC_Private>,
     VersionedClause<OMPC_FirstPrivate>,
     VersionedClause<OMPC_Default>,
     VersionedClause<OMPC_Shared>,
     VersionedClause<OMPC_Reduction>,
     VersionedClause<OMPC_IsDevicePtr>,
     VersionedClause<OMPC_HasDeviceAddr, 51>,
     VersionedClause<OMPC_Allocate>,
     VersionedClause<OMPC_UsesAllocators, 50>,
     VersionedClause<OMPC_OMPX_Attribute>,
   ];
   let allowedOnceClauses = [
     VersionedClause<OMPC_DefaultMap>,
     VersionedClause<OMPC_Device>,
-    VersionedClause<OMPC_If>,
     VersionedClause<OMPC_NumThreads>,
     VersionedClause<OMPC_ProcBind>,
     VersionedClause<OMPC_OMPX_DynCGroupMem>,
   ];
 }
 def OMP_TargetParallelFor : Directive<"target parallel for"> {
   let allowedClauses = [
     VersionedClause<OMPC_If>,
let allowedClauses = [
     VersionedClause<OMPC_OMPX_Attribute>,
   ];
   let allowedOnceClauses = [
     VersionedClause<OMPC_OMPX_DynCGroupMem>,
   ];
 }
 def OMP_TargetParallelDo : Directive<"target parallel do"> {
   let allowedClauses = [
+    VersionedClause<OMPC_If>,
     VersionedClause<OMPC_Map>,
     VersionedClause<OMPC_Private>,
     VersionedClause<OMPC_FirstPrivate>,
     VersionedClause<OMPC_LastPrivate>,
     VersionedClause<OMPC_Depend>,
     VersionedClause<OMPC_Shared>,
     VersionedClause<OMPC_Reduction>,
     VersionedClause<OMPC_Linear>,
     VersionedClause<OMPC_IsDevicePtr>,
     VersionedClause<OMPC_HasDeviceAddr, 51>,
     VersionedClause<OMPC_Allocator>,
     VersionedClause<OMPC_UsesAllocators>,
     VersionedClause<OMPC_Default>,
     VersionedClause<OMPC_Copyin>
   ];
   let allowedOnceClauses = [
-    VersionedClause<OMPC_If>,
     VersionedClause<OMPC_NumThreads>,
     VersionedClause<OMPC_ProcBind>,
     VersionedClause<OMPC_Device>,
     VersionedClause<OMPC_DefaultMap>,
     VersionedClause<OMPC_Schedule>,
     VersionedClause<OMPC_Collapse>,
     VersionedClause<OMPC_Ordered>,
     VersionedClause<OMPC_NoWait>,
let allowedClauses = [
     VersionedClause<OMPC_Allocate>,
     VersionedClause<OMPC_NonTemporal, 50>,
     VersionedClause<OMPC_Order, 50>,
     VersionedClause<OMPC_OMPX_Attribute>,
   ];
 }
 def OMP_ParallelDoSimd : Directive<"parallel do simd"> {
   let allowedClauses = [
+    VersionedClause<OMPC_If>,
     VersionedClause<OMPC_Default>,
     VersionedClause<OMPC_Private>,
     VersionedClause<OMPC_FirstPrivate>,
     VersionedClause<OMPC_Shared>,
     VersionedClause<OMPC_Reduction>,
     VersionedClause<OMPC_Copyin>,
     VersionedClause<OMPC_LastPrivate>,
     VersionedClause<OMPC_Linear>,
     VersionedClause<OMPC_Aligned>,
     VersionedClause<OMPC_Allocate>,
     VersionedClause<OMPC_NonTemporal>,
   ];
   let allowedOnceClauses = [
-    VersionedClause<OMPC_If>,
     VersionedClause<OMPC_NumThreads>,
     VersionedClause<OMPC_ProcBind>,
     VersionedClause<OMPC_Schedule>,
     VersionedClause<OMPC_Ordered>,
     VersionedClause<OMPC_Collapse>,
     VersionedClause<OMPC_SafeLen>,
     VersionedClause<OMPC_SimdLen>,
     VersionedClause<OMPC_Order, 50>
let allowedClauses = [
     VersionedClause<OMPC_ProcBind>,
     VersionedClause<OMPC_Allocate>,
     VersionedClause<OMPC_Filter>,
     VersionedClause<OMPC_OMPX_Attribute>,
   ];
 }
 def OMP_ParallelSections : Directive<"parallel sections"> {
   let allowedClauses = [
-    VersionedClause<OMPC_If>,
     VersionedClause<OMPC_Default>,
     VersionedClause<OMPC_ProcBind>,
     VersionedClause<OMPC_Private>,
     VersionedClause<OMPC_FirstPrivate>,
     VersionedClause<OMPC_Shared>,
     VersionedClause<OMPC_Reduction>,
     VersionedClause<OMPC_Copyin>,
     VersionedClause<OMPC_LastPrivate>,
     VersionedClause<OMPC_Allocate>,
     VersionedClause<OMPC_OMPX_Attribute>,
   ];
   let allowedOnceClauses = [
+    VersionedClause<OMPC_If>,
     VersionedClause<OMPC_NumThreads>
   ];
 }
 def OMP_ForSimd : Directive<"for simd"> {
   let allowedClauses = [
     VersionedClause<OMPC_Private>,
     VersionedClause<OMPC_FirstPrivate>,
     VersionedClause<OMPC_LastPrivate>,
let allowedClauses = [
     VersionedClause<OMPC_Aligned>,
     VersionedClause<OMPC_Private>,
     VersionedClause<OMPC_FirstPrivate>,
     VersionedClause<OMPC_LastPrivate>,
     VersionedClause<OMPC_Linear>,
     VersionedClause<OMPC_Reduction>
   ];
   let allowedOnceClauses = [
+    VersionedClause<OMPC_If>,
     VersionedClause<OMPC_Schedule>,
     VersionedClause<OMPC_Collapse>,
     VersionedClause<OMPC_Ordered>,
     VersionedClause<OMPC_SafeLen>,
     VersionedClause<OMPC_SimdLen>,
     VersionedClause<OMPC_NoWait>,
     VersionedClause<OMPC_Order, 50>
   ];
def OMP_TaskLoop : Directive<"taskloop"> {
   ];
   let allowedExclusiveClauses = [
     VersionedClause<OMPC_GrainSize>,
     VersionedClause<OMPC_NumTasks>
   ];
 }
 def OMP_TaskLoopSimd : Directive<"taskloop simd"> {
   let allowedClauses = [
+    VersionedClause<OMPC_If>,
     VersionedClause<OMPC_Aligned>,
     VersionedClause<OMPC_Allocate>,
     VersionedClause<OMPC_Default>,
     VersionedClause<OMPC_FirstPrivate>,
     VersionedClause<OMPC_InReduction>,
     VersionedClause<OMPC_LastPrivate>,
     VersionedClause<OMPC_Linear>,
     VersionedClause<OMPC_Mergeable>,
     VersionedClause<OMPC_NoGroup>,
     VersionedClause<OMPC_NonTemporal, 50>,
     VersionedClause<OMPC_Private>,
     VersionedClause<OMPC_Reduction>,
     VersionedClause<OMPC_Shared>,
     VersionedClause<OMPC_Untied>
   ];
   let allowedOnceClauses = [
-    VersionedClause<OMPC_If>,
     VersionedClause<OMPC_Collapse>,
     VersionedClause<OMPC_SafeLen>,
     VersionedClause<OMPC_SimdLen>,
     VersionedClause<OMPC_Final>,
     VersionedClause<OMPC_Priority>,
     VersionedClause<OMPC_Order, 50>
   ];
   let allowedExclusiveClauses = [
let allowedClauses = [
     VersionedClause<OMPC_Allocate>,
     VersionedClause<OMPC_NonTemporal>,
     VersionedClause<OMPC_Order, 50>,
     VersionedClause<OMPC_UsesAllocators>
   ];
 }
 def OMP_TargetSimd : Directive<"target simd"> {
   let allowedClauses = [
+    VersionedClause<OMPC_If>,
     VersionedClause<OMPC_Aligned>,
     VersionedClause<OMPC_Allocate>,
     VersionedClause<OMPC_Depend>,
     VersionedClause<OMPC_FirstPrivate>,
     VersionedClause<OMPC_IsDevicePtr>,
     VersionedClause<OMPC_HasDeviceAddr, 51>,
     VersionedClause<OMPC_LastPrivate>,
     VersionedClause<OMPC_Linear>,
     VersionedClause<OMPC_Map>,
     VersionedClause<OMPC_NonTemporal, 50>,
     VersionedClause<OMPC_NoWait>,
     VersionedClause<OMPC_Private>,
     VersionedClause<OMPC_Reduction>,
     VersionedClause<OMPC_Shared>,
     VersionedClause<OMPC_UsesAllocators, 50>,
     VersionedClause<OMPC_OMPX_Attribute>,
   ];
   let allowedOnceClauses = [
     VersionedClause<OMPC_Collapse>,
     VersionedClause<OMPC_SafeLen>,
     VersionedClause<OMPC_SimdLen>,
-    VersionedClause<OMPC_If>,
     VersionedClause<OMPC_NumThreads>,
     VersionedClause<OMPC_ProcBind>,
     VersionedClause<OMPC_Device>,
     VersionedClause<OMPC_DefaultMap>,
     VersionedClause<OMPC_Schedule>,
     VersionedClause<OMPC_OMPX_DynCGroupMem>,
     VersionedClause<OMPC_Order, 50>
   ];
 }
 def OMP_TeamsDistribute : Directive<"teams distribute"> {
   let allowedClauses = [
     VersionedClause<OMPC_Default>,
     VersionedClause<OMPC_Private>,
     VersionedClause<OMPC_FirstPrivate>,
     VersionedClause<OMPC_Shared>,
     VersionedClause<OMPC_Reduction>,
     VersionedClause<OMPC_NumTeams>,
     VersionedClause<OMPC_ThreadLimit>,
     VersionedClause<OMPC_LastPrivate>,
     VersionedClause<OMPC_Collapse>,
     VersionedClause<OMPC_DistSchedule>,
     VersionedClause<OMPC_Allocate>,
     VersionedClause<OMPC_OMPX_Attribute>,
   ];
+  let allowedOnceClauses = [
+    VersionedClause<OMPC_If>
+  ];
 }
 def OMP_TeamsDistributeSimd : Directive<"teams distribute simd"> {
   let allowedClauses = [
+    VersionedClause<OMPC_If, 50>,
     VersionedClause<OMPC_Aligned>,
     VersionedClause<OMPC_Allocate>,
     VersionedClause<OMPC_FirstPrivate>,
     VersionedClause<OMPC_LastPrivate>,
     VersionedClause<OMPC_Linear>,
     VersionedClause<OMPC_NonTemporal, 50>,
     VersionedClause<OMPC_Private>,
     VersionedClause<OMPC_Reduction>,
     VersionedClause<OMPC_Shared>,
     VersionedClause<OMPC_OMPX_Attribute>,
   ];
   let allowedOnceClauses = [
     VersionedClause<OMPC_Collapse>,
     VersionedClause<OMPC_Default>,
     VersionedClause<OMPC_DistSchedule>,
-    VersionedClause<OMPC_If, 50>,
     VersionedClause<OMPC_NumTeams>,
     VersionedClause<OMPC_SafeLen>,
     VersionedClause<OMPC_SimdLen>,
     VersionedClause<OMPC_ThreadLimit>,
     VersionedClause<OMPC_Order, 50>
   ];
 }
 
let allowedClauses = [
     VersionedClause<OMPC_NonTemporal, 50>,
     VersionedClause<OMPC_Order, 50>,
     VersionedClause<OMPC_OMPX_Attribute>,
   ];
 }
 def OMP_TeamsDistributeParallelDoSimd :
     Directive<"teams distribute parallel do simd"> {
   let allowedClauses = [
+    VersionedClause<OMPC_If>,
     VersionedClause<OMPC_Private>,
     VersionedClause<OMPC_FirstPrivate>,
     VersionedClause<OMPC_LastPrivate>,
     VersionedClause<OMPC_Allocate>,
     VersionedClause<OMPC_Shared>,
     VersionedClause<OMPC_Reduction>,
     VersionedClause<OMPC_Linear>,
     VersionedClause<OMPC_Aligned>,
     VersionedClause<OMPC_NonTemporal>
   ];
   let allowedOnceClauses = [
     VersionedClause<OMPC_Default>,
     VersionedClause<OMPC_NumTeams>,
     VersionedClause<OMPC_ThreadLimit>,
     VersionedClause<OMPC_Collapse>,
     VersionedClause<OMPC_DistSchedule>,
     VersionedClause<OMPC_NumThreads>,
     VersionedClause<OMPC_ProcBind>,
     VersionedClause<OMPC_Schedule>,
     VersionedClause<OMPC_SafeLen>,
     VersionedClause<OMPC_SimdLen>,
-    VersionedClause<OMPC_If>,
     VersionedClause<OMPC_Order, 50>
   ];
 }
 def OMP_TeamsDistributeParallelFor :
     Directive<"teams distribute parallel for"> {
   let allowedClauses = [
     VersionedClause<OMPC_FirstPrivate>,
     VersionedClause<OMPC_LastPrivate>,
let allowedClauses = [
     VersionedClause<OMPC_Allocate>,
     VersionedClause<OMPC_Order, 50>,
     VersionedClause<OMPC_OMPX_Attribute>,
   ];
 }
 def OMP_TeamsDistributeParallelDo :
     Directive<"teams distribute parallel do"> {
   let allowedClauses = [
+    VersionedClause<OMPC_If>,
     VersionedClause<OMPC_Private>,
     VersionedClause<OMPC_FirstPrivate>,
     VersionedClause<OMPC_LastPrivate>,
     VersionedClause<OMPC_Shared>,
     VersionedClause<OMPC_Reduction>,
     VersionedClause<OMPC_Allocate>,
     VersionedClause<OMPC_Copyin>,
     VersionedClause<OMPC_Linear>
   ];
 let allowedOnceClauses = [
     VersionedClause<OMPC_NumTeams>,
     VersionedClause<OMPC_ThreadLimit>,
     VersionedClause<OMPC_Default>,
     VersionedClause<OMPC_Collapse>,
     VersionedClause<OMPC_DistSchedule>,
     VersionedClause<OMPC_Ordered>,
-    VersionedClause<OMPC_If>,
     VersionedClause<OMPC_NumThreads>,
     VersionedClause<OMPC_ProcBind>,
     VersionedClause<OMPC_Schedule>,
     VersionedClause<OMPC_Order, 50>
   ];
 }
 def OMP_TargetTeams : Directive<"target teams"> {
   let allowedClauses = [
def OMP_TargetTeamsDistributeParallelForSimd :
   ];
   let allowedOnceClauses = [
     VersionedClause<OMPC_OMPX_DynCGroupMem>,
   ];
 }
 def OMP_TargetTeamsDistributeParallelDoSimd :
     Directive<"target teams distribute parallel do simd"> {
   let allowedClauses = [
+    VersionedClause<OMPC_If>,
     VersionedClause<OMPC_Map>,
     VersionedClause<OMPC_Private>,
     VersionedClause<OMPC_Depend>,
     VersionedClause<OMPC_FirstPrivate>,
     VersionedClause<OMPC_IsDevicePtr>,
     VersionedClause<OMPC_HasDeviceAddr, 51>,
     VersionedClause<OMPC_Reduction>,
     VersionedClause<OMPC_Allocate>,
     VersionedClause<OMPC_UsesAllocators>,
     VersionedClause<OMPC_Shared>,
     VersionedClause<OMPC_LastPrivate>,
     VersionedClause<OMPC_Copyin>,
     VersionedClause<OMPC_Linear>,
     VersionedClause<OMPC_Ordered>,
     VersionedClause<OMPC_Aligned>,
     VersionedClause<OMPC_NonTemporal>
   ];
   let allowedOnceClauses = [
-    VersionedClause<OMPC_If>,
     VersionedClause<OMPC_Device>,
     VersionedClause<OMPC_NoWait>,
     VersionedClause<OMPC_DefaultMap>,
     VersionedClause<OMPC_Default>,
     VersionedClause<OMPC_NumTeams>,
     VersionedClause<OMPC_ThreadLimit>,
     VersionedClause<OMPC_Collapse>,
     VersionedClause<OMPC_DistSchedule>,
let allowedOnceClauses = [
     VersionedClause<OMPC_Default>,
     VersionedClause<OMPC_NumTeams>,
     VersionedClause<OMPC_Order>,
     VersionedClause<OMPC_ThreadLimit>,
   ];
 }
 def OMP_target_teams_loop : Directive<"target teams loop"> {
   let allowedClauses = [
+    VersionedClause<OMPC_If>,
     VersionedClause<OMPC_Allocate>,
     VersionedClause<OMPC_Depend>,
     VersionedClause<OMPC_DefaultMap>,
     VersionedClause<OMPC_Device>,
     VersionedClause<OMPC_FirstPrivate>,
     VersionedClause<OMPC_IsDevicePtr>,
     VersionedClause<OMPC_HasDeviceAddr, 51>,
     VersionedClause<OMPC_LastPrivate>,
     VersionedClause<OMPC_Map>,
     VersionedClause<OMPC_Private>,
     VersionedClause<OMPC_Reduction>,
     VersionedClause<OMPC_Shared>,
     VersionedClause<OMPC_UsesAllocators, 50>,
     VersionedClause<OMPC_OMPX_Attribute>,
   ];
   let allowedOnceClauses = [
     VersionedClause<OMPC_Bind, 50>,
     VersionedClause<OMPC_Collapse>,
     VersionedClause<OMPC_Default>,
-    VersionedClause<OMPC_If>,
     VersionedClause<OMPC_NoWait>,
     VersionedClause<OMPC_NumTeams>,
     VersionedClause<OMPC_Order>,
     VersionedClause<OMPC_ThreadLimit>,
     VersionedClause<OMPC_OMPX_DynCGroupMem>,
   ];
 }
 def OMP_parallel_loop : Directive<"parallel loop"> {
let allowedOnceClauses = [
     VersionedClause<OMPC_If>,
     VersionedClause<OMPC_NumThreads>,
     VersionedClause<OMPC_Order>,
     VersionedClause<OMPC_ProcBind>,
   ];
 }
 def OMP_target_parallel_loop : Directive<"target parallel loop"> {
   let allowedClauses = [
+    VersionedClause<OMPC_If>,
     VersionedClause<OMPC_Allocate>,
     VersionedClause<OMPC_Copyin>,
     VersionedClause<OMPC_Depend>,
     VersionedClause<OMPC_Device>,
     VersionedClause<OMPC_FirstPrivate>,
     VersionedClause<OMPC_IsDevicePtr>,
     VersionedClause<OMPC_HasDeviceAddr, 51>,
     VersionedClause<OMPC_LastPrivate>,
     VersionedClause<OMPC_Map>,
     VersionedClause<OMPC_Private>,
     VersionedClause<OMPC_Reduction>,
     VersionedClause<OMPC_Shared>,
     VersionedClause<OMPC_UsesAllocators, 50>,
     VersionedClause<OMPC_OMPX_Attribute>,
   ];
   let allowedOnceClauses = [
     VersionedClause<OMPC_Bind, 50>,
     VersionedClause<OMPC_Collapse>,
     VersionedClause<OMPC_Default>,
     VersionedClause<OMPC_DefaultMap>,
-    VersionedClause<OMPC_If>,
     VersionedClause<OMPC_NoWait>,
     VersionedClause<OMPC_NumThreads>,
     VersionedClause<OMPC_Order>,
     VersionedClause<OMPC_ProcBind>,
     VersionedClause<OMPC_OMPX_DynCGroupMem>,
   ];
 }
 def OMP_Metadirective : Directive<"metadirective"> {
   let allowedClauses = [VersionedClause<OMPC_When>];
   let allowedOnceClauses = [VersionedClause<OMPC_Default>];
 }
 def OMP_Unknown : Directive<"unknown"> {
   let isDefault = true;
 }