FLANG
check-omp-structure.h
1//===-- lib/Semantics/check-omp-structure.h ---------------------*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8
9// OpenMP structure validity check list
10// 1. invalid clauses on directive
11// 2. invalid repeated clauses on directive
12// 3. TODO: invalid nesting of regions
13
14#ifndef FORTRAN_SEMANTICS_CHECK_OMP_STRUCTURE_H_
15#define FORTRAN_SEMANTICS_CHECK_OMP_STRUCTURE_H_
16
17#include "check-directive-structure.h"
18#include "flang/Common/enum-set.h"
19#include "flang/Parser/parse-tree.h"
20#include "flang/Semantics/openmp-directive-sets.h"
21#include "flang/Semantics/semantics.h"
22
23using OmpClauseSet =
25
26#define GEN_FLANG_DIRECTIVE_CLAUSE_SETS
27#include "llvm/Frontend/OpenMP/OMP.inc"
28
29namespace llvm {
30namespace omp {
31static OmpClauseSet privateSet{
32 Clause::OMPC_private, Clause::OMPC_firstprivate, Clause::OMPC_lastprivate};
33static OmpClauseSet privateReductionSet{
34 OmpClauseSet{Clause::OMPC_reduction} | privateSet};
35// omp.td cannot differentiate allowed/not allowed clause list for few
36// directives for fortran. nowait is not allowed on begin directive clause list
37// for below list of directives. Directives with conflicting list of clauses are
38// included in below list.
39static const OmpDirectiveSet noWaitClauseNotAllowedSet{
40 Directive::OMPD_do,
41 Directive::OMPD_do_simd,
42 Directive::OMPD_sections,
43 Directive::OMPD_single,
44 Directive::OMPD_workshare,
45};
46} // namespace omp
47} // namespace llvm
48
49namespace Fortran::semantics {
50struct AnalyzedCondStmt;
51
52namespace omp {
53struct LoopSequence;
54}
55
56// Mapping from 'Symbol' to 'Source' to keep track of the variables
57// used in multiple clauses
58using SymbolSourceMap = std::multimap<const Symbol *, parser::CharBlock>;
59// Multimap to check the triple <current_dir, enclosing_dir, enclosing_clause>
60using DirectivesClauseTriple = std::multimap<llvm::omp::Directive,
61 std::pair<llvm::omp::Directive, const OmpClauseSet>>;
62
63using OmpStructureCheckerBase = DirectiveStructureChecker<llvm::omp::Directive,
64 llvm::omp::Clause, parser::OmpClause, llvm::omp::Clause_enumSize>;
65
66class OmpStructureChecker : public OmpStructureCheckerBase {
67public:
68 using Base = OmpStructureCheckerBase;
69
70 OmpStructureChecker(SemanticsContext &context);
71
72 using llvmOmpClause = const llvm::omp::Clause;
73
74 bool Enter(const parser::MainProgram &);
75 void Leave(const parser::MainProgram &);
76 bool Enter(const parser::BlockData &);
77 void Leave(const parser::BlockData &);
78 bool Enter(const parser::Module &);
79 void Leave(const parser::Module &);
80 bool Enter(const parser::Submodule &);
81 void Leave(const parser::Submodule &);
82 bool Enter(const parser::SubroutineStmt &);
83 bool Enter(const parser::EndSubroutineStmt &);
84 bool Enter(const parser::FunctionStmt &);
85 bool Enter(const parser::EndFunctionStmt &);
86 bool Enter(const parser::BlockConstruct &);
87 void Leave(const parser::BlockConstruct &);
88 void Enter(const parser::InternalSubprogram &);
89 void Enter(const parser::ModuleSubprogram &);
90
91 void Enter(const parser::SpecificationPart &);
92 void Leave(const parser::SpecificationPart &);
93 void Enter(const parser::ExecutionPart &);
94 void Leave(const parser::ExecutionPart &);
95
96 void Enter(const parser::OpenMPConstruct &);
97 void Leave(const parser::OpenMPConstruct &);
98 void Enter(const parser::OpenMPDeclarativeConstruct &);
99 void Leave(const parser::OpenMPDeclarativeConstruct &);
100
101 void Enter(const parser::OpenMPMisplacedEndDirective &);
102 void Leave(const parser::OpenMPMisplacedEndDirective &);
103 void Enter(const parser::OpenMPInvalidDirective &);
104 void Leave(const parser::OpenMPInvalidDirective &);
105
106 void Enter(const parser::OpenMPLoopConstruct &);
107 void Leave(const parser::OpenMPLoopConstruct &);
108
109 void Enter(const parser::OpenMPAssumeConstruct &);
110 void Leave(const parser::OpenMPAssumeConstruct &);
111 void Enter(const parser::OpenMPDeclarativeAssumes &);
112 void Leave(const parser::OpenMPDeclarativeAssumes &);
113 void Enter(const parser::OpenMPInteropConstruct &);
114 void Leave(const parser::OpenMPInteropConstruct &);
115 void Enter(const parser::OmpBlockConstruct &);
116 void Leave(const parser::OmpBlockConstruct &);
117 void Leave(const parser::OmpBeginDirective &);
118 void Enter(const parser::OmpEndDirective &);
119 void Leave(const parser::OmpEndDirective &);
120
121 void Enter(const parser::OpenMPSectionsConstruct &);
122 void Leave(const parser::OpenMPSectionsConstruct &);
123 void Enter(const parser::OmpEndSectionsDirective &);
124 void Leave(const parser::OmpEndSectionsDirective &);
125
126 void Enter(const parser::OmpDeclareVariantDirective &);
127 void Leave(const parser::OmpDeclareVariantDirective &);
128 void Enter(const parser::OpenMPDeclareSimdConstruct &);
129 void Leave(const parser::OpenMPDeclareSimdConstruct &);
130 void Enter(const parser::OmpAllocateDirective &);
131 void Leave(const parser::OmpAllocateDirective &);
132 void Enter(const parser::OpenMPDeclareMapperConstruct &);
133 void Leave(const parser::OpenMPDeclareMapperConstruct &);
134 void Enter(const parser::OpenMPDeclareReductionConstruct &);
135 void Leave(const parser::OpenMPDeclareReductionConstruct &);
136 void Enter(const parser::OpenMPDeclareTargetConstruct &);
137 void Leave(const parser::OpenMPDeclareTargetConstruct &);
138 void Enter(const parser::OpenMPDepobjConstruct &);
139 void Leave(const parser::OpenMPDepobjConstruct &);
140 void Enter(const parser::OpenMPDispatchConstruct &);
141 void Leave(const parser::OpenMPDispatchConstruct &);
142 void Enter(const parser::OmpErrorDirective &);
143 void Leave(const parser::OmpErrorDirective &);
144 void Enter(const parser::OmpNothingDirective &);
145 void Leave(const parser::OmpNothingDirective &);
146 void Enter(const parser::OpenMPAllocatorsConstruct &);
147 void Leave(const parser::OpenMPAllocatorsConstruct &);
148 void Enter(const parser::OpenMPRequiresConstruct &);
149 void Leave(const parser::OpenMPRequiresConstruct &);
150 void Enter(const parser::OpenMPGroupprivate &);
151 void Leave(const parser::OpenMPGroupprivate &);
152 void Enter(const parser::OpenMPThreadprivate &);
153 void Leave(const parser::OpenMPThreadprivate &);
154
155 void Enter(const parser::OpenMPSimpleStandaloneConstruct &);
156 void Leave(const parser::OpenMPSimpleStandaloneConstruct &);
157 void Enter(const parser::OpenMPFlushConstruct &);
158 void Leave(const parser::OpenMPFlushConstruct &);
159 void Enter(const parser::OpenMPCancelConstruct &);
160 void Leave(const parser::OpenMPCancelConstruct &);
163 void Enter(const parser::OpenMPCriticalConstruct &);
164 void Leave(const parser::OpenMPCriticalConstruct &);
165 void Enter(const parser::OpenMPAtomicConstruct &);
166 void Leave(const parser::OpenMPAtomicConstruct &);
167
168 void Leave(const parser::OmpClauseList &);
169 void Enter(const parser::OmpClause &);
170
171 void Enter(const parser::DoConstruct &);
172 void Leave(const parser::DoConstruct &);
173
174 void Enter(const parser::OmpDirectiveSpecification &);
175 void Leave(const parser::OmpDirectiveSpecification &);
176
177 void Enter(const parser::OmpMetadirectiveDirective &);
178 void Leave(const parser::OmpMetadirectiveDirective &);
179
180 void Enter(const parser::OmpContextSelector &);
181 void Leave(const parser::OmpContextSelector &);
182
183 template <typename A> void Enter(const parser::Statement<A> &);
184 void Leave(const parser::GotoStmt &);
185 void Leave(const parser::ComputedGotoStmt &);
186 void Leave(const parser::ArithmeticIfStmt &);
187 void Leave(const parser::AssignedGotoStmt &);
188 void Leave(const parser::AltReturnSpec &);
189 void Leave(const parser::ErrLabel &);
190 void Leave(const parser::EndLabel &);
191 void Leave(const parser::EorLabel &);
192
193#define GEN_FLANG_CLAUSE_CHECK_ENTER
194#include "llvm/Frontend/OpenMP/OMP.inc"
195
196private:
197 using LoopOrConstruct = std::variant<const parser::DoConstruct *,
199
200 // Most of these functions are defined in check-omp-structure.cpp, but
201 // some groups have their own files.
202
203 // check-omp-atomic.cpp
204 void CheckStorageOverlap(const evaluate::Expr<evaluate::SomeType> &,
206 void ErrorShouldBeVariable(const MaybeExpr &expr, parser::CharBlock source);
207 void CheckAtomicType(SymbolRef sym, parser::CharBlock source,
208 std::string_view name, bool checkTypeOnPointer = true);
209 void CheckAtomicVariable(const evaluate::Expr<evaluate::SomeType> &,
210 parser::CharBlock, bool checkTypeOnPointer = true);
211 std::pair<const parser::ExecutionPartConstruct *,
213 CheckUpdateCapture(const parser::ExecutionPartConstruct *ec1,
215 void CheckAtomicCaptureAssignment(const evaluate::Assignment &capture,
216 const SomeExpr &atom, parser::CharBlock source);
217 void CheckAtomicReadAssignment(
218 const evaluate::Assignment &read, parser::CharBlock source);
219 void CheckAtomicWriteAssignment(
220 const evaluate::Assignment &write, parser::CharBlock source);
221 std::optional<evaluate::Assignment> CheckAtomicUpdateAssignment(
222 const evaluate::Assignment &update, parser::CharBlock source);
223 std::pair<bool, bool> CheckAtomicUpdateAssignmentRhs(const SomeExpr &atom,
224 const SomeExpr &rhs, parser::CharBlock source, bool suppressDiagnostics);
225 void CheckAtomicConditionalUpdateAssignment(const SomeExpr &cond,
226 parser::CharBlock condSource, const evaluate::Assignment &assign,
227 parser::CharBlock assignSource);
228 void CheckAtomicConditionalUpdateStmt(
229 const AnalyzedCondStmt &update, parser::CharBlock source);
230 void CheckAtomicUpdateOnly(const parser::OpenMPAtomicConstruct &x,
231 const parser::Block &body, parser::CharBlock source);
232 void CheckAtomicConditionalUpdate(const parser::OpenMPAtomicConstruct &x,
233 const parser::Block &body, parser::CharBlock source);
234 void CheckAtomicUpdateCapture(const parser::OpenMPAtomicConstruct &x,
235 const parser::Block &body, parser::CharBlock source);
236 void CheckAtomicConditionalUpdateCapture(
237 const parser::OpenMPAtomicConstruct &x, const parser::Block &body,
238 parser::CharBlock source);
239 void CheckAtomicRead(const parser::OpenMPAtomicConstruct &x);
240 void CheckAtomicWrite(const parser::OpenMPAtomicConstruct &x);
241 void CheckAtomicUpdate(const parser::OpenMPAtomicConstruct &x);
242
243 // check-omp-loop.cpp
244 void HasInvalidDistributeNesting(const parser::OpenMPLoopConstruct &x);
245 void HasInvalidLoopBinding(const parser::OpenMPLoopConstruct &x);
246 void CheckSIMDNest(const parser::OpenMPConstruct &x);
247 void CheckRectangularNest(const parser::OmpDirectiveSpecification &spec,
248 const omp::LoopSequence &nest);
249 void CheckNestedConstruct(const parser::OpenMPLoopConstruct &x);
250 const parser::Name GetLoopIndex(const parser::DoConstruct *x);
251 void SetLoopInfo(const parser::OpenMPLoopConstruct &x);
252 void CheckIterationVariableType(const parser::OpenMPLoopConstruct &x);
253 std::int64_t GetOrdCollapseLevel(const parser::OpenMPLoopConstruct &x);
254 void CheckAssociatedLoopConstraints(const parser::OpenMPLoopConstruct &x);
255 void CheckScanModifier(const parser::OmpClause::Reduction &x);
256 void CheckDistLinear(const parser::OpenMPLoopConstruct &x);
257
258 // check-omp-metadirective.cpp
259 const std::list<parser::OmpTraitProperty> &GetTraitPropertyList(
261 std::optional<llvm::omp::Clause> GetClauseFromProperty(
263
264 void CheckTraitSelectorList(const std::list<parser::OmpTraitSelector> &);
265 void CheckTraitSetSelector(const parser::OmpTraitSetSelector &);
266 void CheckTraitScore(const parser::OmpTraitScore &);
267 bool VerifyTraitPropertyLists(
269 void CheckTraitSelector(
271 void CheckTraitADMO(
273 void CheckTraitCondition(
275 void CheckTraitDeviceNum(
277 void CheckTraitRequires(
279 void CheckTraitSimd(
281
282 // check-omp-structure.cpp
283 bool IsAllowedClause(llvm::omp::Clause clauseId);
284 bool CheckAllowedClause(llvmOmpClause clause);
285 void CheckVariableListItem(const SymbolSourceMap &symbols);
286 void CheckDirectiveSpelling(
287 parser::CharBlock spelling, llvm::omp::Directive id);
288 void CheckDirectiveDeprecation(const parser::OpenMPConstruct &x);
289 void AnalyzeObject(const parser::OmpObject &object);
290 void AnalyzeObjects(const parser::OmpObjectList &objects);
291
292 const parser::OpenMPConstruct *GetCurrentConstruct() const;
293 void CheckSourceLabel(const parser::Label &);
294 void CheckLabelContext(const parser::CharBlock, const parser::CharBlock,
296 void ClearLabels();
297 void CheckMultipleOccurrence(semantics::UnorderedSymbolSet &listVars,
298 const std::list<parser::Name> &nameList, const parser::CharBlock &item,
299 const std::string &clauseName);
300 void CheckMultListItems();
301 void CheckStructureComponent(
302 const parser::OmpObjectList &objects, llvm::omp::Clause clauseId);
303 bool HasInvalidWorksharingNesting(
304 const parser::OmpDirectiveName &name, const OmpDirectiveSet &);
305
306 bool IsCloselyNestedRegion(const OmpDirectiveSet &set);
307 bool IsNestedInDirective(llvm::omp::Directive directive);
308 bool IsCombinedParallelWorksharing(llvm::omp::Directive directive) const;
309 bool InTargetRegion();
310 void HasInvalidTeamsNesting(
311 const llvm::omp::Directive &dir, const parser::CharBlock &source);
312 bool HasRequires(llvm::omp::Clause req);
313 void CheckAllowedMapTypes(
314 parser::OmpMapType::Value, llvm::ArrayRef<parser::OmpMapType::Value>);
315
316 llvm::StringRef getClauseName(llvm::omp::Clause clause) override;
317 llvm::StringRef getDirectiveName(llvm::omp::Directive directive) override;
318
319 template < //
320 typename LessTy, typename RangeTy,
321 typename IterTy = decltype(std::declval<RangeTy>().begin())>
322 std::optional<IterTy> FindDuplicate(RangeTy &&);
323
324 void CheckDependList(const parser::DataRef &);
325 void CheckDoacross(const parser::OmpDoacross &doa);
326 void CheckDimsModifier(parser::CharBlock source, size_t numValues,
327 const parser::OmpDimsModifier &x);
328 bool IsDataRefTypeParamInquiry(const parser::DataRef *dataRef);
329 void CheckVarIsNotPartOfAnotherVar(const parser::CharBlock &source,
330 const parser::OmpObject &obj, llvm::StringRef clause = "");
331 void CheckVarIsNotPartOfAnotherVar(const parser::CharBlock &source,
332 const parser::OmpObjectList &objList, llvm::StringRef clause = "");
333 void CheckThreadprivateOrDeclareTargetVar(const parser::Designator &);
334 void CheckThreadprivateOrDeclareTargetVar(const parser::Name &);
335 void CheckThreadprivateOrDeclareTargetVar(const parser::OmpObject &);
336 void CheckThreadprivateOrDeclareTargetVar(const parser::OmpObjectList &);
337 void CheckSymbolName(
338 const parser::CharBlock &source, const parser::OmpObject &object);
339 void CheckSymbolNames(
340 const parser::CharBlock &source, const parser::OmpObjectList &objList);
341 void CheckIntentInPointer(SymbolSourceMap &, const llvm::omp::Clause);
342 void CheckAssumedSizeArray(SymbolSourceMap &, const llvm::omp::Clause);
343 void CheckProcedurePointer(SymbolSourceMap &, const llvm::omp::Clause);
344 void CheckCrayPointee(const parser::OmpObjectList &objectList,
345 llvm::StringRef clause, bool suggestToUseCrayPointer = true);
346 void GetSymbolsInObjectList(const parser::OmpObjectList &, SymbolSourceMap &);
347 void CheckDefinableObjects(SymbolSourceMap &, const llvm::omp::Clause);
348 void CheckCopyingPolymorphicAllocatable(
349 SymbolSourceMap &, const llvm::omp::Clause);
350 void CheckPrivateSymbolsInOuterCxt(
351 SymbolSourceMap &, DirectivesClauseTriple &, const llvm::omp::Clause);
352 void CheckIsLoopIvPartOfClause(
353 llvmOmpClause clause, const parser::OmpObjectList &ompObjectList);
354 bool CheckTargetBlockOnlyTeams(const parser::Block &);
355 void CheckWorkshareBlockStmts(const parser::Block &, parser::CharBlock);
356 void CheckWorkdistributeBlockStmts(const parser::Block &, parser::CharBlock);
357 void CheckIndividualAllocateDirective(
358 const parser::OmpAllocateDirective &x, bool isExecutable);
359 void CheckExecutableAllocateDirective(const parser::OmpAllocateDirective &x);
360
361 void CheckIteratorRange(const parser::OmpIteratorSpecifier &x);
362 void CheckIteratorModifier(const parser::OmpIterator &x);
363
364 void CheckTargetNest(const parser::OpenMPConstruct &x);
365 void CheckTargetUpdate();
366 void CheckTaskgraph(const parser::OmpBlockConstruct &x);
367 void CheckDependenceType(const parser::OmpDependenceType::Value &x);
368 void CheckTaskDependenceType(const parser::OmpTaskDependenceType::Value &x);
369 std::optional<llvm::omp::Directive> GetCancelType(
370 llvm::omp::Directive cancelDir, const parser::CharBlock &cancelSource,
371 const std::optional<parser::OmpClauseList> &maybeClauses);
372 void CheckCancellationNest(
373 const parser::CharBlock &source, llvm::omp::Directive type);
374 void CheckReductionObjects(
375 const parser::OmpObjectList &objects, llvm::omp::Clause clauseId);
376 bool CheckReductionOperator(const parser::OmpReductionIdentifier &ident,
377 parser::CharBlock source, llvm::omp::Clause clauseId);
378 void CheckReductionObjectTypes(const parser::OmpObjectList &objects,
379 const parser::OmpReductionIdentifier &ident);
380 void CheckReductionModifier(const parser::OmpReductionModifier &);
381 void CheckLastprivateModifier(const parser::OmpLastprivateModifier &);
382 void CheckMasterNesting(const parser::OmpBlockConstruct &x);
383 void ChecksOnOrderedAsBlock();
384 void CheckBarrierNesting(const parser::OpenMPSimpleStandaloneConstruct &x);
385 void CheckScan(const parser::OpenMPSimpleStandaloneConstruct &x);
386 void ChecksOnOrderedAsStandalone();
387 void CheckOrderedDependClause(std::optional<std::int64_t> orderedValue);
388 void CheckReductionArraySection(
389 const parser::OmpObjectList &ompObjectList, llvm::omp::Clause clauseId);
390 void CheckArraySection(const parser::ArrayElement &arrayElement,
391 const parser::Name &name, const llvm::omp::Clause clause);
392 void CheckLastPartRefForArraySection(
393 const parser::Designator &designator, llvm::omp::Clause clauseId);
394 void CheckSharedBindingInOuterContext(
395 const parser::OmpObjectList &ompObjectList);
396 void CheckIfContiguous(const parser::OmpObject &object);
397 const parser::Name *GetObjectName(const parser::OmpObject &object);
398 void CheckInitOnDepobj(const parser::OpenMPDepobjConstruct &depobj,
399 const parser::OmpClause &initClause);
400 void CheckAllowedRequiresClause(llvmOmpClause clause);
401 void AddEndDirectiveClauses(const parser::OmpClauseList &clauses);
402
403 void EnterDirectiveNest(const int index) { directiveNest_[index]++; }
404 void ExitDirectiveNest(const int index) { directiveNest_[index]--; }
405 int GetDirectiveNest(const int index) { return directiveNest_[index]; }
406
407 bool deviceConstructFound_{false};
408 enum directiveNestType : int {
409 SIMDNest,
410 TargetBlockOnlyTeams,
411 TargetNest,
412 DeclarativeNest,
413 ContextSelectorNest,
414 MetadirectiveNest,
415 LastType = MetadirectiveNest,
416 };
417 int directiveNest_[LastType + 1] = {0};
418
419 int allocateDirectiveLevel_{0};
420 parser::CharBlock visitedAtomicSource_;
421 SymbolSourceMap deferredNonVariables_;
422
423 // Stack of nested DO loops and OpenMP constructs.
424 // This is used to verify DO loop nest for DOACROSS, and branches into
425 // and out of OpenMP constructs.
426 std::vector<LoopOrConstruct> constructStack_;
427 // Scopes for scoping units.
428 std::vector<const Scope *> scopeStack_;
429 // Stack of directive specifications (except for SECTION).
430 // This is to allow visitor functions to see all specified clauses, since
431 // they are only recorded in DirectiveContext as they are processed.
432 std::vector<const parser::OmpDirectiveSpecification *> dirStack_;
433
434 enum class PartKind : int {
435 // There are also other "parts", such as internal-subprogram-part, etc,
436 // but we're keeping track of these two for now.
437 SpecificationPart,
438 ExecutionPart,
439 };
440 std::vector<PartKind> partStack_;
441
442 std::multimap<const parser::Label,
443 std::pair<parser::CharBlock, const parser::OpenMPConstruct *>>
444 sourceLabels_;
445 std::map<const parser::Label,
446 std::pair<parser::CharBlock, const parser::OpenMPConstruct *>>
447 targetLabels_;
448 parser::CharBlock currentStatementSource_;
449};
450
451template <typename A>
452void OmpStructureChecker::Enter(const parser::Statement<A> &statement) {
453 currentStatementSource_ = statement.source;
454 // Keep track of the labels in all the labelled statements
455 if (statement.label) {
456 auto label{statement.label.value()};
457 // Get the context to check if the labelled statement is in an
458 // enclosing OpenMP construct
459 auto *thisConstruct{GetCurrentConstruct()};
460 targetLabels_.emplace(
461 label, std::make_pair(currentStatementSource_, thisConstruct));
462 // Check if a statement that causes a jump to the 'label'
463 // has already been encountered
464 auto range{sourceLabels_.equal_range(label)};
465 for (auto it{range.first}; it != range.second; ++it) {
466 // Check if both the statement with 'label' and the statement that
467 // causes a jump to the 'label' are in the same scope
468 CheckLabelContext(it->second.first, currentStatementSource_,
469 it->second.second, thisConstruct);
470 }
471 }
472}
473
476template <typename LessTy, typename RangeTy, typename IterTy>
477std::optional<IterTy> OmpStructureChecker::FindDuplicate(RangeTy &&range) {
478 // Deal with iterators, since the actual elements may be rvalues (i.e.
479 // have no addresses), for example with custom-constructed ranges that
480 // are not simple c.begin()..c.end().
481 std::set<IterTy, LessTy> uniq;
482 for (auto it{range.begin()}, end{range.end()}; it != end; ++it) {
483 if (!uniq.insert(it).second) {
484 return it;
485 }
486 }
487 return std::nullopt;
488}
489
490} // namespace Fortran::semantics
491#endif // FORTRAN_SEMANTICS_CHECK_OMP_STRUCTURE_H_
Definition enum-set.h:28
Definition expression.h:921
Definition common.h:215
Definition char-block.h:28
Definition check-directive-structure.h:208
Definition semantics.h:67
Definition FIRType.h:103
Definition parse-tree.h:3492
Definition parse-tree.h:1898
Definition parse-tree.h:3502
Definition parse-tree.h:2182
Definition parse-tree.h:3020
Definition parse-tree.h:2510
Definition parse-tree.h:1808
Definition parse-tree.h:1847
Definition parse-tree.h:2325
Definition parse-tree.h:556
Definition parse-tree.h:3139
Definition parse-tree.h:465
Definition parse-tree.h:2929
Definition parse-tree.h:2943
Definition parse-tree.h:2964
Definition parse-tree.h:589
Definition parse-tree.h:5314
Definition parse-tree.h:5108
Definition parse-tree.h:5118
Definition parse-tree.h:5077
Definition parse-tree.h:5061
Definition parse-tree.h:3528
Definition parse-tree.h:5084
Definition parse-tree.h:4508
Definition parse-tree.h:5113
Definition parse-tree.h:5184
Definition parse-tree.h:5146
Definition parse-tree.h:5131
Definition parse-tree.h:5140
Definition parse-tree.h:3573
Definition parse-tree.h:3561
Definition parse-tree.h:3617
Definition parse-tree.h:5340
Definition parse-tree.h:5173
Definition parse-tree.h:5345
Definition parse-tree.h:5382
Definition parse-tree.h:5466
Definition parse-tree.h:5330
Definition parse-tree.h:5161
Definition parse-tree.h:5393
Definition parse-tree.h:5407
Definition parse-tree.h:5423
Definition parse-tree.h:5269
Definition parse-tree.h:5431
Definition parse-tree.h:5484
Definition parse-tree.h:5452
Definition parse-tree.h:5275
Definition parse-tree.h:5199
Definition parse-tree.h:5281
Definition parse-tree.h:453
Definition parse-tree.h:361
Definition parse-tree.h:3006
Definition parse-tree.h:3158
Definition parse-tree.h:4010
Definition parse-tree.h:4076
Definition parse-tree.h:4086
Definition parse-tree.h:4094
Definition parse-tree.h:4235
Definition parse-tree.h:3763
Definition parse-tree.h:3729
Definition parse-tree.h:3802
Definition parse-tree.h:3824
Definition check-omp-atomic.cpp:242
Definition openmp-utils.h:254