[llvm-branch-commits] [flang] [flang] Keep do concurrent structured when its branching stays in the body (PR #244176)
Kareem Ergawy via llvm-branch-commits
llvm-branch-commits at lists.llvm.org
Thu Nov 19 04:05:51 PST 2026
https://github.com/ergawy created https://github.com/llvm/llvm-project/pull/244176
A DO loop whose raw branching is confined to its body keeps its structured
form, with only the body folded into an scf.execute_region. Only increment
loops qualified. A do concurrent header puts no control flow in the body
either: its indices are always integer and its mask is a test inside the
innermost loop. So a do concurrent qualifies under the same body checks.
This lets a do concurrent with, for example, a SELECT CASE in its body lower
inside an OpenACC kernels region instead of hitting the "unstructured do loop
in acc kernels" TODO.
The tests cover a do concurrent that keeps its structured form with a SELECT
CASE in its body, a mask over two indices, a CYCLE, a locality specifier, an
EXIT of a BLOCK, and an EXIT of an inner DO, and the same loop under OpenACC
parallel loop and kernels. They also cover the shapes that stay unstructured:
a GOTO back to an earlier statement of the body, and an infinite DO in the
body. do_concurrent.f90 also checks the old lowering with
--wrap-unstructured-constructs-in-execute-region=false.
>From 9b196b799447c811593c07e7544e24384df34dcd Mon Sep 17 00:00:00 2001
From: ergawy <kareem.ergawy at gmail.com>
Date: Thu, 19 Nov 2026 02:41:18 -0800
Subject: [PATCH] [flang] Keep do concurrent structured when its branching
stays in the body
A DO loop whose raw branching is confined to its body keeps its structured
form, with only the body folded into an scf.execute_region. Only increment
loops qualified. A do concurrent header puts no control flow in the body
either: its indices are always integer and its mask is a test inside the
innermost loop. So a do concurrent qualifies under the same body checks.
This lets a do concurrent with, for example, a SELECT CASE in its body lower
inside an OpenACC kernels region instead of hitting the "unstructured do loop
in acc kernels" TODO.
---
flang/lib/Lower/PFTBuilder.cpp | 42 ++--
.../OpenACC/acc-directive-loop-bounds.f90 | 65 ++++++
.../do-concurrent-unstructured-internals.f90 | 214 ++++++++++++++++++
flang/test/Lower/do_concurrent.f90 | 88 ++++---
flang/test/Lower/do_loop_unstructured.f90 | 21 +-
flang/test/Lower/loops.f90 | 8 +-
6 files changed, 377 insertions(+), 61 deletions(-)
create mode 100644 flang/test/Lower/do-concurrent-unstructured-internals.f90
diff --git a/flang/lib/Lower/PFTBuilder.cpp b/flang/lib/Lower/PFTBuilder.cpp
index b2915fcc0800f7..6498c520d24207 100644
--- a/flang/lib/Lower/PFTBuilder.cpp
+++ b/flang/lib/Lower/PFTBuilder.cpp
@@ -2924,10 +2924,10 @@ static bool isStructurableWithUnstructuredInternals(
loop.evaluationList->size() < 3)
return false;
- // Only an increment loop keeps all of its control outside the body. A DO
- // WHILE or an infinite DO lowers through a header block and a back edge, and
- // a do concurrent has no plain bounds triple either, so in each case the
- // loop's own control flow runs through the body a wrap would cover.
+ // Only an increment loop or a do concurrent keeps all of its control outside
+ // the body. A DO WHILE or an infinite DO lowers through a header block and a
+ // back edge, so the loop's own control flow runs through the body a wrap
+ // would cover.
const auto *doConstruct = loop.getIf<parser::DoConstruct>();
if (!doConstruct)
return false;
@@ -2936,22 +2936,28 @@ static bool isStructurableWithUnstructuredInternals(
if (!loopControl)
return false;
- const auto *bounds =
- std::get_if<parser::LoopControl::Bounds>(&loopControl->u);
- if (!bounds)
- return false;
+ // A do concurrent header puts no control flow in the body: its indices are
+ // always integer, and its mask is a test inside the innermost loop. The body
+ // checks below still apply.
+ if (!std::holds_alternative<parser::LoopControl::Concurrent>(
+ loopControl->u)) {
+ const auto *bounds =
+ std::get_if<parser::LoopControl::Bounds>(&loopControl->u);
+ if (!bounds)
+ return false;
- // A REAL control variable does not lower to fir.do_loop, whose induction
- // variable must be a signless integer or index, so such a loop is lowered as
- // unstructured whatever its body looks like.
- const semantics::Symbol *ctrlVar = bounds->Name().thing.symbol;
- if (!ctrlVar)
- return false;
+ // A REAL control variable does not lower to fir.do_loop, whose induction
+ // variable must be a signless integer or index, so such a loop is lowered
+ // as unstructured whatever its body looks like.
+ const semantics::Symbol *ctrlVar = bounds->Name().thing.symbol;
+ if (!ctrlVar)
+ return false;
- const semantics::DeclTypeSpec *ctrlType = ctrlVar->GetType();
- if (!ctrlType || ctrlType->category() != semantics::DeclTypeSpec::Numeric ||
- ctrlType->numericTypeSpec().category() != common::TypeCategory::Integer)
- return false;
+ const semantics::DeclTypeSpec *ctrlType = ctrlVar->GetType();
+ if (!ctrlType || ctrlType->category() != semantics::DeclTypeSpec::Numeric ||
+ ctrlType->numericTypeSpec().category() != common::TypeCategory::Integer)
+ return false;
+ }
const Fortran::lower::pft::Evaluation *endDoStmt =
&loop.evaluationList->back();
diff --git a/flang/test/Lower/OpenACC/acc-directive-loop-bounds.f90 b/flang/test/Lower/OpenACC/acc-directive-loop-bounds.f90
index edc1b2c0e54e3b..a6664077b9756a 100644
--- a/flang/test/Lower/OpenACC/acc-directive-loop-bounds.f90
+++ b/flang/test/Lower/OpenACC/acc-directive-loop-bounds.f90
@@ -64,3 +64,68 @@ subroutine parallel_region_goto(a, n)
! CHECK: Subroutine parallel_region_goto
! CHECK: <<OpenACCConstruct!>>
! CHECK: GotoStmt!
+
+! A do concurrent with a SELECT CASE in its body keeps its structured form too,
+! so the directive's acc.loop carries the bounds.
+subroutine parallel_loop_do_concurrent(a, n, tag)
+ real :: a(n)
+ integer :: n, i, tag
+ !$acc parallel loop
+ do concurrent (i = 1:n)
+ select case (tag)
+ case (1)
+ a(i) = 1.0
+ case default
+ a(i) = 0.0
+ end select
+ end do
+end subroutine
+
+! CHECK: Subroutine parallel_loop_do_concurrent
+! CHECK: <<OpenACCConstruct~>>
+! CHECK: <<DoConstruct~>>
+
+! FIR-LABEL: func.func @_QPparallel_loop_do_concurrent
+! FIR: acc.parallel combined(loop) {
+! FIR-NOT: acc.loop
+! FIR: acc.loop combined(parallel) private({{.*}}) control(%{{.*}} : i32) = (%{{.*}} : i32) to (%{{.*}} : i32) step (%{{.*}} : i32) {
+! FIR: scf.execute_region no_inline {
+! FIR: fir.select_case
+! FIR: scf.yield
+! FIR: }
+! FIR-NOT: acc.loop
+! FIR: acc.yield
+! FIR: }
+
+! The same do concurrent directly in a kernels region gets the implicit acc.loop
+! with bounds, instead of being reported as an unstructured DO.
+subroutine kernels_do_concurrent(a, n, tag)
+ real :: a(n)
+ integer :: n, i, tag
+ !$acc kernels
+ do concurrent (i = 1:n)
+ select case (tag)
+ case (1)
+ a(i) = 1.0
+ case default
+ a(i) = 0.0
+ end select
+ end do
+ !$acc end kernels
+end subroutine
+
+! CHECK: Subroutine kernels_do_concurrent
+! CHECK: <<OpenACCConstruct~>>
+! CHECK: <<DoConstruct~>>
+
+! FIR-LABEL: func.func @_QPkernels_do_concurrent
+! FIR: acc.kernels {
+! FIR-NOT: acc.loop
+! FIR: acc.loop private({{.*}}) control(%{{.*}} : i32) = (%{{.*}} : i32) to (%{{.*}} : i32) step (%{{.*}} : i32) {
+! FIR: scf.execute_region no_inline {
+! FIR: fir.select_case
+! FIR: scf.yield
+! FIR: }
+! FIR-NOT: acc.loop
+! FIR: acc.yield
+! FIR: }
diff --git a/flang/test/Lower/do-concurrent-unstructured-internals.f90 b/flang/test/Lower/do-concurrent-unstructured-internals.f90
new file mode 100644
index 00000000000000..17a897e0d226fd
--- /dev/null
+++ b/flang/test/Lower/do-concurrent-unstructured-internals.f90
@@ -0,0 +1,214 @@
+! A do concurrent whose branching is confined to its body keeps its structured
+! form: its header puts no control flow in the body, so only the body is folded
+! into an scf.execute_region. The body checks that apply to an increment loop
+! still apply.
+
+! RUN: %flang_fc1 -fdebug-dump-pft -o /dev/null %s 2>&1 | FileCheck %s
+! RUN: %flang_fc1 -emit-hlfir -o - %s | FileCheck %s --check-prefix=FIR
+
+! A SELECT CASE is lowered as raw branching, but its branches stay in the body.
+subroutine select_case(n, a, tag)
+ integer :: n, tag, i
+ real :: a(n)
+ do concurrent (i = 1:n)
+ select case (tag)
+ case (1)
+ a(i) = 1
+ case default
+ a(i) = 0
+ end select
+ end do
+end subroutine
+
+! CHECK-LABEL: Subroutine select_case
+! CHECK: <<DoConstruct~>>
+! CHECK: <<CaseConstruct!>>
+! CHECK: <<End DoConstruct~>>
+
+! FIR-LABEL: func.func @_QPselect_case
+! FIR: fir.do_concurrent {
+! FIR: fir.do_concurrent.loop
+! FIR: scf.execute_region no_inline {
+! FIR: fir.select_case
+! FIR: scf.yield
+! FIR: }
+
+! Two indices and a mask: the mask stays a test around the wrapped body.
+subroutine mask_two_indices(n, a, tag)
+ integer :: n, tag, i, j
+ real :: a(n, n)
+ do concurrent (i = 1:n, j = 1:n, a(i, j) > 0.0)
+ select case (tag)
+ case (1)
+ a(i, j) = 1
+ case default
+ a(i, j) = 0
+ end select
+ end do
+end subroutine
+
+! CHECK-LABEL: Subroutine mask_two_indices
+! CHECK: <<DoConstruct~>>
+! CHECK: <<End DoConstruct~>>
+
+! FIR-LABEL: func.func @_QPmask_two_indices
+! FIR: fir.do_concurrent {
+! FIR: fir.do_concurrent.loop (%{{.*}}, %{{.*}}) =
+! FIR: %[[MASK:.*]] = arith.cmpf ogt
+! FIR: fir.if %[[MASK]] {
+! FIR: scf.execute_region no_inline {
+! FIR: fir.select_case
+! FIR: scf.yield
+! FIR: }
+
+! A CYCLE targets the EndDoStmt, so it does not escape the body.
+subroutine cycle_in_body(n, a, tag)
+ integer :: n, tag, i
+ real :: a(n)
+ do concurrent (i = 1:n)
+ select case (tag)
+ case (1)
+ cycle
+ case default
+ a(i) = 0
+ end select
+ end do
+end subroutine
+
+! CHECK-LABEL: Subroutine cycle_in_body
+! CHECK: <<DoConstruct~>>
+! CHECK: <<End DoConstruct~>>
+
+! FIR-LABEL: func.func @_QPcycle_in_body
+! FIR: fir.do_concurrent.loop
+! FIR: scf.execute_region no_inline {
+! FIR: fir.select_case
+! FIR: scf.yield
+! FIR: }
+
+! A locality specifier does not change the classification.
+subroutine local_spec(n, a, tag)
+ integer :: n, tag, i
+ real :: a(n), t
+ do concurrent (i = 1:n) local(t)
+ select case (tag)
+ case (1)
+ t = 1
+ case default
+ t = 2
+ end select
+ a(i) = t
+ end do
+end subroutine
+
+! CHECK-LABEL: Subroutine local_spec
+! CHECK: <<DoConstruct~>>
+! CHECK: <<End DoConstruct~>>
+
+! FIR-LABEL: func.func @_QPlocal_spec
+! FIR: fir.do_concurrent.loop {{.*}} local(
+! FIR: scf.execute_region no_inline {
+! FIR: fir.select_case
+! FIR: scf.yield
+! FIR: }
+
+! An EXIT of a BLOCK in the body stays in the body.
+subroutine exit_block(n, a)
+ integer :: n, i
+ real :: a(n)
+ do concurrent (i = 1:n)
+ b: block
+ if (a(i) < 0.0) exit b
+ a(i) = 1
+ end block b
+ end do
+end subroutine
+
+! CHECK-LABEL: Subroutine exit_block
+! CHECK: <<DoConstruct~>>
+! CHECK: <<BlockConstruct!>>
+! CHECK: <<End DoConstruct~>>
+
+! FIR-LABEL: func.func @_QPexit_block
+! FIR: fir.do_concurrent.loop
+! FIR: scf.execute_region no_inline {
+! FIR: cf.cond_br
+! FIR: scf.yield
+! FIR: }
+
+! An EXIT of an inner increment loop belongs to that loop. The inner loop
+! leaves the do concurrent structured, so the do concurrent needs no wrap.
+subroutine exit_inner_loop(n, a)
+ integer :: n, i, j
+ real :: a(n)
+ do concurrent (i = 1:n)
+ do j = 1, n
+ if (a(j) < 0.0) exit
+ a(i) = a(i) + 1
+ end do
+ end do
+end subroutine
+
+! CHECK-LABEL: Subroutine exit_inner_loop
+! CHECK: <<DoConstruct>>
+! CHECK: <<DoConstruct!>>
+! CHECK: <<End DoConstruct!>>
+! CHECK: <<End DoConstruct>>
+
+! FIR-LABEL: func.func @_QPexit_inner_loop
+! FIR: fir.do_concurrent.loop
+! FIR: scf.execute_region no_inline {
+! FIR: cf.cond_br
+! FIR: scf.yield
+! FIR: }
+
+! A GOTO back to an earlier statement of the body may never let the body
+! complete, so the loop stays unstructured.
+subroutine goto_cycle_in_body(n, a)
+ integer :: n, i
+ real :: a(n)
+ do concurrent (i = 1:n)
+10 a(i) = a(i) + 1.0
+ if (a(i) < 5.0) goto 10
+ end do
+end subroutine
+
+! CHECK-LABEL: Subroutine goto_cycle_in_body
+! CHECK: <<DoConstruct!>>
+! CHECK: <<End DoConstruct!>>
+
+! The whole construct is folded into one region, with the loop control as raw
+! branches inside it.
+! FIR-LABEL: func.func @_QPgoto_cycle_in_body
+! FIR-NOT: fir.do_concurrent
+! FIR: scf.execute_region no_inline {
+! FIR-NOT: fir.do_concurrent
+! FIR: cf.cond_br
+! FIR: scf.yield
+! FIR: }
+
+! An infinite DO in the body cannot run to completion either.
+subroutine infinite_inner(n, a)
+ integer :: n, i
+ real :: a(n)
+ do concurrent (i = 1:n)
+ do
+ a(i) = a(i) + 1.0
+ if (a(i) > 5.0) exit
+ end do
+ end do
+end subroutine
+
+! CHECK-LABEL: Subroutine infinite_inner
+! CHECK: <<DoConstruct!>>
+! CHECK: <<DoConstruct!>>
+! CHECK: <<End DoConstruct!>>
+! CHECK: <<End DoConstruct!>>
+
+! The infinite DO is not wrappable, so the loop control stays raw branches in
+! the function body.
+! FIR-LABEL: func.func @_QPinfinite_inner
+! FIR-NOT: fir.do_concurrent
+! FIR-NOT: scf.execute_region
+! FIR: cf.cond_br
+! FIR: return
diff --git a/flang/test/Lower/do_concurrent.f90 b/flang/test/Lower/do_concurrent.f90
index 99454c0e50b93c..a2353d00636eca 100644
--- a/flang/test/Lower/do_concurrent.f90
+++ b/flang/test/Lower/do_concurrent.f90
@@ -1,4 +1,5 @@
-! RUN: %flang_fc1 -emit-hlfir -o - %s | FileCheck %s
+! RUN: %flang_fc1 -emit-hlfir -o - %s | FileCheck %s --check-prefixes=CHECK,WRAP
+! RUN: %flang_fc1 -emit-hlfir -mmlir --wrap-unstructured-constructs-in-execute-region=false -o - %s | FileCheck %s --check-prefixes=CHECK,NOWRAP
! Simple tests for structured concurrent loops with loop-control.
@@ -86,39 +87,66 @@ subroutine sub2(n)
end do
end subroutine
+! The computed GOTO's targets are all inside the body, so the loop keeps its
+! structured form and only the body is folded into an scf.execute_region,
+! inside the mask test.
!CHECK-LABEL: unstructured
subroutine unstructured(inner_step)
integer(4) :: i, j, inner_step
-!CHECK-NOT: cf.br
-!CHECK-NOT: cf.cond_br
-!CHECK: %[[LB1:.*]] = arith.constant 1 : i32
-!CHECK: %[[LB1_CVT:.*]] = fir.convert %c1_i32 : (i32) -> i16
-!CHECK: %[[UB1:.*]] = arith.constant 5 : i32
-!CHECK: %[[UB1_CVT:.*]] = fir.convert %c5_i32 : (i32) -> i16
-!CHECK: %[[STP1:.*]] = arith.constant 1 : i16
-
-!CHECK-NOT: cf.br
-!CHECK-NOT: cf.cond_br
-!CHECK: %[[LB2:.*]] = arith.constant 3 : i32
-!CHECK: %[[LB2_CVT:.*]] = fir.convert %[[LB2]] : (i32) -> i16
-!CHECK: %[[UB2:.*]] = arith.constant 9 : i32
-!CHECK: %[[UB2_CVT:.*]] = fir.convert %[[UB2]] : (i32) -> i16
-!CHECK: %[[STP2:.*]] = fir.load %{{.*}}#0 : !fir.ref<i32>
-!CHECK: %[[STP2_CVT:.*]] = fir.convert %[[STP2]] : (i32) -> i16
-!CHECK: fir.store %[[STP2_CVT]] to %{{.*}} : !fir.ref<i16>
-!CHECK: cf.br ^[[I_LOOP_HEADER:.*]]
-
-!CHECK: ^[[I_LOOP_HEADER]]:
-!CHECK-NEXT: %{{.*}} = fir.load %{{.*}} : !fir.ref<i16>
-!CHECK-NEXT: %{{.*}} = arith.constant 0 : i16
-!CHECK-NEXT: %{{.*}} = arith.cmpi sgt, %{{.*}}, %{{.*}}: i16
-!CHECK-NEXT: cf.cond_br %{{.*}}, ^[[J_LOOP_HEADER:.*]], ^{{.*}}
-
-!CHECK: ^[[J_LOOP_HEADER]]:
-!CHECK-NEXT: %[[RANGE:.*]] = arith.subi %[[UB2_CVT]], %[[LB2_CVT]] : i16
-!CHECK-NEXT: %{{.*}} = arith.addi %[[RANGE]], %[[STP2_CVT]] : i16
-!CHECK-NEXT: %{{.*}} = arith.divsi %{{.*}}, %[[STP2_CVT]] : i16
+!WRAP: %[[LB1:.*]] = arith.constant 1 : i32
+!WRAP: %[[LB1_CVT:.*]] = fir.convert %[[LB1]] : (i32) -> index
+!WRAP: %[[UB1:.*]] = arith.constant 5 : i32
+!WRAP: %[[UB1_CVT:.*]] = fir.convert %[[UB1]] : (i32) -> index
+!WRAP: %[[STP1:.*]] = arith.constant 1 : index
+!WRAP: %[[LB2:.*]] = arith.constant 3 : i32
+!WRAP: %[[LB2_CVT:.*]] = fir.convert %[[LB2]] : (i32) -> index
+!WRAP: %[[UB2:.*]] = arith.constant 9 : i32
+!WRAP: %[[UB2_CVT:.*]] = fir.convert %[[UB2]] : (i32) -> index
+!WRAP: %[[STP2:.*]] = fir.load %{{.*}}#0 : !fir.ref<i32>
+!WRAP: %[[STP2_CVT:.*]] = fir.convert %[[STP2]] : (i32) -> index
+!WRAP: fir.do_concurrent {
+!WRAP: fir.do_concurrent.loop (%{{.*}}, %{{.*}}) = (%[[LB1_CVT]], %[[LB2_CVT]]) to (%[[UB1_CVT]], %[[UB2_CVT]]) step (%[[STP1]], %[[STP2_CVT]]) {
+!WRAP: %[[MASK:.*]] = arith.cmpi ne
+!WRAP: fir.if %[[MASK]] {
+!WRAP: scf.execute_region no_inline {
+!WRAP: fir.select
+!WRAP: scf.yield
+!WRAP: }
+!WRAP: }
+!WRAP: }
+!WRAP: }
+
+! With the wrap disabled, the loop is lowered as raw branches.
+!NOWRAP-NOT: cf.br
+!NOWRAP-NOT: cf.cond_br
+!NOWRAP: %[[LB1:.*]] = arith.constant 1 : i32
+!NOWRAP: %[[LB1_CVT:.*]] = fir.convert %c1_i32 : (i32) -> i16
+!NOWRAP: %[[UB1:.*]] = arith.constant 5 : i32
+!NOWRAP: %[[UB1_CVT:.*]] = fir.convert %c5_i32 : (i32) -> i16
+!NOWRAP: %[[STP1:.*]] = arith.constant 1 : i16
+
+!NOWRAP-NOT: cf.br
+!NOWRAP-NOT: cf.cond_br
+!NOWRAP: %[[LB2:.*]] = arith.constant 3 : i32
+!NOWRAP: %[[LB2_CVT:.*]] = fir.convert %[[LB2]] : (i32) -> i16
+!NOWRAP: %[[UB2:.*]] = arith.constant 9 : i32
+!NOWRAP: %[[UB2_CVT:.*]] = fir.convert %[[UB2]] : (i32) -> i16
+!NOWRAP: %[[STP2:.*]] = fir.load %{{.*}}#0 : !fir.ref<i32>
+!NOWRAP: %[[STP2_CVT:.*]] = fir.convert %[[STP2]] : (i32) -> i16
+!NOWRAP: fir.store %[[STP2_CVT]] to %{{.*}} : !fir.ref<i16>
+!NOWRAP: cf.br ^[[I_LOOP_HEADER:.*]]
+
+!NOWRAP: ^[[I_LOOP_HEADER]]:
+!NOWRAP-NEXT: %{{.*}} = fir.load %{{.*}} : !fir.ref<i16>
+!NOWRAP-NEXT: %{{.*}} = arith.constant 0 : i16
+!NOWRAP-NEXT: %{{.*}} = arith.cmpi sgt, %{{.*}}, %{{.*}}: i16
+!NOWRAP-NEXT: cf.cond_br %{{.*}}, ^[[J_LOOP_HEADER:.*]], ^{{.*}}
+
+!NOWRAP: ^[[J_LOOP_HEADER]]:
+!NOWRAP-NEXT: %[[RANGE:.*]] = arith.subi %[[UB2_CVT]], %[[LB2_CVT]] : i16
+!NOWRAP-NEXT: %{{.*}} = arith.addi %[[RANGE]], %[[STP2_CVT]] : i16
+!NOWRAP-NEXT: %{{.*}} = arith.divsi %{{.*}}, %[[STP2_CVT]] : i16
do concurrent (integer(2)::i=1:5, j=3:9:inner_step, i.ne.3)
goto (7, 7) i+1
print*, 'E:', i, j
diff --git a/flang/test/Lower/do_loop_unstructured.f90 b/flang/test/Lower/do_loop_unstructured.f90
index e38c6ceda0f2be..51db47fbaf49ec 100644
--- a/flang/test/Lower/do_loop_unstructured.f90
+++ b/flang/test/Lower/do_loop_unstructured.f90
@@ -89,16 +89,15 @@ subroutine unstructured_do_concurrent
error stop "fail"
enddo
end
+! The ERROR STOP stays in the body, so the loop keeps its structured form and
+! only the body is folded into a region.
! CHECK-LABEL: func.func @_QPunstructured_do_concurrent
-! CHECK: %[[ITER_VAR:.*]] = fir.alloca i32
-! CHECK: scf.execute_region no_inline {
-! CHECK: cf.br ^[[HEADER:.*]]
-! CHECK: ^[[HEADER]]:
-! CHECK: %{{.*}} = fir.load %[[ITER_VAR]] : !fir.ref<i32>
-! CHECK: cf.cond_br %{{.*}}, ^[[BODY:.*]], ^[[EXIT:.*]]
-! CHECK: ^[[BODY]]:
-! CHECK-NEXT: %{{.*}} = fir.alloca !fir.logical<4> <{bindc_name = "success", {{.*}}}>
-! CHECK: ^[[EXIT]]:
-! CHECK-NEXT: scf.yield
-! CHECK: }
+! CHECK: fir.do_concurrent {
+! CHECK: fir.do_concurrent.loop (%{{.*}}) = (%{{.*}}) to (%{{.*}}) step (%{{.*}}) local(@{{.*}}success{{.*}}) {
+! CHECK: scf.execute_region no_inline {
+! CHECK: fir.call @_FortranAStopStatementText
+! CHECK-NEXT: fir.unreachable
+! CHECK-NEXT: }
+! CHECK-NEXT: }
+! CHECK-NEXT: }
! CHECK: return
diff --git a/flang/test/Lower/loops.f90 b/flang/test/Lower/loops.f90
index 0c1dc9f5ae04d2..b1bdf9c11dbbe6 100644
--- a/flang/test/Lower/loops.f90
+++ b/flang/test/Lower/loops.f90
@@ -64,8 +64,12 @@ subroutine loop_test
6 continue
enddo
- ! CHECK-NOT: fir.do_loop
- ! CHECK-NOT: fir.if
+ ! The computed GOTO's targets are inside the body, so only the body is
+ ! folded into a region, inside the mask test.
+ ! CHECK: fir.do_concurrent.loop (%{{.*}}) = {{.*}}
+ ! CHECK: fir.if
+ ! CHECK: scf.execute_region no_inline {
+ ! CHECK: fir.select
do concurrent (integer(2)::i=1:5, i.ne.3)
goto (7, 7) i+1
! CHECK: fir.call @_FortranAioBeginExternalListOutput
More information about the llvm-branch-commits
mailing list