Revert "[flang][OpenMP] Enable tiling (llvm#143715)"

This reverts commit d452e67.

Author: Meinersbur

flang/include/flang/Lower/OpenMP.h

@@ -80,6 +80,7 @@ void genOpenMPDeclarativeConstruct(AbstractConverter &,
 void genOpenMPSymbolProperties(AbstractConverter &converter,
                                const pft::Variable &var);
 
+int64_t getCollapseValue(const Fortran::parser::OmpClauseList &clauseList);
 void genThreadprivateOp(AbstractConverter &, const pft::Variable &);
 void genDeclareTargetIntGlobal(AbstractConverter &, const pft::Variable &);
 bool isOpenMPTargetConstruct(const parser::OpenMPConstruct &);

flang/lib/Lower/OpenMP/ClauseProcessor.cpp

@@ -273,15 +273,10 @@ bool ClauseProcessor::processCancelDirectiveName(
 
 bool ClauseProcessor::processCollapse(
     mlir::Location currentLocation, lower::pft::Evaluation &eval,
-    mlir::omp::LoopRelatedClauseOps &loopResult,
-    mlir::omp::CollapseClauseOps &collapseResult,
+    mlir::omp::LoopRelatedClauseOps &result,
     llvm::SmallVectorImpl<const semantics::Symbol *> &iv) const {
-
-  int64_t numCollapse = collectLoopRelatedInfo(converter, currentLocation, eval,
-                                               clauses, loopResult, iv);
-  fir::FirOpBuilder &firOpBuilder = converter.getFirOpBuilder();
-  collapseResult.collapseNumLoops = firOpBuilder.getI64IntegerAttr(numCollapse);
-  return numCollapse > 1;
+  return collectLoopRelatedInfo(converter, currentLocation, eval, clauses,
+                                result, iv);
 }
 
 bool ClauseProcessor::processDevice(lower::StatementContext &stmtCtx,
@@ -527,13 +522,6 @@ bool ClauseProcessor::processProcBind(
   return false;
 }
 
-bool ClauseProcessor::processTileSizes(
-    lower::pft::Evaluation &eval, mlir::omp::LoopNestOperands &result) const {
-  auto *ompCons{eval.getIf<parser::OpenMPConstruct>()};
-  collectTileSizesFromOpenMPConstruct(ompCons, result.tileSizes, semaCtx);
-  return !result.tileSizes.empty();
-}
-
 bool ClauseProcessor::processSafelen(
     mlir::omp::SafelenClauseOps &result) const {
   if (auto *clause = findUniqueClause<omp::clause::Safelen>()) {

flang/lib/Lower/OpenMP/ClauseProcessor.h

@@ -63,8 +63,7 @@ class ClauseProcessor {
       mlir::omp::CancelDirectiveNameClauseOps &result) const;
   bool
   processCollapse(mlir::Location currentLocation, lower::pft::Evaluation &eval,
-                  mlir::omp::LoopRelatedClauseOps &loopResult,
-                  mlir::omp::CollapseClauseOps &collapseResult,
+                  mlir::omp::LoopRelatedClauseOps &result,
                   llvm::SmallVectorImpl<const semantics::Symbol *> &iv) const;
   bool processDevice(lower::StatementContext &stmtCtx,
                      mlir::omp::DeviceClauseOps &result) const;
@@ -99,8 +98,6 @@ class ClauseProcessor {
   bool processPriority(lower::StatementContext &stmtCtx,
                        mlir::omp::PriorityClauseOps &result) const;
   bool processProcBind(mlir::omp::ProcBindClauseOps &result) const;
-  bool processTileSizes(lower::pft::Evaluation &eval,
-                        mlir::omp::LoopNestOperands &result) const;
   bool processSafelen(mlir::omp::SafelenClauseOps &result) const;
   bool processSchedule(lower::StatementContext &stmtCtx,
                        mlir::omp::ScheduleClauseOps &result) const;

flang/lib/Lower/OpenMP/OpenMP.cpp

@@ -503,7 +503,7 @@ static void processHostEvalClauses(lower::AbstractConverter &converter,
       [[fallthrough]];
     case OMPD_distribute:
     case OMPD_distribute_simd:
-      cp.processCollapse(loc, eval, hostInfo->ops, hostInfo->ops, hostInfo->iv);
+      cp.processCollapse(loc, eval, hostInfo->ops, hostInfo->iv);
       break;
 
     case OMPD_teams:
@@ -522,7 +522,7 @@ static void processHostEvalClauses(lower::AbstractConverter &converter,
       [[fallthrough]];
     case OMPD_target_teams_distribute:
     case OMPD_target_teams_distribute_simd:
-      cp.processCollapse(loc, eval, hostInfo->ops, hostInfo->ops, hostInfo->iv);
+      cp.processCollapse(loc, eval, hostInfo->ops, hostInfo->iv);
       cp.processNumTeams(stmtCtx, hostInfo->ops);
       break;
 
@@ -533,7 +533,7 @@ static void processHostEvalClauses(lower::AbstractConverter &converter,
       cp.processNumTeams(stmtCtx, hostInfo->ops);
       [[fallthrough]];
     case OMPD_loop:
-      cp.processCollapse(loc, eval, hostInfo->ops, hostInfo->ops, hostInfo->iv);
+      cp.processCollapse(loc, eval, hostInfo->ops, hostInfo->iv);
       break;
 
     case OMPD_teams_workdistribute:
@@ -1569,10 +1569,9 @@ genLoopNestClauses(lower::AbstractConverter &converter,
 
   HostEvalInfo *hostEvalInfo = getHostEvalInfoStackTop(converter);
   if (!hostEvalInfo || !hostEvalInfo->apply(clauseOps, iv))
-    cp.processCollapse(loc, eval, clauseOps, clauseOps, iv);
+    cp.processCollapse(loc, eval, clauseOps, iv);
 
   clauseOps.loopInclusive = converter.getFirOpBuilder().getUnitAttr();
-  cp.processTileSizes(eval, clauseOps);
 }
 
 static void genLoopClauses(
@@ -1949,9 +1948,9 @@ static mlir::omp::LoopNestOp genLoopNestOp(
     return llvm::SmallVector<const semantics::Symbol *>(iv);
   };
 
-  uint64_t nestValue = getCollapseValue(item->clauses);
-  nestValue = nestValue < iv.size() ? iv.size() : nestValue;
-  auto *nestedEval = getCollapsedLoopEval(eval, nestValue);
+  auto *nestedEval =
+      getCollapsedLoopEval(eval, getCollapseValue(item->clauses));
+
   return genOpWithBody<mlir::omp::LoopNestOp>(
       OpWithBodyGenInfo(converter, symTable, semaCtx, loc, *nestedEval,
                         directive)
@@ -3844,8 +3843,8 @@ static void genOMP(lower::AbstractConverter &converter, lower::SymMap &symTable,
           parser::omp::GetOmpDirectiveName(*ompNestedLoopCons).v;
       switch (nestedDirective) {
       case llvm::omp::Directive::OMPD_tile:
-        // Skip OMPD_tile since the tile sizes will be retrieved when
-        // generating the omp.loop_nest op.
+        // Emit the omp.loop_nest with annotation for tiling
+        genOMP(converter, symTable, semaCtx, eval, ompNestedLoopCons->value());
         break;
       default: {
         unsigned version = semaCtx.langOptions().OpenMPVersion;
@@ -3958,6 +3957,18 @@ void Fortran::lower::genOpenMPSymbolProperties(
     lower::genDeclareTargetIntGlobal(converter, var);
 }
 
+int64_t
+Fortran::lower::getCollapseValue(const parser::OmpClauseList &clauseList) {
+  for (const parser::OmpClause &clause : clauseList.v) {
+    if (const auto &collapseClause =
+            std::get_if<parser::OmpClause::Collapse>(&clause.u)) {
+      const auto *expr = semantics::GetExpr(collapseClause->v);
+      return evaluate::ToInt64(*expr).value();
+    }
+  }
+  return 1;
+}
+
 void Fortran::lower::genThreadprivateOp(lower::AbstractConverter &converter,
                                         const lower::pft::Variable &var) {
   fir::FirOpBuilder &firOpBuilder = converter.getFirOpBuilder();

flang/lib/Lower/OpenMP/Utils.cpp

@@ -13,7 +13,6 @@
 #include "Utils.h"
 
 #include "ClauseFinder.h"
-#include "flang/Evaluate/fold.h"
 #include "flang/Lower/OpenMP/Clauses.h"
 #include <flang/Lower/AbstractConverter.h>
 #include <flang/Lower/ConvertType.h>
@@ -25,32 +24,11 @@
 #include <flang/Parser/parse-tree.h>
 #include <flang/Parser/tools.h>
 #include <flang/Semantics/tools.h>
-#include <flang/Semantics/type.h>
 #include <flang/Utils/OpenMP.h>
 #include <llvm/Support/CommandLine.h>
 
 #include <iterator>
 
-template <typename T>
-Fortran::semantics::MaybeIntExpr
-EvaluateIntExpr(Fortran::semantics::SemanticsContext &context, const T &expr) {
-  if (Fortran::semantics::MaybeExpr maybeExpr{
-          Fold(context.foldingContext(), AnalyzeExpr(context, expr))}) {
-    if (auto *intExpr{
-            Fortran::evaluate::UnwrapExpr<Fortran::semantics::SomeIntExpr>(
-                *maybeExpr)}) {
-      return std::move(*intExpr);
-    }
-  }
-  return std::nullopt;
-}
-
-template <typename T>
-std::optional<std::int64_t>
-EvaluateInt64(Fortran::semantics::SemanticsContext &context, const T &expr) {
-  return Fortran::evaluate::ToInt64(EvaluateIntExpr(context, expr));
-}
-
 llvm::cl::opt<bool> treatIndexAsSection(
     "openmp-treat-index-as-section",
     llvm::cl::desc("In the OpenMP data clauses treat `a(N)` as `a(N:N)`."),
@@ -599,64 +577,12 @@ static void convertLoopBounds(lower::AbstractConverter &converter,
   }
 }
 
-// Helper function that finds the sizes clause in a inner OMPD_tile directive
-// and passes the sizes clause to the callback function if found.
-static void processTileSizesFromOpenMPConstruct(
-    const parser::OpenMPConstruct *ompCons,
-    std::function<void(const parser::OmpClause::Sizes *)> processFun) {
-  if (!ompCons)
-    return;
-  if (auto *ompLoop{std::get_if<parser::OpenMPLoopConstruct>(&ompCons->u)}) {
-    const auto &nestedOptional =
-        std::get<std::optional<parser::NestedConstruct>>(ompLoop->t);
-    assert(nestedOptional.has_value() &&
-           "Expected a DoConstruct or OpenMPLoopConstruct");
-    const auto *innerConstruct =
-        std::get_if<common::Indirection<parser::OpenMPLoopConstruct>>(
-            &(nestedOptional.value()));
-    if (innerConstruct) {
-      const auto &innerLoopDirective = innerConstruct->value();
-      const auto &innerBegin =
-          std::get<parser::OmpBeginLoopDirective>(innerLoopDirective.t);
-      const auto &innerDirective =
-          std::get<parser::OmpLoopDirective>(innerBegin.t).v;
-
-      if (innerDirective == llvm::omp::Directive::OMPD_tile) {
-        // Get the size values from parse tree and convert to a vector.
-        const auto &innerClauseList{
-            std::get<parser::OmpClauseList>(innerBegin.t)};
-        for (const auto &clause : innerClauseList.v) {
-          if (const auto tclause{
-                  std::get_if<parser::OmpClause::Sizes>(&clause.u)}) {
-            processFun(tclause);
-            break;
-          }
-        }
-      }
-    }
-  }
-}
-
-/// Populates the sizes vector with values if the given OpenMPConstruct
-/// contains a loop construct with an inner tiling construct.
-void collectTileSizesFromOpenMPConstruct(
-    const parser::OpenMPConstruct *ompCons,
-    llvm::SmallVectorImpl<int64_t> &tileSizes,
-    Fortran::semantics::SemanticsContext &semaCtx) {
-  processTileSizesFromOpenMPConstruct(
-      ompCons, [&](const parser::OmpClause::Sizes *tclause) {
-        for (auto &tval : tclause->v)
-          if (const auto v{EvaluateInt64(semaCtx, tval)})
-            tileSizes.push_back(*v);
-      });
-}
-
-int64_t collectLoopRelatedInfo(
+bool collectLoopRelatedInfo(
     lower::AbstractConverter &converter, mlir::Location currentLocation,
     lower::pft::Evaluation &eval, const omp::List<omp::Clause> &clauses,
     mlir::omp::LoopRelatedClauseOps &result,
     llvm::SmallVectorImpl<const semantics::Symbol *> &iv) {
-  int64_t numCollapse = 1;
+  bool found = false;
   fir::FirOpBuilder &firOpBuilder = converter.getFirOpBuilder();
 
   // Collect the loops to collapse.
@@ -669,19 +595,9 @@ int64_t collectLoopRelatedInfo(
   if (auto *clause =
           ClauseFinder::findUniqueClause<omp::clause::Collapse>(clauses)) {
     collapseValue = evaluate::ToInt64(clause->v).value();
-    numCollapse = collapseValue;
-  }
-
-  // Collect sizes from tile directive if present.
-  std::int64_t sizesLengthValue = 0l;
-  if (auto *ompCons{eval.getIf<parser::OpenMPConstruct>()}) {
-    processTileSizesFromOpenMPConstruct(
-        ompCons, [&](const parser::OmpClause::Sizes *tclause) {
-          sizesLengthValue = tclause->v.size();
-        });
+    found = true;
   }
 
-  collapseValue = std::max(collapseValue, sizesLengthValue);
   std::size_t loopVarTypeSize = 0;
   do {
     lower::pft::Evaluation *doLoop =
@@ -715,7 +631,7 @@ int64_t collectLoopRelatedInfo(
 
   convertLoopBounds(converter, currentLocation, result, loopVarTypeSize);
 
-  return numCollapse;
+  return found;
 }
 
 } // namespace omp

flang/lib/Lower/OpenMP/Utils.h

@@ -159,17 +159,12 @@ void genObjectList(const ObjectList &objects,
 void lastprivateModifierNotSupported(const omp::clause::Lastprivate &lastp,
                                      mlir::Location loc);
 
-int64_t collectLoopRelatedInfo(
+bool collectLoopRelatedInfo(
     lower::AbstractConverter &converter, mlir::Location currentLocation,
     lower::pft::Evaluation &eval, const omp::List<omp::Clause> &clauses,
     mlir::omp::LoopRelatedClauseOps &result,
     llvm::SmallVectorImpl<const semantics::Symbol *> &iv);
 
-void collectTileSizesFromOpenMPConstruct(
-    const parser::OpenMPConstruct *ompCons,
-    llvm::SmallVectorImpl<int64_t> &tileSizes,
-    Fortran::semantics::SemanticsContext &semaCtx);
-
 } // namespace omp
 } // namespace lower
 } // namespace Fortran