resolve-directives.cpp - OpenGrok cross reference for /llvm-project/flang/lib/Semantics/resolve-directives.cpp

Lines Matching refs:parser
32   std::optional<Fortran::parser::CharBlock> source{GetLastSource(x)};
48     DirContext(const parser::CharBlock &source, T d, Scope &s)
50     parser::CharBlock directiveSource;
68   void PushContext(const parser::CharBlock &source, T dir, Scope &scope) {
71   void PushContext(const parser::CharBlock &source, T dir) {
75   void SetContextDirectiveSource(parser::CharBlock &dir) {
111   const parser::Name *GetLoopIndex(const parser::DoConstruct &);
112   const parser::DoConstruct *GetDoConstructIf(
113       const parser::ExecutionPartConstruct &);
116       const parser::Name &, Symbol::Flag, Scope &);
118   Symbol *DeclareOrMarkOtherAccessEntity(const parser::Name &, Symbol::Flag);
130   template <typename A> void Walk(const A &x) { parser::Walk(x, *this); }
134   bool Pre(const parser::OpenACCBlockConstruct &);
135   void Post(const parser::OpenACCBlockConstruct &) { PopContext(); }
136   bool Pre(const parser::OpenACCCombinedConstruct &);
137   void Post(const parser::OpenACCCombinedConstruct &) { PopContext(); }
139   bool Pre(const parser::OpenACCDeclarativeConstruct &);
140   void Post(const parser::OpenACCDeclarativeConstruct &) { PopContext(); }
142   void Post(const parser::AccDeclarativeDirective &) {
146   bool Pre(const parser::OpenACCRoutineConstruct &);
147   bool Pre(const parser::AccBindClause &);
148   void Post(const parser::OpenACCStandaloneDeclarativeConstruct &);
150   void Post(const parser::AccBeginBlockDirective &) {
154   bool Pre(const parser::OpenACCLoopConstruct &);
155   void Post(const parser::OpenACCLoopConstruct &) { PopContext(); }
156   void Post(const parser::AccLoopDirective &) {
160   bool Pre(const parser::OpenACCStandaloneConstruct &);
161   void Post(const parser::OpenACCStandaloneConstruct &) { PopContext(); }
162   void Post(const parser::AccStandaloneDirective &) {
166   bool Pre(const parser::OpenACCCacheConstruct &);
167   void Post(const parser::OpenACCCacheConstruct &) { PopContext(); }
169   void Post(const parser::AccDefaultClause &);
171   bool Pre(const parser::AccClause::Attach &);
172   bool Pre(const parser::AccClause::Detach &);
174   bool Pre(const parser::AccClause::Copy &x) {
179   bool Pre(const parser::AccClause::Create &x) {
180     const auto &objectList{std::get<parser::AccObjectList>(x.v.t)};
185   bool Pre(const parser::AccClause::Copyin &x) {
186     const auto &objectList{std::get<parser::AccObjectList>(x.v.t)};
188         std::get<std::optional<parser::AccDataModifier>>(x.v.t)};
190         (*modifier).v == parser::AccDataModifier::Modifier::ReadOnly) {
198   bool Pre(const parser::AccClause::Copyout &x) {
199     const auto &objectList{std::get<parser::AccObjectList>(x.v.t)};
204   bool Pre(const parser::AccClause::Present &x) {
208   bool Pre(const parser::AccClause::Private &x) {
212   bool Pre(const parser::AccClause::Firstprivate &x) {
217   bool Pre(const parser::AccClause::Device &x) {
222   bool Pre(const parser::AccClause::DeviceResident &x) {
227   bool Pre(const parser::AccClause::Deviceptr &x) {
232   bool Pre(const parser::AccClause::Link &x) {
237   bool Pre(const parser::AccClause::Host &x) {
242   bool Pre(const parser::AccClause::Self &x) {
243     const std::optional<parser::AccSelfClause> &accSelfClause = x.v;
245         std::holds_alternative<parser::AccObjectList>((*accSelfClause).u)) {
247           std::get<parser::AccObjectList>((*accSelfClause).u);
253   void Post(const parser::Name &);
256   std::int64_t GetAssociatedLoopLevelFromClauses(const parser::AccClauseList &);
275   void CheckAssociatedLoop(const parser::DoConstruct &);
276   void ResolveAccObjectList(const parser::AccObjectList &, Symbol::Flag);
277   void ResolveAccObject(const parser::AccObject &, Symbol::Flag);
278   Symbol *ResolveAcc(const parser::Name &, Symbol::Flag, Scope &);
280   Symbol *ResolveName(const parser::Name &, bool parentScope = false);
281   Symbol *ResolveFctName(const parser::Name &);
282   Symbol *ResolveAccCommonBlockName(const parser::Name *);
283   Symbol *DeclareOrMarkOtherAccessEntity(const parser::Name &, Symbol::Flag);
286       const parser::Name &, const Symbol &, Symbol::Flag);
287   void AllowOnlyArrayAndSubArray(const parser::AccObjectList &objectList);
288   void DoNotAllowAssumedSizedArray(const parser::AccObjectList &objectList);
289   void AllowOnlyVariable(const parser::AccObject &object);
291       const llvm::acc::Clause clause, const parser::AccObjectList &objectList);
293       Symbol &, const parser::OpenACCRoutineConstruct &);
303   template <typename A> void Walk(const A &x) { parser::Walk(x, *this); }
307   template <typename A> bool Pre(const parser::Statement<A> &statement) {
330   bool Pre(const parser::InternalSubprogram &) {
336   bool Pre(const parser::ModuleSubprogram &) {
342   bool Pre(const parser::StmtFunctionStmt &x) {
343     const auto &parsedExpr{std::get<parser::Scalar<parser::Expr>>(x.t)};
354   bool Pre(const parser::OmpDirectiveSpecification &x) {
358   void Post(const parser::OmpDirectiveSpecification &) { PopContext(); }
359   bool Pre(const parser::OmpMetadirectiveDirective &x) {
363   void Post(const parser::OmpMetadirectiveDirective &) { PopContext(); }
365   bool Pre(const parser::OpenMPBlockConstruct &);
366   void Post(const parser::OpenMPBlockConstruct &);
368   void Post(const parser::OmpBeginBlockDirective &) {
372   bool Pre(const parser::OpenMPSimpleStandaloneConstruct &);
373   void Post(const parser::OpenMPSimpleStandaloneConstruct &) { PopContext(); }
375   bool Pre(const parser::OpenMPLoopConstruct &);
376   void Post(const parser::OpenMPLoopConstruct &) { PopContext(); }
377   void Post(const parser::OmpBeginLoopDirective &) {
380   bool Pre(const parser::DoConstruct &);
382   bool Pre(const parser::OpenMPSectionsConstruct &);
383   void Post(const parser::OpenMPSectionsConstruct &) { PopContext(); }
385   bool Pre(const parser::OpenMPCriticalConstruct &critical);
386   void Post(const parser::OpenMPCriticalConstruct &) { PopContext(); }
388   bool Pre(const parser::OpenMPDeclareSimdConstruct &x) {
390     const auto &name{std::get<std::optional<parser::Name>>(x.t)};
396   void Post(const parser::OpenMPDeclareSimdConstruct &) { PopContext(); }
398   bool Pre(const parser::OpenMPDepobjConstruct &x) {
400     auto &object{std::get<parser::OmpObject>(x.t)};
404   void Post(const parser::OpenMPDepobjConstruct &) { PopContext(); }
406   bool Pre(const parser::OpenMPRequiresConstruct &x) {
414     for (const auto &clause : std::get<parser::OmpClauseList>(x.t).v) {
418                   const parser::OmpClause::AtomicDefaultMemOrder &atomic) {
422               [](const parser::OmpClause::ReverseOffload &) {
425               [](const parser::OmpClause::UnifiedAddress &) {
428               [](const parser::OmpClause::UnifiedSharedMemory &) {
431               [](const parser::OmpClause::DynamicAllocators &) {
441   void Post(const parser::OpenMPRequiresConstruct &) { PopContext(); }
443   bool Pre(const parser::OpenMPDeclareTargetConstruct &);
444   void Post(const parser::OpenMPDeclareTargetConstruct &) { PopContext(); }
446   bool Pre(const parser::OpenMPDeclareMapperConstruct &);
447   void Post(const parser::OpenMPDeclareMapperConstruct &) { PopContext(); }
449   bool Pre(const parser::OpenMPThreadprivate &);
450   void Post(const parser::OpenMPThreadprivate &) { PopContext(); }
452   bool Pre(const parser::OpenMPDeclarativeAllocate &);
453   void Post(const parser::OpenMPDeclarativeAllocate &) { PopContext(); }
455   bool Pre(const parser::OpenMPDispatchConstruct &);
456   void Post(const parser::OpenMPDispatchConstruct &) { PopContext(); }
458   bool Pre(const parser::OpenMPExecutableAllocate &);
459   void Post(const parser::OpenMPExecutableAllocate &);
461   bool Pre(const parser::OpenMPAllocatorsConstruct &);
462   void Post(const parser::OpenMPAllocatorsConstruct &);
464   void Post(const parser::OmpObjectList &x) {
467     // parser::Name, those are dealt with as members of other structures).
470     for (const parser::OmpObject &obj : x.v) {
471       auto *name{std::get_if<parser::Name>(&obj.u)};
479   bool Pre(const parser::OmpClause::Inclusive &x) {
483   bool Pre(const parser::OmpClause::Exclusive &x) {
487   void Post(const parser::OmpDefaultClause &);
488   bool Pre(const parser::OmpClause::Shared &x) {
492   bool Pre(const parser::OmpClause::Private &x) {
496   bool Pre(const parser::OmpAllocateClause &x) {
497     const auto &objectList{std::get<parser::OmpObjectList>(x.t)};
501   bool Pre(const parser::OmpClause::Firstprivate &x) {
505   bool Pre(const parser::OmpClause::Lastprivate &x) {
506     const auto &objList{std::get<parser::OmpObjectList>(x.v.t)};
510   bool Pre(const parser::OmpClause::Copyin &x) {
514   bool Pre(const parser::OmpClause::Copyprivate &x) {
518   bool Pre(const parser::OmpLinearClause &x) {
519     auto &objects{std::get<parser::OmpObjectList>(x.t)};
524   bool Pre(const parser::OmpClause::Reduction &x) {
525     const auto &objList{std::get<parser::OmpObjectList>(x.v.t)};
529       auto createDummyProcSymbol = [&](const parser::Name *name) {
541         if (!std::holds_alternative<parser::OmpReductionIdentifier>(mod.u)) {
544         auto &opr{std::get<parser::OmpReductionIdentifier>(mod.u)};
545         if (auto *procD{parser::Unwrap<parser::ProcedureDesignator>(opr.u)}) {
546           if (auto *name{parser::Unwrap<parser::Name>(procD->u)}) {
554                   parser::Unwrap<parser::ProcComponentRef>(procD->u)}) {
563       using ReductionModifier = parser::OmpReductionModifier;
574   bool Pre(const parser::OmpAlignedClause &x) {
575     const auto &alignedNameList{std::get<parser::OmpObjectList>(x.t)};
580   bool Pre(const parser::OmpClause::Nontemporal &x) {
586   void Post(const parser::OmpIteration &x) {
587     if (const auto &name{std::get<parser::Name>(x.t)}; !name.symbol) {
599   bool Pre(const parser::OmpClause::UseDevicePtr &x) {
604   bool Pre(const parser::OmpClause::UseDeviceAddr &x) {
609   bool Pre(const parser::OmpClause::IsDevicePtr &x) {
614   bool Pre(const parser::OmpClause::HasDeviceAddr &x) {
619   void Post(const parser::Name &);
622   void Post(const parser::GotoStmt &gotoStmt) { CheckSourceLabel(gotoStmt.v); }
623   void Post(const parser::ComputedGotoStmt &computedGotoStmt) {
624     for (auto &label : std::get<std::list<parser::Label>>(computedGotoStmt.t)) {
628   void Post(const parser::ArithmeticIfStmt &arithmeticIfStmt) {
633   void Post(const parser::AssignedGotoStmt &assignedGotoStmt) {
634     for (auto &label : std::get<std::list<parser::Label>>(assignedGotoStmt.t)) {
638   void Post(const parser::AltReturnSpec &altReturnSpec) {
641   void Post(const parser::ErrLabel &errLabel) { CheckSourceLabel(errLabel.v); }
642   void Post(const parser::EndLabel &endLabel) { CheckSourceLabel(endLabel.v); }
643   void Post(const parser::EorLabel &eorLabel) { CheckSourceLabel(eorLabel.v); }
645   void Post(const parser::OmpMapClause &x) {
648     if (auto *mapType{OmpGetUniqueModifier<parser::OmpMapType>(mods)}) {
650       case parser::OmpMapType::Value::To:
653       case parser::OmpMapType::Value::From:
656       case parser::OmpMapType::Value::Tofrom:
659       case parser::OmpMapType::Value::Alloc:
662       case parser::OmpMapType::Value::Release:
665       case parser::OmpMapType::Value::Delete:
670     const auto &ompObjList{std::get<parser::OmpObjectList>(x.t)};
674               [&](const parser::Designator &designator) {
698   const parser::OmpClause *associatedClause{nullptr};
699   void SetAssociatedClause(const parser::OmpClause &c) {
702   const parser::OmpClause *GetAssociatedClause() { return associatedClause; }
705   std::int64_t GetAssociatedLoopLevelFromClauses(const parser::OmpClauseList &);
729   std::vector<const parser::Name *> allocateNames_; // on one directive
732   std::multimap<const parser::Label,
733       std::pair<parser::CharBlock, std::optional<DirContext>>>
735   std::map<const parser::Label,
736       std::pair<parser::CharBlock, std::optional<DirContext>>>
738   parser::CharBlock currentStatementSource_;
740   void AddAllocateName(const parser::Name *&object) {
754       const parser::OpenMPLoopConstruct &);
755   void ResolveSeqLoopIndexInParallelOrTaskConstruct(const parser::Name &);
758   void ResolveOmpObjectList(const parser::OmpObjectList &, Symbol::Flag);
759   void ResolveOmpObject(const parser::OmpObject &, Symbol::Flag);
760   Symbol *ResolveOmp(const parser::Name &, Symbol::Flag, Scope &);
762   Symbol *ResolveOmpCommonBlockName(const parser::Name *);
763   void ResolveOmpNameList(const std::list<parser::Name> &, Symbol::Flag);
764   void ResolveOmpName(const parser::Name &, Symbol::Flag);
765   Symbol *ResolveName(const parser::Name *);
766   Symbol *ResolveOmpObjectScope(const parser::Name *);
767   Symbol *DeclareOrMarkOtherAccessEntity(const parser::Name &, Symbol::Flag);
770       const parser::Name &, const Symbol &, Symbol::Flag);
773       const parser::Name &, const Symbol &, Symbol::Flag);
774   void CheckAssocLoopLevel(std::int64_t level, const parser::OmpClause *clause);
776       const parser::Name &, const Symbol &, Symbol::Flag);
777   void CheckSourceLabel(const parser::Label &);
778   void CheckLabelContext(const parser::CharBlock, const parser::CharBlock,
784   void CheckAllNamesInAllocateStmt(const parser::CharBlock &source,
785       const parser::OmpObjectList &ompObjectList,
786       const parser::AllocateStmt &allocate);
787   void CheckNameInAllocateStmt(const parser::CharBlock &source,
788       const parser::Name &ompObject, const parser::AllocateStmt &allocate);
795       llvm::omp::Directive D, parser::CharBlock source);
809 const parser::Name *DirectiveAttributeVisitor<T>::GetLoopIndex(
810     const parser::DoConstruct &x) {
811   using Bounds = parser::LoopControl::Bounds;
820         .Say(std::get<parser::Statement<parser::NonLabelDoStmt>>(x.t).source,
829 const parser::DoConstruct *DirectiveAttributeVisitor<T>::GetDoConstructIf(
830     const parser::ExecutionPartConstruct &x) {
831   return parser::Unwrap<parser::DoConstruct>(x);
849     const parser::Name &name, Symbol::Flag flag, Scope &scope) {
868 bool AccAttributeVisitor::Pre(const parser::OpenACCBlockConstruct &x) {
869   const auto &beginBlockDir{std::get<parser::AccBeginBlockDirective>(x.t)};
870   const auto &blockDir{std::get<parser::AccBlockDirective>(beginBlockDir.t)};
886 bool AccAttributeVisitor::Pre(const parser::OpenACCDeclarativeConstruct &x) {
888           std::get_if<parser::OpenACCStandaloneDeclarativeConstruct>(&x.u)}) {
890         std::get<parser::AccDeclarativeDirective>(declConstruct->t)};
897 static const parser::AccObjectList &GetAccObjectList(
898     const parser::AccClause &clause) {
900           std::get_if<Fortran::parser::AccClause::Copy>(&clause.u)) {
903                  std::get_if<Fortran::parser::AccClause::Create>(&clause.u)) {
904     const Fortran::parser::AccObjectListWithModifier &listWithModifier =
906     const Fortran::parser::AccObjectList &accObjectList =
907         std::get<Fortran::parser::AccObjectList>(listWithModifier.t);
910                  std::get_if<Fortran::parser::AccClause::Copyin>(&clause.u)) {
911     const Fortran::parser::AccObjectListWithModifier &listWithModifier =
913     const Fortran::parser::AccObjectList &accObjectList =
914         std::get<Fortran::parser::AccObjectList>(listWithModifier.t);
917                  std::get_if<Fortran::parser::AccClause::Copyout>(&clause.u)) {
918     const Fortran::parser::AccObjectListWithModifier &listWithModifier =
920     const Fortran::parser::AccObjectList &accObjectList =
921         std::get<Fortran::parser::AccObjectList>(listWithModifier.t);
924                  std::get_if<Fortran::parser::AccClause::Present>(&clause.u)) {
927                  std::get_if<Fortran::parser::AccClause::Deviceptr>(
931                  std::get_if<Fortran::parser::AccClause::DeviceResident>(
935                  std::get_if<Fortran::parser::AccClause::Link>(&clause.u)) {
943     const parser::OpenACCStandaloneDeclarativeConstruct &x) {
944   const auto &clauseList = std::get<parser::AccClauseList>(x.t);
951 bool AccAttributeVisitor::Pre(const parser::OpenACCLoopConstruct &x) {
952   const auto &beginDir{std::get<parser::AccBeginLoopDirective>(x.t)};
953   const auto &loopDir{std::get<parser::AccLoopDirective>(beginDir.t)};
954   const auto &clauseList{std::get<parser::AccClauseList>(beginDir.t)};
960   const auto &outer{std::get<std::optional<parser::DoConstruct>>(x.t)};
965 bool AccAttributeVisitor::Pre(const parser::OpenACCStandaloneConstruct &x) {
966   const auto &standaloneDir{std::get<parser::AccStandaloneDirective>(x.t)};
984     const parser::Name &name, bool parentScope) {
996 Symbol *AccAttributeVisitor::ResolveFctName(const parser::Name &name) {
1025     Symbol &symbol, const parser::OpenACCRoutineConstruct &x) {
1028     const auto &clauses = std::get<Fortran::parser::AccClauseList>(x.t);
1029     for (const Fortran::parser::AccClause &clause : clauses.v) {
1030       if (std::get_if<Fortran::parser::AccClause::Seq>(&clause.u)) {
1037                      std::get_if<Fortran::parser::AccClause::Gang>(&clause.u)) {
1044           const Fortran::parser::AccGangArgList &x = *gangClause->v;
1045           for (const Fortran::parser::AccGangArg &gangArg : x.v) {
1047                     std::get_if<Fortran::parser::AccGangArg::Dim>(&gangArg.u)) {
1058       } else if (std::get_if<Fortran::parser::AccClause::Vector>(&clause.u)) {
1064       } else if (std::get_if<Fortran::parser::AccClause::Worker>(&clause.u)) {
1070       } else if (std::get_if<Fortran::parser::AccClause::Nohost>(&clause.u)) {
1073                      std::get_if<Fortran::parser::AccClause::Bind>(&clause.u)) {
1075                 std::get_if<Fortran::parser::Name>(&bindClause->v.u)) {
1089                        std::get_if<Fortran::parser::ScalarDefaultCharExpr>(
1092               Fortran::parser::Unwrap<Fortran::parser::CharLiteralConstant>(
1104                      std::get_if<Fortran::parser::AccClause::DeviceType>(
1106         const parser::AccDeviceTypeExprList &deviceTypeExprList = dType->v;
1116 bool AccAttributeVisitor::Pre(const parser::OpenACCRoutineConstruct &x) {
1117   const auto &verbatim{std::get<parser::Verbatim>(x.t)};
1124   const auto &optName{std::get<std::optional<parser::Name>>(x.t)};
1142 bool AccAttributeVisitor::Pre(const parser::AccBindClause &x) {
1143   if (const auto *name{std::get_if<parser::Name>(&x.u)}) {
1153 bool AccAttributeVisitor::Pre(const parser::OpenACCCombinedConstruct &x) {
1154   const auto &beginBlockDir{std::get<parser::AccBeginCombinedDirective>(x.t)};
1156       std::get<parser::AccCombinedDirective>(beginBlockDir.t)};
1166   const auto &clauseList{std::get<parser::AccClauseList>(beginBlockDir.t)};
1168   const auto &outer{std::get<std::optional<parser::DoConstruct>>(x.t)};
1174 static bool IsLastNameArray(const parser::Designator &designator) {
1193     const parser::AccObjectList &objectList) {
1197             [&](const parser::Designator &designator) {
1201                     parser::ToUpperCaseLetters(
1210                   parser::ToUpperCaseLetters(
1220     const parser::AccObjectList &objectList) {
1224             [&](const parser::Designator &designator) {
1230                     parser::ToUpperCaseLetters(
1244 void AccAttributeVisitor::AllowOnlyVariable(const parser::AccObject &object) {
1247           [&](const parser::Designator &designator) {
1254                   parser::ToUpperCaseLetters(
1264 bool AccAttributeVisitor::Pre(const parser::OpenACCCacheConstruct &x) {
1265   const auto &verbatim{std::get<parser::Verbatim>(x.t)};
1270       std::get<parser::AccObjectListWithModifier>(x.t);
1272       std::get<Fortran::parser::AccObjectList>(objectListWithModifier.t);
1282     const parser::AccClauseList &x) {
1286             std::get_if<parser::AccClause::Collapse>(&clause.u)}) {
1287       const parser::AccCollapseArg &arg = collapseClause->v;
1288       const auto &collapseValue{std::get<parser::ScalarIntConstantExpr>(arg.t)};
1302     const parser::DoConstruct &outerDoConstruct) {
1309       [this](const parser::Block &block,
1310           std::int64_t &level) -> const parser::DoConstruct * {
1314       } else if (parser::Unwrap<parser::CompilerDirective>(entry)) {
1318                      parser::Unwrap<parser::OpenACCLoopConstruct>(entry)}) {
1322             std::get<parser::AccBeginLoopDirective>(accLoop->t)};
1345   using Bounds = parser::LoopControl::Bounds;
1346   for (const parser::DoConstruct *loop{&outerDoConstruct}; loop && level > 0;) {
1348     if (const parser::Name * ivName{GetLoopIndex(*loop)}) {
1368     const auto &block{std::get<parser::Block>(loop->t)};
1376     const llvm::acc::Clause clause, const parser::AccObjectList &objectList) {
1380             [&](const parser::Designator &designator) {
1387                     parser::ToUpperCaseLetters(
1395                   parser::ToUpperCaseLetters(
1403 bool AccAttributeVisitor::Pre(const parser::AccClause::Attach &x) {
1409 bool AccAttributeVisitor::Pre(const parser::AccClause::Detach &x) {
1415 void AccAttributeVisitor::Post(const parser::AccDefaultClause &x) {
1430 void AccAttributeVisitor::Post(const parser::Name &name) {
1451     const parser::Name *name) {
1468     const parser::AccObjectList &accObjectList, Symbol::Flag accFlag) {
1476     const parser::AccObject &accObject, Symbol::Flag accFlag) {
1479           [&](const parser::Designator &designator) {
1491                 if (std::holds_alternative<parser::Substring>(designator.u)) {
1500           [&](const parser::Name &name) { // common block
1521     const parser::Name &name, Symbol::Flag accFlag, Scope &scope) {
1531     const parser::Name &name, Symbol::Flag accFlag) {
1558     const parser::Name &name, const Symbol &symbol, Symbol::Flag accFlag) {
1571 bool OmpAttributeVisitor::Pre(const parser::OpenMPBlockConstruct &x) {
1572   const auto &beginBlockDir{std::get<parser::OmpBeginBlockDirective>(x.t)};
1573   const auto &beginDir{std::get<parser::OmpBlockDirective>(beginBlockDir.t)};
1607 void OmpAttributeVisitor::Post(const parser::OpenMPBlockConstruct &x) {
1608   const auto &beginBlockDir{std::get<parser::OmpBeginBlockDirective>(x.t)};
1609   const auto &beginDir{std::get<parser::OmpBlockDirective>(beginBlockDir.t)};
1651     const parser::OpenMPSimpleStandaloneConstruct &x) {
1653       std::get<parser::OmpSimpleStandaloneDirective>(x.t)};
1672 bool OmpAttributeVisitor::Pre(const parser::OpenMPLoopConstruct &x) {
1673   const auto &beginLoopDir{std::get<parser::OmpBeginLoopDirective>(x.t)};
1674   const auto &beginDir{std::get<parser::OmpLoopDirective>(beginLoopDir.t)};
1675   const auto &clauseList{std::get<parser::OmpClauseList>(beginLoopDir.t)};
1730             std::get<std::optional<parser::DoConstruct>>(x.t)}) {
1742     const parser::Name &iv) {
1794 bool OmpAttributeVisitor::Pre(const parser::DoConstruct &x) {
1796     llvm::SmallVector<const parser::Name *> ivs;
1798       const parser::Name *iv{GetLoopIndex(x)};
1825     const parser::OmpClauseList &x) {
1829   const parser::OmpClause *ordClause{nullptr};
1830   const parser::OmpClause *collClause{nullptr};
1834             std::get_if<parser::OmpClause::Ordered>(&clause.u)}) {
1841             std::get_if<parser::OmpClause::Collapse>(&clause.u)}) {
1868     const parser::OpenMPLoopConstruct &x) {
1882   const auto &outer{std::get<std::optional<parser::DoConstruct>>(x.t)};
1884     for (const parser::DoConstruct *loop{&*outer}; loop && level > 0; --level) {
1886       const parser::Name *iv{GetLoopIndex(*loop)};
1894         const auto &block{std::get<parser::Block>(loop->t)};
1903         parser::ToUpperCaseLetters(
1908     std::int64_t level, const parser::OmpClause *clause) {
1917 bool OmpAttributeVisitor::Pre(const parser::OpenMPSectionsConstruct &x) {
1919       std::get<parser::OmpBeginSectionsDirective>(x.t)};
1921       std::get<parser::OmpSectionsDirective>(beginSectionsDir.t)};
1935 bool OmpAttributeVisitor::Pre(const parser::OpenMPCriticalConstruct &x) {
1936   const auto &beginCriticalDir{std::get<parser::OmpCriticalDirective>(x.t)};
1937   const auto &endCriticalDir{std::get<parser::OmpEndCriticalDirective>(x.t)};
1941           std::get<std::optional<parser::Name>>(beginCriticalDir.t)}) {
1945           std::get<std::optional<parser::Name>>(endCriticalDir.t)}) {
1951 bool OmpAttributeVisitor::Pre(const parser::OpenMPDeclareTargetConstruct &x) {
1953   const auto &spec{std::get<parser::OmpDeclareTargetSpecifier>(x.t)};
1954   if (const auto *objectList{parser::Unwrap<parser::OmpObjectList>(spec.u)}) {
1957                  parser::Unwrap<parser::OmpClauseList>(spec.u)}) {
1959       if (const auto *toClause{std::get_if<parser::OmpClause::To>(&clause.u)}) {
1960         auto &objList{std::get<parser::OmpObjectList>(toClause->v.t)};
1963                      std::get_if<parser::OmpClause::Link>(&clause.u)}) {
1966                      std::get_if<parser::OmpClause::Enter>(&clause.u)}) {
1974 bool OmpAttributeVisitor::Pre(const parser::OpenMPDeclareMapperConstruct &x) {
1979 bool OmpAttributeVisitor::Pre(const parser::OpenMPThreadprivate &x) {
1981   const auto &list{std::get<parser::OmpObjectList>(x.t)};
1986 bool OmpAttributeVisitor::Pre(const parser::OpenMPDeclarativeAllocate &x) {
1988   const auto &list{std::get<parser::OmpObjectList>(x.t)};
1993 bool OmpAttributeVisitor::Pre(const parser::OpenMPDispatchConstruct &x) {
1998 bool OmpAttributeVisitor::Pre(const parser::OpenMPExecutableAllocate &x) {
2000   const auto &list{std::get<std::optional<parser::OmpObjectList>>(x.t)};
2007 bool OmpAttributeVisitor::Pre(const parser::OpenMPAllocatorsConstruct &x) {
2009   const auto &clauseList{std::get<parser::OmpClauseList>(x.t)};
2012             std::get_if<parser::OmpClause::Allocate>(&clause.u)}) {
2013       ResolveOmpObjectList(std::get<parser::OmpObjectList>(allocClause->v.t),
2020 void OmpAttributeVisitor::Post(const parser::OmpDefaultClause &x) {
2023   using DataSharingAttribute = parser::OmpDefaultClause::DataSharingAttribute;
2055 void OmpAttributeVisitor::Post(const parser::OpenMPExecutableAllocate &x) {
2058   // parser::Unwrap instead of the following loop
2059   const auto &clauseList{std::get<parser::OmpClauseList>(x.t)};
2061     if (std::get_if<parser::OmpClause::Allocator>(&clause.u)) {
2076       std::get<parser::Statement<parser::AllocateStmt>>(x.t).statement;
2077   if (const auto &list{std::get<std::optional<parser::OmpObjectList>>(x.t)}) {
2079         std::get<parser::Verbatim>(x.t).source, *list, allocateStmt);
2082           std::get<std::optional<std::list<parser::OpenMPDeclarativeAllocate>>>(
2085       CheckAllNamesInAllocateStmt(std::get<parser::Verbatim>(dalloc.t).source,
2086           std::get<parser::OmpObjectList>(dalloc.t), allocateStmt);
2092 void OmpAttributeVisitor::Post(const parser::OpenMPAllocatorsConstruct &x) {
2093   const auto &dir{std::get<parser::Verbatim>(x.t)};
2094   const auto &clauseList{std::get<parser::OmpClauseList>(x.t)};
2097             std::get_if<parser::OmpClause::Allocate>(&clause.u)}) {
2099           std::get<parser::OmpObjectList>(alloc->v.t),
2100           std::get<parser::Statement<parser::AllocateStmt>>(x.t).statement);
2104           OmpGetUniqueModifier<parser::OmpAllocatorSimpleModifier>(modifiers) ||
2105           OmpGetUniqueModifier<parser::OmpAllocatorComplexModifier>(modifiers)};
2278 void OmpAttributeVisitor::Post(const parser::Name &name) {
2320 Symbol *OmpAttributeVisitor::ResolveName(const parser::Name *name) {
2331     const parser::Name &name, Symbol::Flag ompFlag) {
2347     const std::list<parser::Name> &nameList, Symbol::Flag ompFlag) {
2354     const parser::Name *name) {
2371 Symbol *OmpAttributeVisitor::ResolveOmpObjectScope(const parser::Name *name) {
2392     const parser::OmpObjectList &ompObjectList, Symbol::Flag ompFlag) {
2399     const parser::OmpObject &ompObject, Symbol::Flag ompFlag) {
2402           [&](const parser::Designator &designator) {
2420                             parser::ToUpperCaseLetters(
2456                       parser::ToUpperCaseLetters(
2535                 if (std::holds_alternative<parser::Substring>(designator.u)) {
2544           [&](const parser::Name &name) { // common block
2578     const parser::Name &name, Symbol::Flag ompFlag, Scope &scope) {
2596     const parser::Name &name, Symbol::Flag ompFlag) {
2623     const parser::Name &name, const Symbol &symbol, Symbol::Flag ompFlag) {
2644 void ResolveAccParts(SemanticsContext &context, const parser::ProgramUnit &node,
2652     SemanticsContext &context, const parser::ProgramUnit &node) {
2667     SemanticsContext &context, const parser::Program &program) {
2682     for (const parser::ProgramUnit &unit : program.v) {
2683       if (!std::holds_alternative<common::Indirection<parser::Module>>(
2685           !std::holds_alternative<common::Indirection<parser::Submodule>>(
2688               common::Indirection<parser::CompilerDirective>>(unit.u)) {
2726             parser::ToUpperCaseLetters(llvm::omp::getOpenMPClauseName(
2791     const parser::Name &name, const Symbol &symbol, Symbol::Flag ompFlag) {
2823     const parser::Name &name, const Symbol &symbol, Symbol::Flag ompFlag) {
2853 void OmpAttributeVisitor::CheckSourceLabel(const parser::Label &label) {
2871 void OmpAttributeVisitor::CheckLabelContext(const parser::CharBlock source,
2872     const parser::CharBlock target, std::optional<DirContext> sourceContext,
2882             parser::ToUpperCaseLetters(
2895             parser::ToUpperCaseLetters(
2904     const parser::CharBlock &source, const parser::OmpObjectList &ompObjectList,
2905     const parser::AllocateStmt &allocate) {
2907     if (const auto *d{std::get_if<parser::Designator>(&obj.u)}) {
2908       if (const auto *ref{std::get_if<parser::DataRef>(&d->u)}) {
2909         if (const auto *n{std::get_if<parser::Name>(&ref->u)}) {
2918     const parser::CharBlock &source, const parser::Name &name,
2919     const parser::AllocateStmt &allocate) {
2921       std::get<std::list<parser::Allocation>>(allocate.t)) {
2922     const auto &allocObj = std::get<parser::AllocateObject>(allocation.t);
2923     if (const auto *n{std::get_if<parser::Name>(&allocObj.u)}) {
2933       parser::ToUpperCaseLetters(
2962                       parser::ToUpperCaseLetters(llvm::omp::getOpenMPClauseName(
2977     llvm::omp::Directive D, parser::CharBlock source) {
2981             << parser::ToUpperCaseLetters(