[flang][OpenMP] Parser support for Target directive and Device clause

[NimishMishra]

Summary

This patch adds parser support for device clause on target directive.

Co-authored-by: Sesha Kalyur <[e-mail]>

[NimishMishra]

Debian failure is due to test failures unrelated to this patch.

[shraiysh]

LGTM. Please wait for atleast one more review.

[NimishMishra]

Ping for review!

[kiranchandramohan]

LGTM.

Can you add some more information to the commit message/summary detailing which revision of the standard the device clause appeared first, and what are the options for this clause.

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

#include "llvm/Frontend/OpenMP/OMP.inc"
   NODE(parser, OmpReductionCombiner)
   NODE(OmpReductionCombiner, FunctionCombiner)
   NODE(parser, OmpReductionInitializerClause)
   NODE(parser, OmpReductionOperator)
   NODE(parser, OmpAllocateClause)
   NODE(OmpAllocateClause, Allocator)
   NODE(parser, OmpScheduleClause)
   NODE_ENUM(OmpScheduleClause, ScheduleType)
+  NODE(parser, OmpDeviceClause)
+  NODE_ENUM(OmpDeviceClause, DeviceModifier)
   NODE(parser, OmpScheduleModifier)
   NODE(OmpScheduleModifier, Modifier1)
   NODE(OmpScheduleModifier, Modifier2)
   NODE(parser, OmpScheduleModifierType)
   NODE_ENUM(OmpScheduleModifierType, ModType)
   NODE(parser, OmpSectionBlocks)
   NODE(parser, OmpSectionsDirective)
   NODE(parser, OmpSimpleStandaloneDirective)

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

 struct OmpScheduleClause {
   TUPLE_CLASS_BOILERPLATE(OmpScheduleClause);
   ENUM_CLASS(ScheduleType, Static, Dynamic, Guided, Auto, Runtime)
   std::tuple<std::optional<OmpScheduleModifier>, ScheduleType,
       std::optional<ScalarIntExpr>>
       t;
 };
 
+// device([ device-modifier :] scalar-integer-expression)
+struct OmpDeviceClause {
+  TUPLE_CLASS_BOILERPLATE(OmpDeviceClause);
+  ENUM_CLASS(DeviceModifier, Ancestor, Device_Num)
+  std::tuple<std::optional<DeviceModifier>, ScalarIntExpr> t;
+};
+
 // 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)
   std::tuple<std::optional<DirectiveNameModifier>, ScalarLogicalExpr> t;
 };
 

flang/lib/Parser/openmp-parsers.cpp

 TYPE_PARSER(construct<OmpScheduleClause>(maybe(Parser<OmpScheduleModifier>{}),
     "STATIC" >> pure(OmpScheduleClause::ScheduleType::Static) ||
         "DYNAMIC" >> pure(OmpScheduleClause::ScheduleType::Dynamic) ||
         "GUIDED" >> pure(OmpScheduleClause::ScheduleType::Guided) ||
         "AUTO" >> pure(OmpScheduleClause::ScheduleType::Auto) ||
         "RUNTIME" >> pure(OmpScheduleClause::ScheduleType::Runtime),
     maybe("," >> scalarIntExpr)))
 
+// device([ device-modifier :] scalar-integer-expression)
+TYPE_PARSER(construct<OmpDeviceClause>(
+    maybe(
+        ("ANCESTOR" >> pure(OmpDeviceClause::DeviceModifier::Ancestor) ||
+            "DEVICE_NUM" >> pure(OmpDeviceClause::DeviceModifier::Device_Num)) /
+        ":"),
+    scalarIntExpr))
+
 // 2.12 IF (directive-name-modifier: scalar-logical-expr)
 TYPE_PARSER(construct<OmpIfClause>(
     maybe(
         ("PARALLEL" >> pure(OmpIfClause::DirectiveNameModifier::Parallel) ||
             "TARGET ENTER DATA" >>
                 pure(OmpIfClause::DirectiveNameModifier::TargetEnterData) ||
             "TARGET EXIT DATA" >>
                 pure(OmpIfClause::DirectiveNameModifier::TargetExitData) ||
"COPYPRIVATE" >> construct<OmpClause>(construct<OmpClause::Copyprivate>(
                          (parenthesized(Parser<OmpObjectList>{})))) ||
     "DEFAULT"_id >> construct<OmpClause>(construct<OmpClause::Default>(
                         parenthesized(Parser<OmpDefaultClause>{}))) ||
     "DEFAULTMAP" >> construct<OmpClause>(construct<OmpClause::Defaultmap>(
                         parenthesized(Parser<OmpDefaultmapClause>{}))) ||
     "DEPEND" >> construct<OmpClause>(construct<OmpClause::Depend>(
                     parenthesized(Parser<OmpDependClause>{}))) ||
     "DEVICE" >> construct<OmpClause>(construct<OmpClause::Device>(
-                    parenthesized(scalarIntExpr))) ||
+                    parenthesized(Parser<OmpDeviceClause>{}))) ||
     "DIST_SCHEDULE" >>
         construct<OmpClause>(construct<OmpClause::DistSchedule>(
             parenthesized("STATIC" >> maybe("," >> scalarIntExpr)))) ||
     "FINAL" >> construct<OmpClause>(construct<OmpClause::Final>(
                    parenthesized(scalarLogicalExpr))) ||
     "FIRSTPRIVATE" >> construct<OmpClause>(construct<OmpClause::Firstprivate>(
                           parenthesized(Parser<OmpObjectList>{}))) ||
     "FROM" >> construct<OmpClause>(construct<OmpClause::From>(

flang/lib/Parser/unparse.cpp

void Unparse(const OmpScheduleModifier &x) {
     Walk(std::get<OmpScheduleModifier::Modifier1>(x.t));
     Walk(",", std::get<std::optional<OmpScheduleModifier::Modifier2>>(x.t));
   }
   void Unparse(const OmpScheduleClause &x) {
     Walk(std::get<std::optional<OmpScheduleModifier>>(x.t), ":");
     Walk(std::get<OmpScheduleClause::ScheduleType>(x.t));
     Walk(",", std::get<std::optional<ScalarIntExpr>>(x.t));
   }
+  void Unparse(const OmpDeviceClause &x) {
+    Walk(std::get<std::optional<OmpDeviceClause::DeviceModifier>>(x.t), ":");
+    Walk(std::get<ScalarIntExpr>(x.t));
+  }
   void Unparse(const OmpAlignedClause &x) {
     Walk(std::get<std::list<Name>>(x.t), ",");
     Walk(std::get<std::optional<ScalarIntConstantExpr>>(x.t));
   }
   void Unparse(const OmpIfClause &x) {
     Walk(std::get<std::optional<OmpIfClause::DirectiveNameModifier>>(x.t), ":");
     Walk(std::get<ScalarLogicalExpr>(x.t));
   }
#define WALK_NESTED_ENUM(CLASS, ENUM) \
   WALK_NESTED_ENUM(OmpDefaultClause, Type) // OMP DEFAULT
   WALK_NESTED_ENUM(OmpDefaultmapClause, ImplicitBehavior) // OMP DEFAULTMAP
   WALK_NESTED_ENUM(OmpDefaultmapClause, VariableCategory) // OMP DEFAULTMAP
   WALK_NESTED_ENUM(OmpScheduleModifierType, ModType) // OMP schedule-modifier
   WALK_NESTED_ENUM(OmpLinearModifier, Type) // OMP linear-modifier
   WALK_NESTED_ENUM(OmpDependenceType, Type) // OMP dependence-type
   WALK_NESTED_ENUM(OmpMapType, Type) // OMP map-type
   WALK_NESTED_ENUM(OmpScheduleClause, ScheduleType) // OMP schedule-type
+  WALK_NESTED_ENUM(OmpDeviceClause, DeviceModifier) // OMP device modifier
   WALK_NESTED_ENUM(OmpIfClause, DirectiveNameModifier) // OMP directive-modifier
   WALK_NESTED_ENUM(OmpCancelType, Type) // OMP cancel-type
 #undef WALK_NESTED_ENUM
 
   void Done() const { CHECK(indent_ == 0); }
 
 private:
   void Put(char);

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

 CHECK_SIMPLE_CLAUSE(CancellationConstructType, OMPC_cancellation_construct_type)
 
 CHECK_REQ_SCALAR_INT_CLAUSE(Grainsize, OMPC_grainsize)
 CHECK_REQ_SCALAR_INT_CLAUSE(NumTasks, OMPC_num_tasks)
 CHECK_REQ_SCALAR_INT_CLAUSE(NumTeams, OMPC_num_teams)
 CHECK_REQ_SCALAR_INT_CLAUSE(NumThreads, OMPC_num_threads)
 CHECK_REQ_SCALAR_INT_CLAUSE(Priority, OMPC_priority)
 CHECK_REQ_SCALAR_INT_CLAUSE(ThreadLimit, OMPC_thread_limit)
-CHECK_REQ_SCALAR_INT_CLAUSE(Device, OMPC_device)
 
 CHECK_REQ_CONSTANT_SCALAR_INT_CLAUSE(Collapse, OMPC_collapse)
 CHECK_REQ_CONSTANT_SCALAR_INT_CLAUSE(Safelen, OMPC_safelen)
 CHECK_REQ_CONSTANT_SCALAR_INT_CLAUSE(Simdlen, OMPC_simdlen)
 
 // Restrictions specific to each clause are implemented apart from the
 // generalized restrictions.
 void OmpStructureChecker::Enter(const parser::OmpClause::Reduction &x) {
if (ScheduleModifierHasType(scheduleClause,
           kind != parser::OmpScheduleClause::ScheduleType::Guided) {
         context_.Say(GetContext().clauseSource,
             "The NONMONOTONIC modifier can only be specified with "
             "SCHEDULE(DYNAMIC) or SCHEDULE(GUIDED)"_err_en_US);
       }
     }
   }
 }
-
+void OmpStructureChecker::Enter(const parser::OmpClause::Device &x) {
+  CheckAllowed(llvm::omp::Clause::OMPC_device);
+  const parser::OmpDeviceClause &deviceClause = x.v;
+  const auto &device{std::get<1>(deviceClause.t)};
+  RequiresPositiveParameter(
+      llvm::omp::Clause::OMPC_device, device, "device expression");
+}
 void OmpStructureChecker::Enter(const parser::OmpClause::Depend &x) {
   CheckAllowed(llvm::omp::Clause::OMPC_depend);
   if (const auto *inOut{std::get_if<parser::OmpDependClause::InOut>(&x.v.u)}) {
     const auto &designators{std::get<std::list<parser::Designator>>(inOut->t)};
     for (const auto &ele : designators) {
       if (const auto *dataRef{std::get_if<parser::DataRef>(&ele.u)}) {
         CheckDependList(*dataRef);
         if (const auto *arr{

flang/test/Parser/omp_target_device_parse.f90

+! RUN: %flang_fc1 -fdebug-unparse-no-sema -fopenmp %s | FileCheck --ignore-case %s
+! RUN: %flang_fc1 -fdebug-dump-parse-tree -fopenmp %s | FileCheck --check-prefix="PARSE-TREE" %s
+! Checks the parsing of Openmp 5.0 Target Device constructs
+!
+PROGRAM main
+  USE OMP_LIB
+  IMPLICIT NONE
+  INTEGER :: X, Y
+  INTEGER :: M = 1
+
+
+!------------------------------------------------------
+! Check Device clause with a constant argument
+!------------------------------------------------------
+!CHECK: !$OMP TARGET DEVICE(1)
+!$OMP TARGET DEVICE(1)
+  M = M + 1
+!CHECK: !$OMP END TARGET
+!$OMP END TARGET
+
+!PARSE-TREE: OmpBeginBlockDirective
+!PARSE-TREE: OmpBlockDirective -> llvm::omp::Directive = target
+!PARSE-TREE: OmpClauseList -> OmpClause -> Device -> OmpDeviceClause
+!PARSE-TREE: Scalar -> Integer -> Expr = '1_4'
+!PARSE-TREE: LiteralConstant -> IntLiteralConstant = '1'
+!PARSE-TREE: OmpEndBlockDirective
+!PARSE-TREE: OmpBlockDirective -> llvm::omp::Directive = target
+!PARSE-TREE: OmpClauseList ->
+
+!------------------------------------------------------
+! Check Device clause with a constant integer expression argument
+!------------------------------------------------------
+!CHECK: !$OMP TARGET DEVICE(2-1)
+!$OMP TARGET DEVICE(2-1)
+  M = M + 1
+!CHECK: !$OMP END TARGET
+!$OMP END TARGET
+
+!PARSE-TREE: OmpBeginBlockDirective
+!PARSE-TREE: OmpBlockDirective -> llvm::omp::Directive = target
+!PARSE-TREE: OmpClauseList -> OmpClause -> Device -> OmpDeviceClause
+!PARSE-TREE: Scalar -> Integer -> Expr = '1_4'
+!PARSE-TREE: Subtract
+!PARSE-TREE: Expr = '2_4'
+!PARSE-TREE: LiteralConstant -> IntLiteralConstant = '2'
+!PARSE-TREE: Expr = '1_4'
+!PARSE-TREE: LiteralConstant -> IntLiteralConstant = '1'
+!PARSE-TREE: OmpEndBlockDirective
+!PARSE-TREE: OmpBlockDirective -> llvm::omp::Directive = target
+!PARSE-TREE: OmpClauseList ->
+
+
+!------------------------------------------------------
+! Check Device clause with a variable argument
+!------------------------------------------------------
+!CHECK: !$OMP TARGET DEVICE(X)
+!$OMP TARGET DEVICE(X)
+  M = M + 1
+!CHECK: !$OMP END TARGET
+!$OMP END TARGET
+
+!PARSE-TREE: OmpBeginBlockDirective
+!PARSE-TREE: OmpBlockDirective -> llvm::omp::Directive = target
+!PARSE-TREE: OmpClauseList -> OmpClause -> Device -> OmpDeviceClause
+!PARSE-TREE: Scalar -> Integer -> Expr = 'x'
+!PARSE-TREE: Designator -> DataRef -> Name = 'x'
+!PARSE-TREE: OmpEndBlockDirective
+!PARSE-TREE: OmpBlockDirective -> llvm::omp::Directive = target
+!PARSE-TREE: OmpClauseList ->
+
+
+!------------------------------------------------------
+! Check Device clause with an variable integer expression
+!------------------------------------------------------
+!CHECK: !$OMP TARGET DEVICE(X+Y)
+!$OMP TARGET DEVICE(X+Y)
+  M = M + 1
+!CHECK: !$OMP END TARGET
+!$OMP END TARGET
+
+!PARSE-TREE: OmpBeginBlockDirective
+!PARSE-TREE: OmpBlockDirective -> llvm::omp::Directive = target
+!PARSE-TREE: OmpClauseList -> OmpClause -> Device -> OmpDeviceClause
+!PARSE-TREE: Scalar -> Integer -> Expr = 'x+y'
+!PARSE-TREE: Add
+!PARSE-TREE: Expr = 'x'
+!PARSE-TREE: Designator -> DataRef -> Name = 'x'
+!PARSE-TREE: Expr = 'y'
+!PARSE-TREE: Designator -> DataRef -> Name = 'y'
+!PARSE-TREE: OmpEndBlockDirective
+!PARSE-TREE: OmpBlockDirective -> llvm::omp::Directive = target
+!PARSE-TREE: OmpClauseList ->
+
+!------------------------------------------------------
+! Check Device Ancestor clause with a constant argument
+!------------------------------------------------------
+!CHECK: !$OMP TARGET DEVICE(ANCESTOR:1)
+!$OMP TARGET DEVICE(ANCESTOR: 1)
+  M = M + 1
+!CHECK: !$OMP END TARGET
+!$OMP END TARGET
+
+!PARSE-TREE: OmpBeginBlockDirective
+!PARSE-TREE: OmpBlockDirective -> llvm::omp::Directive = target
+!PARSE-TREE: OmpClauseList -> OmpClause -> Device -> OmpDeviceClause
+!PARSE-TREE: DeviceModifier = Ancestor
+!PARSE-TREE: Scalar -> Integer -> Expr = '1_4'
+!PARSE-TREE: LiteralConstant -> IntLiteralConstant = '1'
+!PARSE-TREE: OmpEndBlockDirective
+!PARSE-TREE: OmpBlockDirective -> llvm::omp::Directive = target
+!PARSE-TREE: OmpClauseList ->
+
+
+!--------------------------------------------------------
+! Check Device Devive-Num clause with a constant argument
+!--------------------------------------------------------
+!CHECK: !$OMP TARGET DEVICE(DEVICE_NUM:2)
+!$OMP TARGET DEVICE(DEVICE_NUM: 2)
+  M = M + 1
+!CHECK: !$OMP END TARGET
+!$OMP END TARGET
+
+!PARSE-TREE: OmpBeginBlockDirective
+!PARSE-TREE: OmpBlockDirective -> llvm::omp::Directive = target
+!PARSE-TREE: OmpClauseList -> OmpClause -> Device -> OmpDeviceClause
+!PARSE-TREE: DeviceModifier = Device_Num
+!PARSE-TREE: Scalar -> Integer -> Expr = '2_4'
+!PARSE-TREE: LiteralConstant -> IntLiteralConstant = '2'
+!PARSE-TREE: OmpEndBlockDirective
+!PARSE-TREE: OmpBlockDirective -> llvm::omp::Directive = target
+!PARSE-TREE: OmpClauseList ->
+
+
+!-------------------------------------------------------------------
+! Check Device Ancestor clause with a variable expression argument
+!-------------------------------------------------------------------
+!CHECK: !$OMP TARGET DEVICE(ANCESTOR:X+Y)
+!$OMP TARGET DEVICE(ANCESTOR: X + Y)
+  M = M + 1
+!CHECK: !$OMP END TARGET
+!$OMP END TARGET
+
+!PARSE-TREE: OmpBeginBlockDirective
+!PARSE-TREE: OmpBlockDirective -> llvm::omp::Directive = target
+!PARSE-TREE: OmpClauseList -> OmpClause -> Device -> OmpDeviceClause
+!PARSE-TREE: DeviceModifier = Ancestor
+!PARSE-TREE: Scalar -> Integer -> Expr = 'x+y'
+!PARSE-TREE: Add
+!PARSE-TREE: Expr = 'x'
+!PARSE-TREE: Designator -> DataRef -> Name = 'x'
+!PARSE-TREE: Expr = 'y'
+!PARSE-TREE: Designator -> DataRef -> Name = 'y'
+!PARSE-TREE: OmpEndBlockDirective
+!PARSE-TREE: OmpBlockDirective -> llvm::omp::Directive = target
+!PARSE-TREE: OmpClauseList ->
+
+
+!-------------------------------------------------------------------
+! Check Device Devive-Num clause with a variable expression argument
+!-------------------------------------------------------------------
+!CHECK: !$OMP TARGET DEVICE(DEVICE_NUM:X-Y)
+!$OMP TARGET DEVICE(DEVICE_NUM: X - Y)
+  M = M + 1
+!CHECK: !$OMP END TARGET
+!$OMP END TARGET
+
+!PARSE-TREE: OmpBeginBlockDirective
+!PARSE-TREE: OmpBlockDirective -> llvm::omp::Directive = target
+!PARSE-TREE: OmpClauseList -> OmpClause -> Device -> OmpDeviceClause
+!PARSE-TREE: DeviceModifier = Device_Num
+!PARSE-TREE: Scalar -> Integer -> Expr = 'x-y'
+!PARSE-TREE: Subtract
+!PARSE-TREE: Expr = 'x'
+!PARSE-TREE: Designator -> DataRef -> Name = 'x'
+!PARSE-TREE: Expr = 'y'
+!PARSE-TREE: Designator -> DataRef -> Name = 'y'
+!PARSE-TREE: OmpEndBlockDirective
+!PARSE-TREE: OmpBlockDirective -> llvm::omp::Directive = target
+END PROGRAM

flang/test/Parser/omp_target_device_unparse.f90

+! RUN: %flang_fc1 -fdebug-unparse-no-sema -fopenmp %s | FileCheck --ignore-case %s
+! Verifies the unparsing of the Openmp Target Device constructs
+PROGRAM main
+    USE OMP_LIB
+    IMPLICIT NONE
+    INTEGER:: X, Y
+    INTEGER:: M = 1
+
+!--------------------------------------------
+! constant argument
+!--------------------------------------------
+!CHECK: !$OMP TARGET DEVICE(0)
+!CHECK: !$OMP END TARGET
+!$OMP TARGET DEVICE(0)
+  M = M + 1
+!$OMP END TARGET
+
+!--------------------------------------------
+! constant expression argument
+!--------------------------------------------
+!CHECK: !$OMP TARGET DEVICE(2+1)
+!CHECK: !$OMP END TARGET
+!$OMP TARGET DEVICE(2+1)
+  M = M + 1
+!$OMP END TARGET
+
+!--------------------------------------------
+! variable argument
+!--------------------------------------------
+!CHECK: !$OMP TARGET DEVICE(X)
+!CHECK: !$OMP END TARGET
+!$OMP TARGET DEVICE(X)
+  M = M + 1
+!$OMP END TARGET
+
+!--------------------------------------------
+! variable expression argument
+!--------------------------------------------
+!CHECK: !$OMP TARGET DEVICE(X-Y)
+!CHECK: !$OMP END TARGET
+!$OMP TARGET DEVICE(X-Y)
+  M = M + 1
+!$OMP END TARGET
+
+!--------------------------------------------
+! Ancestor followed by constant argument
+!--------------------------------------------
+!CHECK: !$OMP TARGET DEVICE(ANCESTOR:0)
+!CHECK: !$OMP END TARGET
+!$OMP TARGET DEVICE(ANCESTOR: 0)
+  M = M + 1
+!$OMP END TARGET
+
+!--------------------------------------------
+! Device_Num followed by constant argument
+!--------------------------------------------
+!CHECK: !$OMP TARGET DEVICE(DEVICE_NUM:1)
+!CHECK: !$OMP END TARGET
+!$OMP TARGET DEVICE(DEVICE_NUM: 1)
+  M = M + 1
+!$OMP END TARGET
+
+!--------------------------------------------
+! Ancestor followed by variable expression argument
+!--------------------------------------------
+!CHECK: !$OMP TARGET DEVICE(ANCESTOR:X+Y)
+!CHECK: !$OMP END TARGET
+!$OMP TARGET DEVICE(ANCESTOR: X + Y)
+  M = M + 1
+!$OMP END TARGET
+
+!--------------------------------------------
+! Device_Num followed by variable expression argument
+!--------------------------------------------
+!CHECK: !$OMP TARGET DEVICE(DEVICE_NUM:X-Y)
+!CHECK: !$OMP END TARGET
+!$OMP TARGET DEVICE(DEVICE_NUM: X - Y)
+  M = M + 1
+!$OMP END TARGET
+END PROGRAM

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

program main
 
   !ERROR: At least one of MAP clause must appear on the TARGET DATA directive
   !$omp target data device(0)
   do i = 1, N
      a = 3.14
   enddo
   !$omp end target data
 
-  !ERROR: The parameter of the DEVICE clause must be a positive integer expression
+  !ERROR: The device expression of the DEVICE clause must be a positive integer expression
   !$omp target enter data map(alloc:A) device(-2)
 
-  !ERROR: The parameter of the DEVICE clause must be a positive integer expression
+  !ERROR: The device expression of the DEVICE clause must be a positive integer expression
   !$omp target exit data map(delete:A) device(-2)
 
   !ERROR: At most one IF clause can appear on the TARGET ENTER DATA directive
   !$omp target enter data map(to:a) if(.true.) if(.false.)
 
   !ERROR: Only the TO, ALLOC map types are permitted for MAP clauses on the TARGET ENTER DATA directive
   !$omp target enter data map(from:a)
 

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

 def OMPC_Release : Clause<"release"> { let clangClass = "OMPReleaseClause"; }
 def OMPC_Relaxed : Clause<"relaxed"> { let clangClass = "OMPRelaxedClause"; }
 def OMPC_Depend : Clause<"depend"> {
   let clangClass = "OMPDependClause";
   let flangClass = "OmpDependClause";
 }
 def OMPC_Device : Clause<"device"> {
   let clangClass = "OMPDeviceClause";
-  let flangClass = "ScalarIntExpr";
+  let flangClass = "OmpDeviceClause";
 }
 def OMPC_Threads : Clause<"threads"> { let clangClass = "OMPThreadsClause"; }
 def OMPC_Simd : Clause<"simd"> { let clangClass = "OMPSIMDClause"; }
 def OMPC_Map : Clause<"map"> {
   let clangClass = "OMPMapClause";
   let flangClass = "OmpMapClause";
 }
 def OMPC_NumTeams : Clause<"num_teams"> {