Resolve conflicts and format

Author: Ferran Toda

flang/lib/Lower/OpenMP/OpenMP.cpp

@@ -3470,13 +3470,14 @@ static void genOMPDispatch(lower::AbstractConverter &converter,
     break;
   case llvm::omp::Directive::OMPD_tile:
     genTileOp(converter, symTable, stmtCtx, semaCtx, eval, loc, queue, item);
+    break;
   case llvm::omp::Directive::OMPD_fuse: {
     unsigned version = semaCtx.langOptions().OpenMPVersion;
     if (!semaCtx.langOptions().OpenMPSimd)
       TODO(loc, "Unhandled loop directive (" +
                     llvm::omp::getOpenMPDirectiveName(dir, version) + ")");
     break;
-                                        }
+  }
   case llvm::omp::Directive::OMPD_unroll:
     genUnrollOp(converter, symTable, stmtCtx, semaCtx, eval, loc, queue, item);
     break;

flang/lib/Semantics/resolve-directives.cpp

@@ -2259,85 +2259,86 @@ void OmpAttributeVisitor::CheckPerfectNestAndRectangularLoop(
   // Find the associated region by skipping nested loop-associated constructs
   // such as loop transformations
   const parser::NestedConstruct *innermostAssocRegion{nullptr};
-  const parser::OpenMPLoopConstruct *innermostConstruct{&x};
-  while (const auto &innerAssocStmt{
-      std::get<std::optional<parser::NestedConstruct>>(
-          innermostConstruct->t)}) {
-    innermostAssocRegion = &(innerAssocStmt.value());
+  const parser::OpenMPLoopConstruct *innermostConstruct = &x;
+  auto &loopConsList =
+      std::get<std::list<parser::NestedConstruct>>(innermostConstruct->t);
+  for (auto &loopCons : loopConsList) {
+    innermostAssocRegion = &loopCons;
     if (const auto *innerConstruct{
             std::get_if<common::Indirection<parser::OpenMPLoopConstruct>>(
                 innermostAssocRegion)}) {
-      innermostConstruct = &innerConstruct->value();
+      CheckPerfectNestAndRectangularLoop(innerConstruct->value());
+      return;
     } else {
-      break;
-    }
-  }
 
-  if (!innermostAssocRegion)
-    return;
-  const auto &outer{std::get_if<parser::DoConstruct>(innermostAssocRegion)};
-  if (!outer)
-    return;
+      if (!innermostAssocRegion)
+        continue;
+      const auto &outer{std::get_if<parser::DoConstruct>(innermostAssocRegion)};
+      if (!outer)
+        continue;
 
-  llvm::SmallVector<Symbol *> ivs;
-  int curLevel{0};
-  const parser::DoConstruct *loop{outer};
-  while (true) {
-    auto [iv, lb, ub, step] = GetLoopBounds(*loop);
-
-    if (lb)
-      checkExprHasSymbols(ivs, lb);
-    if (ub)
-      checkExprHasSymbols(ivs, ub);
-    if (step)
-      checkExprHasSymbols(ivs, step);
-    if (iv) {
-      if (auto *symbol{currScope().FindSymbol(iv->source)})
-        ivs.push_back(symbol);
-    }
+      llvm::SmallVector<Symbol *> ivs;
+      int curLevel{0};
+      const parser::DoConstruct *loop{outer};
+      while (true) {
+        auto [iv, lb, ub, step] = GetLoopBounds(*loop);
+
+        if (lb)
+          checkExprHasSymbols(ivs, lb);
+        if (ub)
+          checkExprHasSymbols(ivs, ub);
+        if (step)
+          checkExprHasSymbols(ivs, step);
+        if (iv) {
+          if (auto *symbol{currScope().FindSymbol(iv->source)})
+            ivs.push_back(symbol);
+        }
 
-    // Stop after processing all affected loops
-    if (curLevel + 1 >= dirDepth)
-      break;
+        // Stop after processing all affected loops
+        if (curLevel + 1 >= dirDepth)
+          break;
 
-    // Recurse into nested loop
-    const auto &block{std::get<parser::Block>(loop->t)};
-    if (block.empty()) {
-      // Insufficient number of nested loops already reported by
-      // CheckAssocLoopLevel()
-      break;
-    }
+        // Recurse into nested loop
+        const auto &block{std::get<parser::Block>(loop->t)};
+        if (block.empty()) {
+          // Insufficient number of nested loops already reported by
+          // CheckAssocLoopLevel()
+          break;
+        }
 
-    loop = GetDoConstructIf(block.front());
-    if (!loop) {
-      // Insufficient number of nested loops already reported by
-      // CheckAssocLoopLevel()
-      break;
-    }
+        loop = GetDoConstructIf(block.front());
+        if (!loop) {
+          // Insufficient number of nested loops already reported by
+          // CheckAssocLoopLevel()
+          break;
+        }
 
-    auto checkPerfectNest = [&, this]() {
-      if (block.empty())
-        return;
-      auto last = block.end();
-      --last;
+        auto checkPerfectNest = [&, this]() {
+          if (block.empty())
+            return;
+          auto last = block.end();
+          --last;
 
-      // A trailing CONTINUE is not considered part of the loop body
-      if (parser::Unwrap<parser::ContinueStmt>(*last))
-        --last;
+          // A trailing CONTINUE is not considered part of the loop body
+          if (parser::Unwrap<parser::ContinueStmt>(*last))
+            --last;
 
-      // In a perfectly nested loop, the nested loop must be the only statement
-      if (last == block.begin())
-        return;
+          // In a perfectly nested loop, the nested loop must be the only
+          // statement
+          if (last == block.begin())
+            return;
 
-      // Non-perfectly nested loop
-      // TODO: Point to non-DO statement, directiveSource as a note
-      context_.Say(dirContext.directiveSource,
-          "Canonical loop nest must be perfectly nested."_err_en_US);
-    };
+          // Non-perfectly nested loop
+          // TODO: Point to non-DO statement, directiveSource as a note
+          context_.Say(dirContext.directiveSource,
+              "Canonical loop nest must be perfectly nested."_err_en_US);
+        };
 
-    checkPerfectNest();
+        checkPerfectNest();
 
-    ++curLevel;
+        ++curLevel;
+      }
+    }
   }
 }
 

flang/test/Parser/OpenMP/loop-transformation-construct05.f90

@@ -14,7 +14,7 @@ subroutine loop_transformation_construct
   do i = 1, I
     continue
   end do
-  !$omp tile
+  !$omp tile sizes(2)
     do j = 1, I
       continue
     end do
@@ -47,7 +47,8 @@ subroutine loop_transformation_construct
 !CHECK-PARSE-NEXT: | | | | OpenMPLoopConstruct
 !CHECK-PARSE-NEXT: | | | | | OmpBeginLoopDirective
 !CHECK-PARSE-NEXT: | | | | | | OmpDirectiveName -> llvm::omp::Directive = tile
-!CHECK-PARSE-NEXT: | | | | | | OmpClauseList ->
+!CHECK-PARSE-NEXT: | | | | | | OmpClauseList -> OmpClause -> Sizes -> Scalar -> Integer -> Expr = '2_4'
+!CHECK-PARSE-NEXT: | | | | | | | LiteralConstant -> IntLiteralConstant = '2'
 !CHECK-PARSE-NEXT: | | | | | | Flags = None
 !CHECK-PARSE-NEXT: | | | | | DoConstruct
 !CHECK-PARSE-NEXT: | | | | | | NonLabelDoStmt

flang/test/Semantics/OpenMP/loop-transformation-construct03.f90

@@ -27,7 +27,7 @@ subroutine loop_transformation_construct2
   integer :: v(i)
 
   ! Only 1 do loop is associated with the OMP TILE directive so the END TILE directive is unmatched
-  !$omp tile
+  !$omp tile sizes(2)
   do x = 1, i
     v(x) = x(x) * 2
   end do

flang/test/Semantics/OpenMP/loop-transformation-construct04.f90

@@ -31,7 +31,7 @@ subroutine loop_transformation_construct4
   integer :: v(i)
 
   !ERROR: The loop sequence following the TILE construct must be fully fused first.
-  !$omp tile
+  !$omp tile sizes(2)
   !$omp fuse looprange(1,2)
   do x = 1, i
     v(x) = x * 2

flang/test/Semantics/OpenMP/tile02.f90

@@ -6,7 +6,7 @@ subroutine on_unroll
   implicit none
   integer i
 
-  !ERROR: If a loop construct has been fully unrolled, it cannot then be tiled
+  !ERROR: If a loop construct has been fully unrolled, it cannot then be further transformed
   !$omp tile sizes(2)
   !$omp unroll
   do i = 1, 5