R8: converting string refs to symbol* and merging the new changes

Author: anchuraj

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

@@ -201,10 +201,6 @@ class DirectiveStructureChecker : public virtual BaseChecker {
     ClauseMapTy clauseInfo;
     std::list<C> actualClauses;
     std::list<C> crtGroup;
-    std::set<std::string> usedInScanDirective;
-
-    using ReductionModifier = parser::OmpReductionClause::ReductionModifier;
-    std::map<const std::string, ReductionModifier> reductionMod;
     Symbol *loopIV{nullptr};
   };
 

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

@@ -976,6 +976,12 @@ void OmpStructureChecker::CheckDistLinear(
 void OmpStructureChecker::Leave(const parser::OpenMPLoopConstruct &x) {
   const auto &beginLoopDir{std::get<parser::OmpBeginLoopDirective>(x.t)};
   const auto &clauseList{std::get<parser::OmpClauseList>(beginLoopDir.t)};
+
+  // A few semantic checks for InScan reduction are performed below as SCAN
+  // constructs inside LOOP may add the relevant information. Scan reduction is
+  // supported only in loop constructs, so same checks are not applicable to
+  // other directives.
+
   for (const auto &clause : clauseList.v) {
     if (const auto *reductionClause{
             std::get_if<parser::OmpClause::Reduction>(&clause.u)}) {
@@ -987,14 +993,13 @@ void OmpStructureChecker::Leave(const parser::OpenMPLoopConstruct &x) {
             std::get<parser::OmpObjectList>(reductionClause->v.t)};
         auto checkReductionSymbolInScan = [&](const parser::Name *name) {
           if (name->symbol) {
-            std::string nameStr = name->symbol->name().ToString();
-            if (GetContext().usedInScanDirective.find(nameStr) ==
-                GetContext().usedInScanDirective.end()) {
+            if (!scanReductionInfoStack.top().findSymbolInScanConstruct(
+                    name->symbol)) {
               context_.Say(name->source,
-                  "List item %s must appear in 'inclusive' or "
-                  "'exclusive' clause of an "
-                  "enclosed scan directive"_err_en_US,
-                  nameStr);
+                  "List item %s must appear in EXCLUSIVE or "
+                  "INCLUSIVE clause of an "
+                  "enclosed SCAN directive"_err_en_US,
+                  name->ToString());
             }
           }
         };
@@ -1011,6 +1016,7 @@ void OmpStructureChecker::Leave(const parser::OpenMPLoopConstruct &x) {
               },
               ompObj.u);
         }
+        scanReductionInfoStack.pop();
       }
     }
   }
@@ -1690,14 +1696,14 @@ void OmpStructureChecker::CheckScan(
     const parser::OpenMPSimpleStandaloneConstruct &x) {
   if (std::get<parser::OmpClauseList>(x.t).v.size() != 1) {
     context_.Say(x.source,
-        "Exactly one of `exclusive` or `inclusive` clause is expected"_err_en_US);
+        "Exactly one of EXCLUSIVE or INCLUSIVE clause is expected"_err_en_US);
   }
   if (!CurrentDirectiveIsNested() ||
       !llvm::omp::scanParentAllowedSet.test(GetContextParent().directive)) {
     context_.Say(x.source,
-        "Orphaned `omp scan` directives are prohibited; perhaps you forgot "
-        "to enclose the directive in to a worksharing loop, a worksharing "
-        "loop simd or a simd directive."_err_en_US);
+        "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."_err_en_US);
   }
 }
 
@@ -2838,20 +2844,24 @@ void OmpStructureChecker::Enter(const parser::OmpClause::Reduction &x) {
   if (const auto &maybeModifier{
           std::get<std::optional<ReductionModifier>>(x.v.t)}) {
     const ReductionModifier modifier{*maybeModifier};
-    const auto &ompObjectList{std::get<parser::OmpObjectList>(x.v.t)};
-    AddModifierToMap(ompObjectList, modifier);
+    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);
-  CheckAndAddSymbolsToUsedInScanList(x.v);
+  CheckAndMarkSymbolsUsedInScan(x.v);
 }
 
 void OmpStructureChecker::Enter(const parser::OmpClause::Exclusive &x) {
   CheckAllowed(llvm::omp::Clause::OMPC_exclusive);
-  CheckAndAddSymbolsToUsedInScanList(x.v);
+  CheckAndMarkSymbolsUsedInScan(x.v);
 }
 
 bool OmpStructureChecker::CheckReductionOperators(
@@ -2895,34 +2905,24 @@ bool OmpStructureChecker::CheckReductionOperators(
   return ok;
 }
 
-void OmpStructureChecker::AddModifierToMap(
-    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}) {
-        GetContext().reductionMod[symbol->name().ToString()] = modifier;
-      }
-    }
-  }
-}
-
-void OmpStructureChecker::CheckAndAddSymbolsToUsedInScanList(
+void OmpStructureChecker::CheckAndMarkSymbolsUsedInScan(
     const parser::OmpObjectList &x) {
   for (const auto &ompObj : x.v) {
-    auto checkScanSymbolInReduction = [&](const parser::Name *name) {
+    auto checkAndMark = [&](const parser::Name *name) {
       if (name->symbol) {
         if (CurrentDirectiveIsNested()) {
-          std::string nameStr = name->symbol->name().ToString();
-          if (GetContextParent().reductionMod.find(nameStr) ==
-              GetContextParent().reductionMod.end()) {
-
+          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 "
+                "List item %s must appear in REDUCTION clause "
+                "with the INSCAN modifier of the parent "
                 "directive"_err_en_US,
-                nameStr);
+                name->ToString());
           }
-          GetContextParent().usedInScanDirective.insert(nameStr);
+          scanReductionInfo.markSymbolAsUsedInScanConstruct(name->symbol);
         }
       }
     };
@@ -2931,10 +2931,10 @@ void OmpStructureChecker::CheckAndAddSymbolsToUsedInScanList(
             [&](const parser::Designator &designator) {
               if (const auto *name{
                       semantics::getDesignatorNameIfDataRef(designator)}) {
-                checkScanSymbolInReduction(name);
+                checkAndMark(name);
               }
             },
-            [&](const auto &name) { checkScanSymbolInReduction(&name); },
+            [&](const auto &name) { checkAndMark(&name); },
         },
         ompObj.u);
   }
@@ -3112,7 +3112,7 @@ void OmpStructureChecker::CheckReductionModifier(
     if (!llvm::omp::scanParentAllowedSet.test(dirCtx.directive)) {
       context_.Say(GetContext().clauseSource,
           "Modifier 'INSCAN' on REDUCTION clause is only allowed with "
-          "worksharing-loop, worksharing-loop simd, "
+          "WORKSHARING LOOP, WORKSHARING LOOP SIMD, "
           "or SIMD directive"_err_en_US);
     }
   } else {

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

@@ -20,6 +20,8 @@
 #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>;
@@ -71,6 +73,43 @@ class OmpStructureChecker
   }
   using llvmOmpClause = const llvm::omp::Clause;
   using ReductionModifier = parser::OmpReductionClause::ReductionModifier;
+  using Symbol = Fortran::semantics::Symbol;
+  class ScanReductionInfo {
+
+  public:
+    std::set<Symbol *> usedInScanDirective;
+    std::map<Symbol *, ReductionModifier> reductionMod;
+
+    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) {
+      usedInScanDirective.insert(sym);
+    }
+
+    bool findSymbolInScanConstruct(Symbol *sym) {
+      if (usedInScanDirective.find(sym) != usedInScanDirective.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 &);
@@ -249,9 +288,7 @@ class OmpStructureChecker
       const parser::OmpObjectList &ompObjectList);
   void CheckPredefinedAllocatorRestriction(
       const parser::CharBlock &source, const parser::Name &name);
-  void CheckAndAddSymbolsToUsedInScanList(const parser::OmpObjectList &x);
-  void AddModifierToMap(
-      const parser::OmpObjectList &x, const ReductionModifier &modifier);
+  void CheckAndMarkSymbolsUsedInScan(const parser::OmpObjectList &x);
   bool isPredefinedAllocator{false};
 
   void CheckAllowedRequiresClause(llvmOmpClause clause);

flang/lib/Semantics/resolve-directives.cpp

@@ -21,6 +21,7 @@
 #include "flang/Semantics/expression.h"
 #include "flang/Semantics/symbol.h"
 #include "flang/Semantics/tools.h"
+#include <iostream>
 #include <list>
 #include <map>
 #include <sstream>
@@ -458,6 +459,18 @@ class OmpAttributeVisitor : DirectiveAttributeVisitor<llvm::omp::Directive> {
   }
 
   // 2.15.3 Data-Sharing Attribute Clauses
+  void ResolveNames(const parser::OmpObjectList &objList);
+
+  bool Pre(const parser::OmpClause::Inclusive &x) {
+    const auto &objectList{x.v};
+    ResolveNames(objectList);
+    return false;
+  }
+  bool Pre(const parser::OmpClause::Exclusive &x) {
+    const auto &objectList{x.v};
+    ResolveNames(objectList);
+    return false;
+  }
   void Post(const parser::OmpDefaultClause &);
   bool Pre(const parser::OmpClause::Shared &x) {
     ResolveOmpObjectList(x.v, Symbol::Flag::OmpShared);
@@ -2957,4 +2970,19 @@ void OmpAttributeVisitor::IssueNonConformanceWarning(
   context_.Warn(common::UsageWarning::OpenMPUsage, source, "%s"_warn_en_US,
       warnStrOS.str());
 }
+void OmpAttributeVisitor::ResolveNames(const parser::OmpObjectList &objList) {
+  for (const auto &ompObj : objList.v) {
+    common::visit(
+        common::visitors{
+            [&](const parser::Designator &designator) {
+              if (const auto *name{
+                      semantics::getDesignatorNameIfDataRef(designator)}) {
+                ResolveName(name);
+              }
+            },
+            [&](const auto &name) { ResolveName(&name); },
+        },
+        ompObj.u);
+  }
+}
 } // namespace Fortran::semantics

flang/test/Lower/OpenMP/Todo/reduction-inscan.f90

@@ -8,6 +8,7 @@ subroutine reduction_inscan()
 
   !$omp do reduction(inscan, +:i)
   do j=1,10
+     !$omp scan inclusive(i)
      i = i + 1
   end do
   !$omp end do

flang/test/Semantics/OpenMP/reduction-modifiers.f90

@@ -72,7 +72,7 @@ subroutine mod_inscan3(x)
 subroutine mod_inscan4(x)
   integer, intent(inout) :: x
 
-  !ERROR: Modifier 'INSCAN' on REDUCTION clause is only allowed with worksharing-loop, worksharing-loop simd, or SIMD directive
+  !ERROR: Modifier 'INSCAN' on REDUCTION clause is only allowed with WORKSHARING LOOP, WORKSHARING LOOP SIMD, or SIMD directive
   !$omp parallel reduction(inscan, +:x)
   do i = 1, 100
     x = foo(i)
@@ -83,7 +83,7 @@ subroutine mod_inscan4(x)
 subroutine mod_inscan5(x)
   integer, intent(inout) :: x
 
-  !ERROR: Modifier 'INSCAN' on REDUCTION clause is only allowed with worksharing-loop, worksharing-loop simd, or SIMD directive
+  !ERROR: Modifier 'INSCAN' on REDUCTION clause is only allowed with WORKSHARING LOOP, WORKSHARING LOOP SIMD, or SIMD directive
   !$omp sections reduction(inscan, +:x)
   do i = 1, 100
     x = foo(i)

flang/test/Semantics/OpenMP/scan.f90

@@ -3,7 +3,7 @@
 subroutine test_scan()
  integer x, y, k, z
 
- !ERROR: Orphaned `omp 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: 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.
  !$omp scan inclusive(x)
  !$omp parallel do simd
  do k = 1, n
@@ -13,21 +13,21 @@ subroutine test_scan()
 
  !$omp parallel do simd
  do k = 1, n
- !ERROR: Exactly one of `exclusive` or `inclusive` clause is expected
+ !ERROR: Exactly one of EXCLUSIVE or INCLUSIVE clause is expected
    !$omp scan
  end do
 
 !$omp parallel do simd reduction(inscan,+: x, y)
  do k = 1, n
- !ERROR: Exactly one of `exclusive` or `inclusive` clause is expected
+ !ERROR: Exactly one of EXCLUSIVE or INCLUSIVE clause is expected
    !$omp scan inclusive(x) exclusive(y)
  end do
 
-!ERROR: List item y must appear in 'inclusive' or 'exclusive' clause of an enclosed scan directive
+!ERROR: List item y must appear in EXCLUSIVE or INCLUSIVE clause of an enclosed SCAN directive
 !$omp parallel do simd reduction(inscan,+: x, y)
  do k = 1, n
- !ERROR: Exactly one of `exclusive` or `inclusive` clause is expected
- !ERROR: List item z must appear in 'reduction' clause with the 'inscan' modifier of the parent directive
+ !ERROR: Exactly one of EXCLUSIVE or INCLUSIVE clause is expected
+ !ERROR: List item z must appear in REDUCTION clause with the INSCAN modifier of the parent directive
    !$omp scan inclusive(x) exclusive(z)
  end do
 end subroutine