1 //===--- OpenMPKinds.cpp - Token Kinds Support ----------------------------===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 /// \file
10 /// \brief This file implements the OpenMP enum and support functions.
11 ///
12 //===----------------------------------------------------------------------===//
13 
14 #include "clang/Basic/OpenMPKinds.h"
15 #include "clang/Basic/IdentifierTable.h"
16 #include "llvm/ADT/StringRef.h"
17 #include "llvm/ADT/StringSwitch.h"
18 #include "llvm/Support/ErrorHandling.h"
19 #include <cassert>
20 
21 using namespace clang;
22 
23 OpenMPDirectiveKind clang::getOpenMPDirectiveKind(StringRef Str) {
24   return llvm::StringSwitch<OpenMPDirectiveKind>(Str)
25 #define OPENMP_DIRECTIVE(Name) .Case(#Name, OMPD_##Name)
26 #define OPENMP_DIRECTIVE_EXT(Name, Str) .Case(Str, OMPD_##Name)
27 #include "clang/Basic/OpenMPKinds.def"
28       .Default(OMPD_unknown);
29 }
30 
31 const char *clang::getOpenMPDirectiveName(OpenMPDirectiveKind Kind) {
32   assert(Kind <= OMPD_unknown);
33   switch (Kind) {
34   case OMPD_unknown:
35     return "unknown";
36 #define OPENMP_DIRECTIVE(Name)                                                 \
37   case OMPD_##Name:                                                            \
38     return #Name;
39 #define OPENMP_DIRECTIVE_EXT(Name, Str)                                        \
40   case OMPD_##Name:                                                            \
41     return Str;
42 #include "clang/Basic/OpenMPKinds.def"
43     break;
44   }
45   llvm_unreachable("Invalid OpenMP directive kind");
46 }
47 
48 OpenMPClauseKind clang::getOpenMPClauseKind(StringRef Str) {
49   // 'flush' clause cannot be specified explicitly, because this is an implicit
50   // clause for 'flush' directive. If the 'flush' clause is explicitly specified
51   // the Parser should generate a warning about extra tokens at the end of the
52   // directive.
53   if (Str == "flush")
54     return OMPC_unknown;
55   return llvm::StringSwitch<OpenMPClauseKind>(Str)
56 #define OPENMP_CLAUSE(Name, Class) .Case(#Name, OMPC_##Name)
57 #include "clang/Basic/OpenMPKinds.def"
58       .Case("uniform", OMPC_uniform)
59       .Default(OMPC_unknown);
60 }
61 
62 const char *clang::getOpenMPClauseName(OpenMPClauseKind Kind) {
63   assert(Kind <= OMPC_unknown);
64   switch (Kind) {
65   case OMPC_unknown:
66     return "unknown";
67 #define OPENMP_CLAUSE(Name, Class)                                             \
68   case OMPC_##Name:                                                            \
69     return #Name;
70 #include "clang/Basic/OpenMPKinds.def"
71   case OMPC_uniform:
72     return "uniform";
73   case OMPC_threadprivate:
74     return "threadprivate or thread local";
75   }
76   llvm_unreachable("Invalid OpenMP clause kind");
77 }
78 
79 unsigned clang::getOpenMPSimpleClauseType(OpenMPClauseKind Kind,
80                                           StringRef Str) {
81   switch (Kind) {
82   case OMPC_default:
83     return llvm::StringSwitch<OpenMPDefaultClauseKind>(Str)
84 #define OPENMP_DEFAULT_KIND(Name) .Case(#Name, OMPC_DEFAULT_##Name)
85 #include "clang/Basic/OpenMPKinds.def"
86         .Default(OMPC_DEFAULT_unknown);
87   case OMPC_proc_bind:
88     return llvm::StringSwitch<OpenMPProcBindClauseKind>(Str)
89 #define OPENMP_PROC_BIND_KIND(Name) .Case(#Name, OMPC_PROC_BIND_##Name)
90 #include "clang/Basic/OpenMPKinds.def"
91         .Default(OMPC_PROC_BIND_unknown);
92   case OMPC_schedule:
93     return llvm::StringSwitch<unsigned>(Str)
94 #define OPENMP_SCHEDULE_KIND(Name)                                             \
95   .Case(#Name, static_cast<unsigned>(OMPC_SCHEDULE_##Name))
96 #define OPENMP_SCHEDULE_MODIFIER(Name)                                         \
97   .Case(#Name, static_cast<unsigned>(OMPC_SCHEDULE_MODIFIER_##Name))
98 #include "clang/Basic/OpenMPKinds.def"
99         .Default(OMPC_SCHEDULE_unknown);
100   case OMPC_depend:
101     return llvm::StringSwitch<OpenMPDependClauseKind>(Str)
102 #define OPENMP_DEPEND_KIND(Name) .Case(#Name, OMPC_DEPEND_##Name)
103 #include "clang/Basic/OpenMPKinds.def"
104         .Default(OMPC_DEPEND_unknown);
105   case OMPC_linear:
106     return llvm::StringSwitch<OpenMPLinearClauseKind>(Str)
107 #define OPENMP_LINEAR_KIND(Name) .Case(#Name, OMPC_LINEAR_##Name)
108 #include "clang/Basic/OpenMPKinds.def"
109         .Default(OMPC_LINEAR_unknown);
110   case OMPC_map:
111     return llvm::StringSwitch<OpenMPMapClauseKind>(Str)
112 #define OPENMP_MAP_KIND(Name) .Case(#Name, OMPC_MAP_##Name)
113 #include "clang/Basic/OpenMPKinds.def"
114         .Default(OMPC_MAP_unknown);
115   case OMPC_dist_schedule:
116     return llvm::StringSwitch<OpenMPDistScheduleClauseKind>(Str)
117 #define OPENMP_DIST_SCHEDULE_KIND(Name) .Case(#Name, OMPC_DIST_SCHEDULE_##Name)
118 #include "clang/Basic/OpenMPKinds.def"
119         .Default(OMPC_DIST_SCHEDULE_unknown);
120   case OMPC_defaultmap:
121     return llvm::StringSwitch<unsigned>(Str)
122 #define OPENMP_DEFAULTMAP_KIND(Name)                                           \
123   .Case(#Name, static_cast<unsigned>(OMPC_DEFAULTMAP_##Name))
124 #define OPENMP_DEFAULTMAP_MODIFIER(Name)                                       \
125   .Case(#Name, static_cast<unsigned>(OMPC_DEFAULTMAP_MODIFIER_##Name))
126 #include "clang/Basic/OpenMPKinds.def"
127         .Default(OMPC_DEFAULTMAP_unknown);
128   case OMPC_unknown:
129   case OMPC_threadprivate:
130   case OMPC_if:
131   case OMPC_final:
132   case OMPC_num_threads:
133   case OMPC_safelen:
134   case OMPC_simdlen:
135   case OMPC_collapse:
136   case OMPC_private:
137   case OMPC_firstprivate:
138   case OMPC_lastprivate:
139   case OMPC_shared:
140   case OMPC_reduction:
141   case OMPC_aligned:
142   case OMPC_copyin:
143   case OMPC_copyprivate:
144   case OMPC_ordered:
145   case OMPC_nowait:
146   case OMPC_untied:
147   case OMPC_mergeable:
148   case OMPC_flush:
149   case OMPC_read:
150   case OMPC_write:
151   case OMPC_update:
152   case OMPC_capture:
153   case OMPC_seq_cst:
154   case OMPC_device:
155   case OMPC_threads:
156   case OMPC_simd:
157   case OMPC_num_teams:
158   case OMPC_thread_limit:
159   case OMPC_priority:
160   case OMPC_grainsize:
161   case OMPC_nogroup:
162   case OMPC_num_tasks:
163   case OMPC_hint:
164   case OMPC_uniform:
165     break;
166   }
167   llvm_unreachable("Invalid OpenMP simple clause kind");
168 }
169 
170 const char *clang::getOpenMPSimpleClauseTypeName(OpenMPClauseKind Kind,
171                                                  unsigned Type) {
172   switch (Kind) {
173   case OMPC_default:
174     switch (Type) {
175     case OMPC_DEFAULT_unknown:
176       return "unknown";
177 #define OPENMP_DEFAULT_KIND(Name)                                              \
178   case OMPC_DEFAULT_##Name:                                                    \
179     return #Name;
180 #include "clang/Basic/OpenMPKinds.def"
181     }
182     llvm_unreachable("Invalid OpenMP 'default' clause type");
183   case OMPC_proc_bind:
184     switch (Type) {
185     case OMPC_PROC_BIND_unknown:
186       return "unknown";
187 #define OPENMP_PROC_BIND_KIND(Name)                                            \
188   case OMPC_PROC_BIND_##Name:                                                  \
189     return #Name;
190 #include "clang/Basic/OpenMPKinds.def"
191     }
192     llvm_unreachable("Invalid OpenMP 'proc_bind' clause type");
193   case OMPC_schedule:
194     switch (Type) {
195     case OMPC_SCHEDULE_unknown:
196     case OMPC_SCHEDULE_MODIFIER_last:
197       return "unknown";
198 #define OPENMP_SCHEDULE_KIND(Name)                                             \
199     case OMPC_SCHEDULE_##Name:                                                 \
200       return #Name;
201 #define OPENMP_SCHEDULE_MODIFIER(Name)                                         \
202     case OMPC_SCHEDULE_MODIFIER_##Name:                                        \
203       return #Name;
204 #include "clang/Basic/OpenMPKinds.def"
205     }
206     llvm_unreachable("Invalid OpenMP 'schedule' clause type");
207   case OMPC_depend:
208     switch (Type) {
209     case OMPC_DEPEND_unknown:
210       return "unknown";
211 #define OPENMP_DEPEND_KIND(Name)                                             \
212   case OMPC_DEPEND_##Name:                                                   \
213     return #Name;
214 #include "clang/Basic/OpenMPKinds.def"
215     }
216     llvm_unreachable("Invalid OpenMP 'depend' clause type");
217   case OMPC_linear:
218     switch (Type) {
219     case OMPC_LINEAR_unknown:
220       return "unknown";
221 #define OPENMP_LINEAR_KIND(Name)                                             \
222   case OMPC_LINEAR_##Name:                                                   \
223     return #Name;
224 #include "clang/Basic/OpenMPKinds.def"
225     }
226     llvm_unreachable("Invalid OpenMP 'linear' clause type");
227   case OMPC_map:
228     switch (Type) {
229     case OMPC_MAP_unknown:
230       return "unknown";
231 #define OPENMP_MAP_KIND(Name)                                                \
232   case OMPC_MAP_##Name:                                                      \
233     return #Name;
234 #include "clang/Basic/OpenMPKinds.def"
235     default:
236       break;
237     }
238     llvm_unreachable("Invalid OpenMP 'map' clause type");
239   case OMPC_dist_schedule:
240     switch (Type) {
241     case OMPC_DIST_SCHEDULE_unknown:
242       return "unknown";
243 #define OPENMP_DIST_SCHEDULE_KIND(Name)                                      \
244   case OMPC_DIST_SCHEDULE_##Name:                                            \
245     return #Name;
246 #include "clang/Basic/OpenMPKinds.def"
247     }
248     llvm_unreachable("Invalid OpenMP 'dist_schedule' clause type");
249   case OMPC_defaultmap:
250     switch (Type) {
251     case OMPC_DEFAULTMAP_unknown:
252     case OMPC_DEFAULTMAP_MODIFIER_last:
253       return "unknown";
254 #define OPENMP_DEFAULTMAP_KIND(Name)                                         \
255     case OMPC_DEFAULTMAP_##Name:                                             \
256       return #Name;
257 #define OPENMP_DEFAULTMAP_MODIFIER(Name)                                     \
258     case OMPC_DEFAULTMAP_MODIFIER_##Name:                                    \
259       return #Name;
260 #include "clang/Basic/OpenMPKinds.def"
261     }
262     llvm_unreachable("Invalid OpenMP 'schedule' clause type");
263   case OMPC_unknown:
264   case OMPC_threadprivate:
265   case OMPC_if:
266   case OMPC_final:
267   case OMPC_num_threads:
268   case OMPC_safelen:
269   case OMPC_simdlen:
270   case OMPC_collapse:
271   case OMPC_private:
272   case OMPC_firstprivate:
273   case OMPC_lastprivate:
274   case OMPC_shared:
275   case OMPC_reduction:
276   case OMPC_aligned:
277   case OMPC_copyin:
278   case OMPC_copyprivate:
279   case OMPC_ordered:
280   case OMPC_nowait:
281   case OMPC_untied:
282   case OMPC_mergeable:
283   case OMPC_flush:
284   case OMPC_read:
285   case OMPC_write:
286   case OMPC_update:
287   case OMPC_capture:
288   case OMPC_seq_cst:
289   case OMPC_device:
290   case OMPC_threads:
291   case OMPC_simd:
292   case OMPC_num_teams:
293   case OMPC_thread_limit:
294   case OMPC_priority:
295   case OMPC_grainsize:
296   case OMPC_nogroup:
297   case OMPC_num_tasks:
298   case OMPC_hint:
299   case OMPC_uniform:
300     break;
301   }
302   llvm_unreachable("Invalid OpenMP simple clause kind");
303 }
304 
305 bool clang::isAllowedClauseForDirective(OpenMPDirectiveKind DKind,
306                                         OpenMPClauseKind CKind) {
307   assert(DKind <= OMPD_unknown);
308   assert(CKind <= OMPC_unknown);
309   switch (DKind) {
310   case OMPD_parallel:
311     switch (CKind) {
312 #define OPENMP_PARALLEL_CLAUSE(Name)                                           \
313   case OMPC_##Name:                                                            \
314     return true;
315 #include "clang/Basic/OpenMPKinds.def"
316     default:
317       break;
318     }
319     break;
320   case OMPD_simd:
321     switch (CKind) {
322 #define OPENMP_SIMD_CLAUSE(Name)                                               \
323   case OMPC_##Name:                                                            \
324     return true;
325 #include "clang/Basic/OpenMPKinds.def"
326     default:
327       break;
328     }
329     break;
330   case OMPD_for:
331     switch (CKind) {
332 #define OPENMP_FOR_CLAUSE(Name)                                                \
333   case OMPC_##Name:                                                            \
334     return true;
335 #include "clang/Basic/OpenMPKinds.def"
336     default:
337       break;
338     }
339     break;
340   case OMPD_for_simd:
341     switch (CKind) {
342 #define OPENMP_FOR_SIMD_CLAUSE(Name)                                           \
343   case OMPC_##Name:                                                            \
344     return true;
345 #include "clang/Basic/OpenMPKinds.def"
346     default:
347       break;
348     }
349     break;
350   case OMPD_sections:
351     switch (CKind) {
352 #define OPENMP_SECTIONS_CLAUSE(Name)                                           \
353   case OMPC_##Name:                                                            \
354     return true;
355 #include "clang/Basic/OpenMPKinds.def"
356     default:
357       break;
358     }
359     break;
360   case OMPD_single:
361     switch (CKind) {
362 #define OPENMP_SINGLE_CLAUSE(Name)                                             \
363   case OMPC_##Name:                                                            \
364     return true;
365 #include "clang/Basic/OpenMPKinds.def"
366     default:
367       break;
368     }
369     break;
370   case OMPD_parallel_for:
371     switch (CKind) {
372 #define OPENMP_PARALLEL_FOR_CLAUSE(Name)                                       \
373   case OMPC_##Name:                                                            \
374     return true;
375 #include "clang/Basic/OpenMPKinds.def"
376     default:
377       break;
378     }
379     break;
380   case OMPD_parallel_for_simd:
381     switch (CKind) {
382 #define OPENMP_PARALLEL_FOR_SIMD_CLAUSE(Name)                                  \
383   case OMPC_##Name:                                                            \
384     return true;
385 #include "clang/Basic/OpenMPKinds.def"
386     default:
387       break;
388     }
389     break;
390   case OMPD_parallel_sections:
391     switch (CKind) {
392 #define OPENMP_PARALLEL_SECTIONS_CLAUSE(Name)                                  \
393   case OMPC_##Name:                                                            \
394     return true;
395 #include "clang/Basic/OpenMPKinds.def"
396     default:
397       break;
398     }
399     break;
400   case OMPD_task:
401     switch (CKind) {
402 #define OPENMP_TASK_CLAUSE(Name)                                               \
403   case OMPC_##Name:                                                            \
404     return true;
405 #include "clang/Basic/OpenMPKinds.def"
406     default:
407       break;
408     }
409     break;
410   case OMPD_flush:
411     return CKind == OMPC_flush;
412     break;
413   case OMPD_atomic:
414     switch (CKind) {
415 #define OPENMP_ATOMIC_CLAUSE(Name)                                             \
416   case OMPC_##Name:                                                            \
417     return true;
418 #include "clang/Basic/OpenMPKinds.def"
419     default:
420       break;
421     }
422     break;
423   case OMPD_target:
424     switch (CKind) {
425 #define OPENMP_TARGET_CLAUSE(Name)                                             \
426   case OMPC_##Name:                                                            \
427     return true;
428 #include "clang/Basic/OpenMPKinds.def"
429     default:
430       break;
431     }
432     break;
433   case OMPD_target_data:
434     switch (CKind) {
435 #define OPENMP_TARGET_DATA_CLAUSE(Name)                                        \
436   case OMPC_##Name:                                                            \
437     return true;
438 #include "clang/Basic/OpenMPKinds.def"
439     default:
440       break;
441     }
442     break;
443   case OMPD_target_enter_data:
444     switch (CKind) {
445 #define OPENMP_TARGET_ENTER_DATA_CLAUSE(Name)                                  \
446   case OMPC_##Name:                                                            \
447     return true;
448 #include "clang/Basic/OpenMPKinds.def"
449     default:
450       break;
451     }
452     break;
453   case OMPD_target_exit_data:
454     switch (CKind) {
455 #define OPENMP_TARGET_EXIT_DATA_CLAUSE(Name)                                   \
456   case OMPC_##Name:                                                            \
457     return true;
458 #include "clang/Basic/OpenMPKinds.def"
459     default:
460       break;
461     }
462     break;
463   case OMPD_target_parallel:
464     switch (CKind) {
465 #define OPENMP_TARGET_PARALLEL_CLAUSE(Name)                                    \
466   case OMPC_##Name:                                                            \
467     return true;
468 #include "clang/Basic/OpenMPKinds.def"
469     default:
470       break;
471     }
472     break;
473   case OMPD_target_parallel_for:
474     switch (CKind) {
475 #define OPENMP_TARGET_PARALLEL_FOR_CLAUSE(Name)                                \
476   case OMPC_##Name:                                                            \
477     return true;
478 #include "clang/Basic/OpenMPKinds.def"
479     default:
480       break;
481     }
482     break;
483   case OMPD_teams:
484     switch (CKind) {
485 #define OPENMP_TEAMS_CLAUSE(Name)                                              \
486   case OMPC_##Name:                                                            \
487     return true;
488 #include "clang/Basic/OpenMPKinds.def"
489     default:
490       break;
491     }
492     break;
493   case OMPD_declare_simd:
494     break;
495   case OMPD_cancel:
496     switch (CKind) {
497 #define OPENMP_CANCEL_CLAUSE(Name)                                             \
498   case OMPC_##Name:                                                            \
499     return true;
500 #include "clang/Basic/OpenMPKinds.def"
501     default:
502       break;
503     }
504     break;
505   case OMPD_ordered:
506     switch (CKind) {
507 #define OPENMP_ORDERED_CLAUSE(Name)                                            \
508   case OMPC_##Name:                                                            \
509     return true;
510 #include "clang/Basic/OpenMPKinds.def"
511     default:
512       break;
513     }
514     break;
515   case OMPD_taskloop:
516     switch (CKind) {
517 #define OPENMP_TASKLOOP_CLAUSE(Name)                                           \
518   case OMPC_##Name:                                                            \
519     return true;
520 #include "clang/Basic/OpenMPKinds.def"
521     default:
522       break;
523     }
524     break;
525   case OMPD_taskloop_simd:
526     switch (CKind) {
527 #define OPENMP_TASKLOOP_SIMD_CLAUSE(Name)                                      \
528   case OMPC_##Name:                                                            \
529     return true;
530 #include "clang/Basic/OpenMPKinds.def"
531     default:
532       break;
533     }
534     break;
535   case OMPD_critical:
536     switch (CKind) {
537 #define OPENMP_CRITICAL_CLAUSE(Name)                                           \
538   case OMPC_##Name:                                                            \
539     return true;
540 #include "clang/Basic/OpenMPKinds.def"
541     default:
542       break;
543     }
544     break;
545   case OMPD_distribute:
546     switch (CKind) {
547 #define OPENMP_DISTRIBUTE_CLAUSE(Name)                                         \
548   case OMPC_##Name:                                                            \
549     return true;
550 #include "clang/Basic/OpenMPKinds.def"
551     default:
552       break;
553     }
554     break;
555   case OMPD_declare_target:
556   case OMPD_end_declare_target:
557   case OMPD_unknown:
558   case OMPD_threadprivate:
559   case OMPD_section:
560   case OMPD_master:
561   case OMPD_taskyield:
562   case OMPD_barrier:
563   case OMPD_taskwait:
564   case OMPD_taskgroup:
565   case OMPD_cancellation_point:
566   case OMPD_declare_reduction:
567     break;
568   }
569   return false;
570 }
571 
572 bool clang::isOpenMPLoopDirective(OpenMPDirectiveKind DKind) {
573   return DKind == OMPD_simd || DKind == OMPD_for || DKind == OMPD_for_simd ||
574          DKind == OMPD_parallel_for || DKind == OMPD_parallel_for_simd ||
575          DKind == OMPD_taskloop || DKind == OMPD_taskloop_simd ||
576          DKind == OMPD_distribute ||
577          DKind == OMPD_target_parallel_for; // TODO add next directives.
578 }
579 
580 bool clang::isOpenMPWorksharingDirective(OpenMPDirectiveKind DKind) {
581   return DKind == OMPD_for || DKind == OMPD_for_simd ||
582          DKind == OMPD_sections || DKind == OMPD_section ||
583          DKind == OMPD_single || DKind == OMPD_parallel_for ||
584          DKind == OMPD_parallel_for_simd || DKind == OMPD_parallel_sections ||
585          DKind == OMPD_target_parallel_for; // TODO add next directives.
586 }
587 
588 bool clang::isOpenMPTaskLoopDirective(OpenMPDirectiveKind DKind) {
589   return DKind == OMPD_taskloop || DKind == OMPD_taskloop_simd;
590 }
591 
592 bool clang::isOpenMPParallelDirective(OpenMPDirectiveKind DKind) {
593   return DKind == OMPD_parallel || DKind == OMPD_parallel_for ||
594          DKind == OMPD_parallel_for_simd || DKind == OMPD_parallel_sections ||
595          DKind == OMPD_target_parallel || DKind == OMPD_target_parallel_for;
596   // TODO add next directives.
597 }
598 
599 bool clang::isOpenMPTargetExecutionDirective(OpenMPDirectiveKind DKind) {
600   // TODO add next directives.
601   return DKind == OMPD_target || DKind == OMPD_target_parallel ||
602          DKind == OMPD_target_parallel_for;
603 }
604 
605 bool clang::isOpenMPTargetDataManagementDirective(OpenMPDirectiveKind DKind) {
606   // TODO add target update directive check.
607   return DKind == OMPD_target_data || DKind == OMPD_target_enter_data ||
608          DKind == OMPD_target_exit_data;
609 }
610 
611 bool clang::isOpenMPTeamsDirective(OpenMPDirectiveKind DKind) {
612   return DKind == OMPD_teams; // TODO add next directives.
613 }
614 
615 bool clang::isOpenMPSimdDirective(OpenMPDirectiveKind DKind) {
616   return DKind == OMPD_simd || DKind == OMPD_for_simd ||
617          DKind == OMPD_parallel_for_simd ||
618          DKind == OMPD_taskloop_simd; // TODO add next directives.
619 }
620 
621 bool clang::isOpenMPDistributeDirective(OpenMPDirectiveKind Kind) {
622   return Kind == OMPD_distribute; // TODO add next directives.
623 }
624 
625 bool clang::isOpenMPPrivate(OpenMPClauseKind Kind) {
626   return Kind == OMPC_private || Kind == OMPC_firstprivate ||
627          Kind == OMPC_lastprivate || Kind == OMPC_linear ||
628          Kind == OMPC_reduction; // TODO add next clauses like 'reduction'.
629 }
630 
631 bool clang::isOpenMPThreadPrivate(OpenMPClauseKind Kind) {
632   return Kind == OMPC_threadprivate || Kind == OMPC_copyin;
633 }
634 
635 bool clang::isOpenMPTaskingDirective(OpenMPDirectiveKind Kind) {
636   return Kind == OMPD_task || isOpenMPTaskLoopDirective(Kind);
637 }
638