[Flang,OpenMP][WIP] Implement reduction during AssignmentStmt Lowering

flang/include/flang/Lower/OpenMP.h

 //===-- Lower/OpenMP.h -- lower Open MP directives --------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // Coding style: https://mlir.llvm.org/getting_started/DeveloperGuide/
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef FORTRAN_LOWER_OPENMP_H
 #define FORTRAN_LOWER_OPENMP_H
 
 #include <cinttypes>
 
 namespace Fortran {
 namespace parser {
 struct OpenMPConstruct;
 struct OpenMPDeclarativeConstruct;
 struct OmpEndLoopDirective;
 struct OmpClauseList;
+struct AssignmentStmt;
 } // namespace parser
 
 namespace lower {
 
 class AbstractConverter;
 
 namespace pft {
 struct Evaluation;
 struct Variable;
 } // namespace pft
 
 void genOpenMPConstruct(AbstractConverter &, pft::Evaluation &,
                         const parser::OpenMPConstruct &);
 void genOpenMPDeclarativeConstruct(AbstractConverter &, pft::Evaluation &,
                                    const parser::OpenMPDeclarativeConstruct &);
 int64_t getCollapseValue(const Fortran::parser::OmpClauseList &clauseList);
 void genThreadprivateOp(AbstractConverter &, const pft::Variable &);
 void genOpenMPReduction(AbstractConverter &,
                         const Fortran::parser::OmpClauseList &clauseList);
+void genOpenMPReduction(AbstractConverter &,
+            const Fortran::parser::AssignmentStmt &stmt);
+bool isOpenMPReduction(const Fortran::parser::AssignmentStmt &stmt);
 
 } // namespace lower
 } // namespace Fortran
 
 #endif // FORTRAN_LOWER_OPENMP_H

flang/lib/Lower/Bridge.cpp

 //===-- Bridge.cpp -- bridge to lower to MLIR -----------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
void genFIR(const Fortran::parser::WhereStmt &stmt) {
     implicitIterSpace.shrinkStack();
   }
 
   void genFIR(const Fortran::parser::PointerAssignmentStmt &stmt) {
     genAssignment(*stmt.typedAssignment->v);
   }
 
   void genFIR(const Fortran::parser::AssignmentStmt &stmt) {
+    if (Fortran::lower::isOpenMPReduction(stmt))
+      // TODO: Implement the genOpenMPReduction function. The current
+      // prototype uses the parse tree AssignmentStmt node, but regular
+      // FIR lowering uses the typedAssignment associated with it. It
+      // will probably be better to swich to the regular FIR lowering. To
+      // begin with, we will only need to implement a subset of the
+      // functionality in genAssignment.
+      Fortran::lower::genOpenMPReduction(*this, stmt);
+    else
       genAssignment(*stmt.typedAssignment->v);
   }
 
   void genFIR(const Fortran::parser::SyncAllStmt &stmt) {
     genSyncAllStatement(*this, stmt);
   }
 
   void genFIR(const Fortran::parser::SyncImagesStmt &stmt) {
     genSyncImagesStatement(*this, stmt);

flang/lib/Lower/OpenMP.cpp

 //===-- OpenMP.cpp -- Open MP directive lowering --------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
if (const auto &reductionClause =
               }
             }
           }
         }
       }
     }
   }
 }
+
+void Fortran::lower::genOpenMPReduction(
+    Fortran::lower::AbstractConverter &,
+    const Fortran::parser::AssignmentStmt &stmt) {}
+
+bool Fortran::lower::isOpenMPReduction(
+    const Fortran::parser::AssignmentStmt &stmt) {
+  auto getVarSym = [](const Fortran::parser::Designator &d) {
+    Fortran::semantics::Symbol *varSym = nullptr;
+    if (const auto *dataRef = std::get_if<Fortran::parser::DataRef>(&d.u)) {
+      if (const auto *name = std::get_if<Fortran::parser::Name>(&dataRef->u)) {
+        varSym = name->symbol;
+      }
+    }
+    return varSym;
+  };
+
+  // TODO : Find the parent operation which has the reduction clause interface
+  // and check whether the provided expression type and variable matches any of
+  // the reduction symbol and reduction variable.
+  auto isMatchingReduction = [firOpBuilder](expr-type, var) {
+  };
+
+  bool isReductionAssign = false;
+  const auto &var{std::get<Fortran::parser::Variable>(stmt.t)};
+  Fortran::semantics::Symbol *varSym = nullptr;
+  if (auto varDesignatorIndirection = std::get_if<
+          Fortran::common::Indirection<Fortran::parser::Designator>>(&var.u)) {
+    varSym = getVarSym(varDesignatorIndirection->value());
+    if (varSym && varSym->test(Fortran::semantics::Symbol::Flag::OmpReduction))
+      isReductionAssign = true;
+  }
+
+  fir::FirOpBuilder &firOpBuilder = converter.getFirOpBuilder();
+  bool reductionVarInExpr = false;
+  bool matchingReductionInOp = false;
+  const auto &expr{std::get<Fortran::parser::Expr>(stmt.t)};
+  Fortran::common::visit(
+      Fortran::common::visitors{
+          [&](const Fortran::parser::Expr::Add &a) {
+            Fortran::semantics::Symbol *lhsSym = nullptr;
+            if (auto lhsVarIndirection = std::get_if<
+                    Fortran::common::Indirection<Fortran::parser::Designator>>(
+                    &std::get<0>(a.t).value().u))
+              lhsSym = getVarSym(lhsVarIndirection->value());
+            if (lhsSym == varSym)
+        reductionVarInExpr = true;
+            Fortran::semantics::Symbol *rhsSym = nullptr;
+            if (auto rhsVarIndirection = std::get_if<
+                    Fortran::common::Indirection<Fortran::parser::Designator>>(
+                    &std::get<1>(a.t).value().u))
+              rhsSym = getVarSym(rhsVarIndirection->value());
+            if (rhsSym == varSym)
+        reductionVarInExpr = true;
+
+      matchingReductionInOp = isMatchingReduction(a, varSym);
+          },
+          [&](const auto &x) {},
+      },
+      expr.u);
+  return isReductionAssign && reductionVarInExpr && matchingReductionInOp;
+}