R10: Re-implementing a few checks by removing stack

Author: anchuraj

flang/include/flang/Semantics/symbol.h

@@ -755,7 +755,8 @@ class Symbol {
       OmpDeclarativeAllocateDirective, OmpExecutableAllocateDirective,
       OmpDeclareSimd, OmpDeclareTarget, OmpThreadprivate, OmpDeclareReduction,
       OmpFlushed, OmpCriticalLock, OmpIfSpecified, OmpNone, OmpPreDetermined,
-      OmpImplicit, OmpDependObject, OmpInclusiveScan, OmpExclusiveScan);
+      OmpImplicit, OmpDependObject, OmpInclusiveScan, OmpExclusiveScan,
+      OmpInScanReduction);
   using Flags = common::EnumSet<Flag, Flag_enumSize>;
 
   const Scope &owner() const { return *owner_; }

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

@@ -990,9 +990,9 @@ void OmpStructureChecker::Leave(const parser::OpenMPLoopConstruct &x) {
         const auto &objectList{
             std::get<parser::OmpObjectList>(reductionClause->v.t)};
         auto checkReductionSymbolInScan = [&](const parser::Name *name) {
-          if (name->symbol) {
-            if (!scanReductionInfoStack.top().findSymbolInScanConstruct(
-                    name->symbol)) {
+          if (auto &symbol = name->symbol) {
+            if (!symbol->test(Symbol::Flag::OmpInclusiveScan) &&
+                !symbol->test(Symbol::Flag::OmpExclusiveScan)) {
               context_.Say(name->source,
                   "List item %s must appear in EXCLUSIVE or "
                   "INCLUSIVE clause of an "
@@ -1014,7 +1014,6 @@ void OmpStructureChecker::Leave(const parser::OpenMPLoopConstruct &x) {
               },
               ompObj.u);
         }
-        scanReductionInfoStack.pop();
       }
     }
   }
@@ -2740,12 +2739,14 @@ CHECK_SIMPLE_CLAUSE(Depobj, OMPC_depobj)
 CHECK_SIMPLE_CLAUSE(Detach, OMPC_detach)
 CHECK_SIMPLE_CLAUSE(DeviceType, OMPC_device_type)
 CHECK_SIMPLE_CLAUSE(DistSchedule, OMPC_dist_schedule)
+CHECK_SIMPLE_CLAUSE(Exclusive, OMPC_exclusive)
 CHECK_SIMPLE_CLAUSE(Final, OMPC_final)
 CHECK_SIMPLE_CLAUSE(Flush, OMPC_flush)
 CHECK_SIMPLE_CLAUSE(Full, OMPC_full)
 CHECK_SIMPLE_CLAUSE(Grainsize, OMPC_grainsize)
 CHECK_SIMPLE_CLAUSE(Hint, OMPC_hint)
 CHECK_SIMPLE_CLAUSE(Holds, OMPC_holds)
+CHECK_SIMPLE_CLAUSE(Inclusive, OMPC_inclusive)
 CHECK_SIMPLE_CLAUSE(InReduction, OMPC_in_reduction)
 CHECK_SIMPLE_CLAUSE(Match, OMPC_match)
 CHECK_SIMPLE_CLAUSE(Nontemporal, OMPC_nontemporal)
@@ -2842,26 +2843,10 @@ void OmpStructureChecker::Enter(const parser::OmpClause::Reduction &x) {
   if (const auto &maybeModifier{
           std::get<std::optional<ReductionModifier>>(x.v.t)}) {
     const ReductionModifier modifier{*maybeModifier};
-    if (modifier == ReductionModifier::Inscan) {
-      scanReductionInfoStack.emplace();
-      const auto &ompObjectList{std::get<parser::OmpObjectList>(x.v.t)};
-      scanReductionInfoStack.top().mapSymbolsToReductionModifiers(
-          ompObjectList, modifier);
-    }
     CheckReductionModifier(modifier);
   }
 }
 
-void OmpStructureChecker::Enter(const parser::OmpClause::Inclusive &x) {
-  CheckAllowed(llvm::omp::Clause::OMPC_inclusive);
-  CheckAndMarkSymbolsUsedInScan(x.v);
-}
-
-void OmpStructureChecker::Enter(const parser::OmpClause::Exclusive &x) {
-  CheckAllowed(llvm::omp::Clause::OMPC_exclusive);
-  CheckAndMarkSymbolsUsedInScan(x.v);
-}
-
 bool OmpStructureChecker::CheckReductionOperators(
     const parser::OmpClause::Reduction &x) {
 
@@ -2903,41 +2888,6 @@ bool OmpStructureChecker::CheckReductionOperators(
   return ok;
 }
 
-void OmpStructureChecker::CheckAndMarkSymbolsUsedInScan(
-    const parser::OmpObjectList &x) {
-  for (const auto &ompObj : x.v) {
-    auto checkAndMark = [&](const parser::Name *name) {
-      if (name->symbol) {
-        if (CurrentDirectiveIsNested()) {
-          ScanReductionInfo &scanReductionInfo = scanReductionInfoStack.top();
-          std::optional<ReductionModifier> reductionMod =
-              scanReductionInfo.findReductionModifier(name->symbol);
-          if (!reductionMod.has_value() ||
-              reductionMod.value() != ReductionModifier::Inscan) {
-            context_.Say(name->source,
-                "List item %s must appear in REDUCTION clause "
-                "with the INSCAN modifier of the parent "
-                "directive"_err_en_US,
-                name->ToString());
-          }
-          scanReductionInfo.markSymbolAsUsedInScanConstruct(name->symbol);
-        }
-      }
-    };
-    common::visit(
-        common::visitors{
-            [&](const parser::Designator &designator) {
-              if (const auto *name{
-                      semantics::getDesignatorNameIfDataRef(designator)}) {
-                checkAndMark(name);
-              }
-            },
-            [&](const auto &name) { checkAndMark(&name); },
-        },
-        ompObj.u);
-  }
-}
-
 bool OmpStructureChecker::CheckIntrinsicOperator(
     const parser::DefinedOperator::IntrinsicOperator &op) {
 

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

@@ -20,8 +20,6 @@
 #include "flang/Semantics/openmp-directive-sets.h"
 #include "flang/Semantics/semantics.h"
 #include "llvm/Frontend/OpenMP/OMPConstants.h"
-#include <optional>
-#include <stack>
 
 using OmpClauseSet =
     Fortran::common::EnumSet<llvm::omp::Clause, llvm::omp::Clause_enumSize>;
@@ -73,42 +71,6 @@ class OmpStructureChecker
   }
   using llvmOmpClause = const llvm::omp::Clause;
   using ReductionModifier = parser::OmpReductionClause::ReductionModifier;
-  using Symbol = Fortran::semantics::Symbol;
-  class ScanReductionInfo {
-    std::set<Symbol *> usedInScan;
-    std::map<Symbol *, ReductionModifier> reductionMod;
-
-  public:
-    void mapSymbolsToReductionModifiers(
-        const parser::OmpObjectList &x, const ReductionModifier &modifier) {
-      for (const auto &ompObject : x.v) {
-        if (const auto *name{parser::Unwrap<parser::Name>(ompObject)}) {
-          if (const auto &symbol{name->symbol}) {
-            reductionMod[symbol] = modifier;
-          }
-        }
-      }
-    }
-
-    void markSymbolAsUsedInScanConstruct(Symbol *sym) {
-      usedInScan.insert(sym);
-    }
-
-    bool findSymbolInScanConstruct(Symbol *sym) {
-      if (usedInScan.find(sym) != usedInScan.end()) {
-        return true;
-      }
-      return false;
-    }
-
-    std::optional<ReductionModifier> findReductionModifier(Symbol *sym) {
-      if (reductionMod.find(sym) != reductionMod.end()) {
-        return reductionMod[sym];
-      }
-      return std::nullopt;
-    }
-  };
-  std::stack<class ScanReductionInfo> scanReductionInfoStack;
 
   void Enter(const parser::OpenMPConstruct &);
   void Leave(const parser::OpenMPConstruct &);
@@ -287,7 +249,6 @@ class OmpStructureChecker
       const parser::OmpObjectList &ompObjectList);
   void CheckPredefinedAllocatorRestriction(
       const parser::CharBlock &source, const parser::Name &name);
-  void CheckAndMarkSymbolsUsedInScan(const parser::OmpObjectList &x);
   bool isPredefinedAllocator{false};
 
   void CheckAllowedRequiresClause(llvmOmpClause clause);

flang/lib/Semantics/resolve-directives.cpp

@@ -546,6 +546,12 @@ class OmpAttributeVisitor : DirectiveAttributeVisitor<llvm::omp::Directive> {
     }
     const auto &objList{std::get<parser::OmpObjectList>(x.v.t)};
     ResolveOmpObjectList(objList, Symbol::Flag::OmpReduction);
+    using ReductionModifier = parser::OmpReductionClause::ReductionModifier;
+    const auto &maybeModifier{
+        std::get<std::optional<ReductionModifier>>(x.v.t)};
+    if (maybeModifier && *maybeModifier == ReductionModifier::Inscan) {
+      ResolveOmpObjectList(objList, Symbol::Flag::OmpInScanReduction);
+    }
     return false;
   }
 
@@ -702,7 +708,7 @@ class OmpAttributeVisitor : DirectiveAttributeVisitor<llvm::omp::Directive> {
 
   Symbol::Flags ompFlagsRequireMark{Symbol::Flag::OmpThreadprivate,
       Symbol::Flag::OmpDeclareTarget, Symbol::Flag::OmpExclusiveScan,
-      Symbol::Flag::OmpInclusiveScan};
+      Symbol::Flag::OmpInclusiveScan, Symbol::Flag::OmpInScanReduction};
 
   Symbol::Flags dataCopyingAttributeFlags{
       Symbol::Flag::OmpCopyIn, Symbol::Flag::OmpCopyPrivate};
@@ -2439,6 +2445,16 @@ void OmpAttributeVisitor::ResolveOmpObject(
                         name->ToString());
                   }
                 }
+                if (ompFlag == Symbol::Flag::OmpInclusiveScan ||
+                    ompFlag == Symbol::Flag::OmpExclusiveScan) {
+                  if (!symbol->test(Symbol::Flag::OmpInScanReduction)) {
+                    context_.Say(name->source,
+                        "List item %s must appear in REDUCTION clause "
+                        "with the INSCAN modifier of the parent "
+                        "directive"_err_en_US,
+                        name->ToString());
+                  }
+                }
                 if (GetContext().directive ==
                     llvm::omp::Directive::OMPD_target_data) {
                   checkExclusivelists(symbol, Symbol::Flag::OmpUseDevicePtr,

flang/test/Semantics/OpenMP/scan.f90

@@ -4,6 +4,7 @@ subroutine test_scan()
  integer x, y, k, z
 
  !ERROR: Orphaned SCAN directives are prohibited; perhaps you forgot to enclose the directive in to a WORKSHARING LOOP, a WORKSHARING LOOP SIMD or a SIMD directive.
+ !ERROR: List item x must appear in REDUCTION clause with the INSCAN modifier of the parent directive
  !$omp scan inclusive(x)
  !$omp parallel do simd
  do k = 1, n

flang/test/Semantics/OpenMP/scan1.f90

@@ -12,13 +12,13 @@ program omp_reduction
 
   ! CHECK: OtherConstruct scope
   ! CHECK: i (OmpPrivate, OmpPreDetermined): HostAssoc
-  ! CHECK: k (OmpReduction, OmpInclusiveScan): HostAssoc
+  ! CHECK: k (OmpReduction, OmpInclusiveScan, OmpInScanReduction): HostAssoc
   !$omp parallel do  reduction(inscan, +:k)
   do i=1,10
    !$omp scan inclusive(k)
   end do
   !$omp end parallel do
-  ! CHECK: m (OmpReduction, OmpExclusiveScan): HostAssoc
+  ! CHECK: m (OmpReduction, OmpExclusiveScan, OmpInScanReduction): HostAssoc
   !$omp parallel do  reduction(inscan, +:m)
   do i=1,10
    !$omp scan exclusive(m)