[flang-commits] [flang] 98fcc11 - [flang][NFC] Converted five tests from old lowering to new lowering (part 17) (#180869)
via flang-commits
flang-commits at lists.llvm.org
Wed Feb 11 05:50:39 PST 2026
Author: Eugene Epshteyn
Date: 2026-02-11T08:50:34-05:00
New Revision: 98fcc11d1a61d0daf0a101ff571e5b07b92ccdf2
URL: https://github.com/llvm/llvm-project/commit/98fcc11d1a61d0daf0a101ff571e5b07b92ccdf2
DIFF: https://github.com/llvm/llvm-project/commit/98fcc11d1a61d0daf0a101ff571e5b07b92ccdf2.diff
LOG: [flang][NFC] Converted five tests from old lowering to new lowering (part 17) (#180869)
Tests converted from test/Lower: goto-do-body.f90, mixed_loops.f90,
while_loop.f90
>From test/Lower/forall: degenerate.f90, forall-2.f90
Added:
Modified:
flang/test/Lower/forall/degenerate.f90
flang/test/Lower/forall/forall-2.f90
flang/test/Lower/goto-do-body.f90
flang/test/Lower/mixed_loops.f90
flang/test/Lower/while_loop.f90
Removed:
################################################################################
diff --git a/flang/test/Lower/forall/degenerate.f90 b/flang/test/Lower/forall/degenerate.f90
index c10c0a9edf829..a5a071565b3fd 100644
--- a/flang/test/Lower/forall/degenerate.f90
+++ b/flang/test/Lower/forall/degenerate.f90
@@ -1,6 +1,14 @@
-! RUN: bbc -emit-fir -hlfir=false %s -o - | FileCheck %s
+! RUN: %flang_fc1 -emit-hlfir %s -o - | FileCheck %s
-! CHECK-LABEL: func @_QPpointer_forall_degenerated_assignment() {
+! CHECK-LABEL: func.func @_QPpointer_forall_degenerated_assignment() {
+! CHECK: %[[P:.*]] = fir.alloca !fir.box<!fir.ptr<i32>>
+! CHECK: hlfir.declare %[[P]] {{.*}}pointer{{.*}} : (!fir.ref<!fir.box<!fir.ptr<i32>>>) -> (!fir.ref<!fir.box<!fir.ptr<i32>>>, !fir.ref<!fir.box<!fir.ptr<i32>>>)
+! CHECK: hlfir.forall lb {
+! CHECK: hlfir.yield %{{.*}} : i32
+! CHECK: } ub {
+! CHECK: hlfir.yield %{{.*}} : i32
+! CHECK: } (%{{.*}}: i32) {
+! CHECK: }
subroutine pointer_forall_degenerated_assignment()
integer, pointer :: p
@@ -11,20 +19,21 @@ subroutine pointer_forall_degenerated_assignment()
end forall
end subroutine
-! CHECK-LABEL: func @_QPlogical_forall_degenerated_assignment() {
-! CHECK: %[[VAL_0:.*]] = fir.alloca i32 {adapt.valuebyref, bindc_name = "i"}
-! CHECK: %[[VAL_1:.*]] = fir.alloca !fir.logical<4> {bindc_name = "l", uniq_name = "_QFlogical_forall_degenerated_assignmentEl"}
-! CHECK: %[[VAL_2:.*]] = arith.constant 1 : i32
-! CHECK: %[[VAL_3:.*]] = fir.convert %[[VAL_2]] : (i32) -> index
-! CHECK: %[[VAL_4:.*]] = arith.constant 1 : i32
-! CHECK: %[[VAL_5:.*]] = fir.convert %[[VAL_4]] : (i32) -> index
-! CHECK: %[[VAL_6:.*]] = arith.constant 1 : index
-! CHECK: fir.do_loop %[[VAL_7:.*]] = %[[VAL_3]] to %[[VAL_5]] step %[[VAL_6]] unordered {
-! CHECK: %[[VAL_8:.*]] = fir.convert %[[VAL_7]] : (index) -> i32
-! CHECK: fir.store %[[VAL_8]] to %[[VAL_0]] : !fir.ref<i32>
-! CHECK: %[[VAL_9:.*]] = arith.constant true
-! CHECK: %[[VAL_10:.*]] = fir.convert %[[VAL_9]] : (i1) -> !fir.logical<4>
-! CHECK: fir.store %[[VAL_10]] to %[[VAL_1]] : !fir.ref<!fir.logical<4>>
+! CHECK-LABEL: func.func @_QPlogical_forall_degenerated_assignment() {
+! CHECK: %[[L_ALLOCA:.*]] = fir.alloca !fir.logical<4> {bindc_name = "l", uniq_name = "_QFlogical_forall_degenerated_assignmentEl"}
+! CHECK: %[[L:.*]]:2 = hlfir.declare %[[L_ALLOCA]] {uniq_name = "_QFlogical_forall_degenerated_assignmentEl"} : (!fir.ref<!fir.logical<4>>) -> (!fir.ref<!fir.logical<4>>, !fir.ref<!fir.logical<4>>)
+! CHECK: hlfir.forall lb {
+! CHECK: hlfir.yield %{{.*}} : i32
+! CHECK: } ub {
+! CHECK: hlfir.yield %{{.*}} : i32
+! CHECK: } (%{{.*}}: i32) {
+! CHECK: hlfir.region_assign {
+! CHECK: %[[TRUE:.*]] = arith.constant true
+! CHECK: %[[VAL:.*]] = fir.convert %[[TRUE]] : (i1) -> !fir.logical<4>
+! CHECK: hlfir.yield %[[VAL]] : !fir.logical<4>
+! CHECK: } to {
+! CHECK: hlfir.yield %[[L]]#0 : !fir.ref<!fir.logical<4>>
+! CHECK: }
! CHECK: }
! CHECK: return
! CHECK: }
@@ -35,4 +44,3 @@ subroutine logical_forall_degenerated_assignment()
l = .true.
end forall
end subroutine
-
diff --git a/flang/test/Lower/forall/forall-2.f90 b/flang/test/Lower/forall/forall-2.f90
index c6a20f5859497..77b73cb44a78f 100644
--- a/flang/test/Lower/forall/forall-2.f90
+++ b/flang/test/Lower/forall/forall-2.f90
@@ -1,7 +1,6 @@
-! RUN: bbc -emit-fir -hlfir=false %s -o - | FileCheck %s
-! RUN: bbc -hlfir=false %s -o - | FileCheck --check-prefix=POSTOPT %s
+! RUN: %flang_fc1 -emit-hlfir %s -o - | FileCheck %s
-! CHECK-LABEL: func @_QPimplied_iters_allocatable(
+! CHECK-LABEL: func.func @_QPimplied_iters_allocatable(
! CHECK-SAME: %[[VAL_0:.*]]: !fir.box<!fir.array<?x!fir.type<_QFimplied_iters_allocatableTt{oui:!fir.logical<4>,arr:!fir.box<!fir.heap<!fir.array<?xf32>>>}>>>{{.*}}, %[[VAL_1:.*]]: !fir.box<!fir.array<?xf32>>{{.*}}) {
! CHECK: return
! CHECK: }
@@ -23,6 +22,11 @@ subroutine implied_iters_allocatable(thing, a1)
end forall
end subroutine implied_iters_allocatable
+! CHECK-LABEL: func.func @_QPconflicting_allocatable(
+! CHECK-SAME: %[[VAL_0:.*]]: !fir.box<!fir.array<?x!fir.type<_QFconflicting_allocatableTt{oui:!fir.logical<4>,arr:!fir.box<!fir.heap<!fir.array<?xf32>>>}>>>{{.*}}, %[[VAL_1:.*]]: !fir.ref<i32>{{.*}}, %[[VAL_2:.*]]: !fir.ref<i32>{{.*}}) {
+! CHECK: return
+! CHECK: }
+
subroutine conflicting_allocatable(thing, lo, hi)
! Introduce a crossing dependence to produce copy-in/copy-out code.
integer :: lo,hi
@@ -39,50 +43,40 @@ subroutine conflicting_allocatable(thing, lo, hi)
end forall
end subroutine conflicting_allocatable
-! CHECK-LABEL: func @_QPforall_pointer_assign(
-! CHECK-SAME: %[[VAL_0:.*]]: !fir.box<!fir.array<?x!fir.type<_QFforall_pointer_assignTt{ptr:!fir.box<!fir.ptr<!fir.array<?xf32>>>}>>> {fir.bindc_name = "ap"}, %[[VAL_1:.*]]: !fir.ref<f32> {fir.bindc_name = "at"}, %[[VAL_2:.*]]: !fir.ref<i32> {fir.bindc_name = "ii"}, %[[VAL_3:.*]]: !fir.ref<i32> {fir.bindc_name = "ij"}) {
-! CHECK: %[[VAL_4:.*]] = fir.alloca i32 {adapt.valuebyref, bindc_name = "i"}
-! CHECK: %[[VAL_5:.*]] = fir.load %[[VAL_2]] : !fir.ref<i32>
-! CHECK: %[[VAL_6:.*]] = fir.convert %[[VAL_5]] : (i32) -> index
-! CHECK: %[[VAL_7:.*]] = fir.load %[[VAL_3]] : !fir.ref<i32>
-! CHECK: %[[VAL_8:.*]] = fir.convert %[[VAL_7]] : (i32) -> index
-! CHECK: %[[VAL_9:.*]] = arith.constant 8 : i32
-! CHECK: %[[VAL_10:.*]] = fir.convert %[[VAL_9]] : (i32) -> index
-! CHECK: %[[VAL_11:.*]] = fir.array_load %[[VAL_0]] : (!fir.box<!fir.array<?x!fir.type<_QFforall_pointer_assignTt{ptr:!fir.box<!fir.ptr<!fir.array<?xf32>>>}>>>) -> !fir.array<?x!fir.type<_QFforall_pointer_assignTt{ptr:!fir.box<!fir.ptr<!fir.array<?xf32>>>}>>
-! CHECK: %[[VAL_12:.*]] = fir.array_load %[[VAL_0]] : (!fir.box<!fir.array<?x!fir.type<_QFforall_pointer_assignTt{ptr:!fir.box<!fir.ptr<!fir.array<?xf32>>>}>>>) -> !fir.array<?x!fir.type<_QFforall_pointer_assignTt{ptr:!fir.box<!fir.ptr<!fir.array<?xf32>>>}>>
-! CHECK: %[[VAL_13:.*]] = fir.do_loop %[[VAL_14:.*]] = %[[VAL_6]] to %[[VAL_8]] step %[[VAL_10]] unordered iter_args(%[[VAL_15:.*]] = %[[VAL_11]]) -> (!fir.array<?x!fir.type<_QFforall_pointer_assignTt{ptr:!fir.box<!fir.ptr<!fir.array<?xf32>>>}>>) {
-! CHECK: %[[VAL_16:.*]] = fir.convert %[[VAL_14]] : (index) -> i32
-! CHECK: fir.store %[[VAL_16]] to %[[VAL_4]] : !fir.ref<i32>
-! CHECK-DAG: %[[VAL_17:.*]] = arith.constant 1 : index
-! CHECK-DAG: %[[VAL_18:.*]] = arith.constant 1 : i32
-! CHECK-DAG: %[[VAL_19:.*]] = fir.load %[[VAL_4]] : !fir.ref<i32>
-! CHECK: %[[VAL_20:.*]] = arith.subi %[[VAL_19]], %[[VAL_18]] : i32
-! CHECK: %[[VAL_21:.*]] = fir.convert %[[VAL_20]] : (i32) -> i64
-! CHECK: %[[VAL_22:.*]] = fir.convert %[[VAL_21]] : (i64) -> index
-! CHECK: %[[VAL_23:.*]] = arith.subi %[[VAL_22]], %[[VAL_17]] : index
-! CHECK: %[[VAL_24:.*]] = fir.field_index ptr, !fir.type<_QFforall_pointer_assignTt{ptr:!fir.box<!fir.ptr<!fir.array<?xf32>>>}>
-! CHECK: %[[VAL_25:.*]] = fir.array_fetch %[[VAL_12]], %[[VAL_23]], %[[VAL_24]] : (!fir.array<?x!fir.type<_QFforall_pointer_assignTt{ptr:!fir.box<!fir.ptr<!fir.array<?xf32>>>}>>, index, !fir.field) -> !fir.box<!fir.ptr<!fir.array<?xf32>>>
-! CHECK: %[[VAL_26:.*]] = arith.constant 1 : index
-! CHECK: %[[VAL_27:.*]] = fir.load %[[VAL_4]] : !fir.ref<i32>
-! CHECK: %[[VAL_28:.*]] = fir.convert %[[VAL_27]] : (i32) -> i64
-! CHECK: %[[VAL_29:.*]] = fir.convert %[[VAL_28]] : (i64) -> index
-! CHECK: %[[VAL_30:.*]] = arith.subi %[[VAL_29]], %[[VAL_26]] : index
-! CHECK: %[[VAL_31:.*]] = fir.field_index ptr, !fir.type<_QFforall_pointer_assignTt{ptr:!fir.box<!fir.ptr<!fir.array<?xf32>>>}>
-! CHECK: %[[VAL_32:.*]] = fir.array_update %[[VAL_15]], %[[VAL_25]], %[[VAL_30]], %[[VAL_31]] : (!fir.array<?x!fir.type<_QFforall_pointer_assignTt{ptr:!fir.box<!fir.ptr<!fir.array<?xf32>>>}>>, !fir.box<!fir.ptr<!fir.array<?xf32>>>, index, !fir.field) -> !fir.array<?x!fir.type<_QFforall_pointer_assignTt{ptr:!fir.box<!fir.ptr<!fir.array<?xf32>>>}>>
-! CHECK: fir.result %[[VAL_32]] : !fir.array<?x!fir.type<_QFforall_pointer_assignTt{ptr:!fir.box<!fir.ptr<!fir.array<?xf32>>>}>>
-! CHECK: }
-! CHECK: fir.array_merge_store %[[VAL_11]], %[[VAL_33:.*]] to %[[VAL_0]] : !fir.array<?x!fir.type<_QFforall_pointer_assignTt{ptr:!fir.box<!fir.ptr<!fir.array<?xf32>>>}>>, !fir.array<?x!fir.type<_QFforall_pointer_assignTt{ptr:!fir.box<!fir.ptr<!fir.array<?xf32>>>}>>, !fir.box<!fir.array<?x!fir.type<_QFforall_pointer_assignTt{ptr:!fir.box<!fir.ptr<!fir.array<?xf32>>>}>>>
-! CHECK: return
-! CHECK: }
-
-! POSTOPT-LABEL: func @_QPforall_pointer_assign(
-! POSTOPT: %[[VAL_15:.*]] = fir.allocmem !fir.array<?x!fir.type<_QFforall_pointer_assignTt{ptr:!fir.box<!fir.ptr<!fir.array<?xf32>>>}>>, %{{.*}}#1
-! POSTOPT: ^bb{{[0-9]+}}(%[[VAL_16:.*]]: index, %[[VAL_17:.*]]: index):
-! POSTOPT: ^bb{{[0-9]+}}(%[[VAL_30:.*]]: index, %[[VAL_31:.*]]: index):
-! POSTOPT: ^bb{{[0-9]+}}(%[[VAL_46:.*]]: index, %[[VAL_47:.*]]: index):
-! POSTOPT-NOT: ^bb{{[0-9]+}}(%{{.*}}: index, %{{.*}}: index):
-! POSTOPT: fir.freemem %[[VAL_15]] : !fir.heap<!fir.array<?x!fir.type<_QFforall_pointer_assignTt{ptr:!fir.box<!fir.ptr<!fir.array<?xf32>>>}>>>
-! POSTOPT: }
+! CHECK-LABEL: func.func @_QPforall_pointer_assign(
+! CHECK-SAME: %[[VAL_0:.*]]: !fir.box<!fir.array<?x!fir.type<_QFforall_pointer_assignTt{ptr:!fir.box<!fir.ptr<!fir.array<?xf32>>>}>>> {{.*}}, %[[VAL_1:.*]]: !fir.ref<f32> {{.*}}, %[[VAL_2:.*]]: !fir.ref<i32> {{.*}}, %[[VAL_3:.*]]: !fir.ref<i32> {{.*}}) {
+! CHECK: %[[AP:.*]]:2 = hlfir.declare %[[VAL_0]]
+! CHECK: %[[AT:.*]]:2 = hlfir.declare %[[VAL_1]]
+! CHECK: %[[II:.*]]:2 = hlfir.declare %[[VAL_2]]
+! CHECK: %[[IJ:.*]]:2 = hlfir.declare %[[VAL_3]]
+! CHECK: %[[IIV:.*]] = fir.load %[[II]]#0
+! CHECK: %[[IJV:.*]] = fir.load %[[IJ]]#0
+! CHECK: %[[C8:.*]] = arith.constant 8 : i32
+! CHECK: hlfir.forall lb {
+! CHECK: hlfir.yield %[[IIV]] : i32
+! CHECK: } ub {
+! CHECK: hlfir.yield %[[IJV]] : i32
+! CHECK: } step {
+! CHECK: hlfir.yield %[[C8]] : i32
+! CHECK: } (%[[IARG:.*]]: i32) {
+! CHECK: %[[I:.*]] = hlfir.forall_index "i" %[[IARG]] : (i32) -> !fir.ref<i32>
+! CHECK: hlfir.region_assign {
+! CHECK: %[[IVAL:.*]] = fir.load %[[I]] : !fir.ref<i32>
+! CHECK: %[[C1:.*]] = arith.constant 1 : i32
+! CHECK: %[[IM1:.*]] = arith.subi %[[IVAL]], %[[C1]]
+! CHECK: %[[IIDX:.*]] = fir.convert %[[IM1]] : (i32) -> i64
+! CHECK: %[[APIM1:.*]] = hlfir.designate %[[AP]]#0 (%[[IIDX]])
+! CHECK: %[[APIM1PTR:.*]] = hlfir.designate %[[APIM1]]{"ptr"}
+! CHECK: %[[VAL:.*]] = fir.load %[[APIM1PTR]]
+! CHECK: hlfir.yield %[[VAL]] : !fir.box<!fir.ptr<!fir.array<?xf32>>>
+! CHECK: } to {
+! CHECK: %[[IVAL:.*]] = fir.load %[[I]] : !fir.ref<i32>
+! CHECK: %[[IIDX:.*]] = fir.convert %[[IVAL]] : (i32) -> i64
+! CHECK: %[[API:.*]] = hlfir.designate %[[AP]]#0 (%[[IIDX]])
+! CHECK: %[[APIPTR:.*]] = hlfir.designate %[[API]]{"ptr"}
+! CHECK: hlfir.yield %[[APIPTR]] : !fir.ref<!fir.box<!fir.ptr<!fir.array<?xf32>>>>
+! CHECK: }
+! CHECK: }
subroutine forall_pointer_assign(ap, at, ii, ij)
! Set pointer members in an array of derived type of pointers to arrays.
@@ -98,57 +92,29 @@ subroutine forall_pointer_assign(ap, at, ii, ij)
end forall
end subroutine forall_pointer_assign
-! CHECK-LABEL: func @_QPslice_with_explicit_iters() {
-! CHECK: %[[VAL_0:.*]] = fir.alloca i32 {adapt.valuebyref, bindc_name = "i"}
-! CHECK: %[[VAL_1:.*]] = arith.constant 10 : index
-! CHECK: %[[VAL_2:.*]] = arith.constant 10 : index
-! CHECK: %[[VAL_3:.*]] = fir.alloca !fir.array<10x10xi32> {bindc_name = "a", uniq_name = "_QFslice_with_explicit_itersEa"}
-! CHECK: %[[VAL_4:.*]] = arith.constant 1 : i32
-! CHECK: %[[VAL_5:.*]] = fir.convert %[[VAL_4]] : (i32) -> index
-! CHECK: %[[VAL_6:.*]] = arith.constant 5 : i32
-! CHECK: %[[VAL_7:.*]] = fir.convert %[[VAL_6]] : (i32) -> index
-! CHECK: %[[VAL_8:.*]] = arith.constant 1 : index
-! CHECK: %[[VAL_9:.*]] = fir.shape %[[VAL_1]], %[[VAL_2]] : (index, index) -> !fir.shape<2>
-! CHECK: %[[VAL_10:.*]] = fir.array_load %[[VAL_3]](%[[VAL_9]]) : (!fir.ref<!fir.array<10x10xi32>>, !fir.shape<2>) -> !fir.array<10x10xi32>
-! CHECK: %[[VAL_11:.*]] = fir.do_loop %[[VAL_12:.*]] = %[[VAL_5]] to %[[VAL_7]] step %[[VAL_8]] unordered iter_args(%[[VAL_13:.*]] = %[[VAL_10]]) -> (!fir.array<10x10xi32>) {
-! CHECK: %[[VAL_14:.*]] = fir.convert %[[VAL_12]] : (index) -> i32
-! CHECK: fir.store %[[VAL_14]] to %[[VAL_0]] : !fir.ref<i32>
-! CHECK: %[[VAL_15:.*]] = arith.constant 1 : index
-! CHECK: %[[VAL_16:.*]] = arith.constant 1 : i64
-! CHECK: %[[VAL_17:.*]] = fir.convert %[[VAL_16]] : (i64) -> index
-! CHECK: %[[VAL_18:.*]] = arith.constant 1 : i64
-! CHECK: %[[VAL_19:.*]] = fir.convert %[[VAL_18]] : (i64) -> index
-! CHECK: %[[VAL_20:.*]] = fir.load %[[VAL_0]] : !fir.ref<i32>
-! CHECK: %[[VAL_21:.*]] = fir.convert %[[VAL_20]] : (i32) -> i64
-! CHECK: %[[VAL_22:.*]] = fir.convert %[[VAL_21]] : (i64) -> index
-! CHECK: %[[VAL_23:.*]] = arith.constant 0 : index
-! CHECK: %[[VAL_24:.*]] = arith.subi %[[VAL_22]], %[[VAL_17]] : index
-! CHECK: %[[VAL_25:.*]] = arith.addi %[[VAL_24]], %[[VAL_19]] : index
-! CHECK: %[[VAL_26:.*]] = arith.divsi %[[VAL_25]], %[[VAL_19]] : index
-! CHECK: %[[VAL_27:.*]] = arith.cmpi sgt, %[[VAL_26]], %[[VAL_23]] : index
-! CHECK: %[[VAL_28:.*]] = arith.select %[[VAL_27]], %[[VAL_26]], %[[VAL_23]] : index
-! CHECK: %[[VAL_29:.*]] = fir.load %[[VAL_0]] : !fir.ref<i32>
-! CHECK: %[[VAL_30:.*]] = fir.convert %[[VAL_29]] : (i32) -> i64
-! CHECK: %[[VAL_31:.*]] = fir.convert %[[VAL_30]] : (i64) -> index
-! CHECK: %[[VAL_32:.*]] = arith.subi %[[VAL_31]], %[[VAL_15]] : index
-! CHECK: %[[VAL_39:.*]] = fir.load %[[VAL_0]] : !fir.ref<i32>
-! CHECK: %[[VAL_40:.*]] = arith.constant 0 : i32
-! CHECK: %[[VAL_41:.*]] = arith.subi %[[VAL_40]], %[[VAL_39]] : i32
-! CHECK: %[[VAL_33:.*]] = arith.constant 1 : index
-! CHECK: %[[VAL_34:.*]] = arith.constant 0 : index
-! CHECK: %[[VAL_35:.*]] = arith.subi %[[VAL_28]], %[[VAL_33]] : index
-! CHECK: %[[VAL_36:.*]] = fir.do_loop %[[VAL_37:.*]] = %[[VAL_34]] to %[[VAL_35]] step %[[VAL_33]] unordered iter_args(%[[VAL_38:.*]] = %[[VAL_13]]) -> (!fir.array<10x10xi32>) {
-! CHECK: %[[VAL_42:.*]] = arith.subi %[[VAL_17]], %[[VAL_15]] : index
-! CHECK: %[[VAL_43:.*]] = arith.muli %[[VAL_37]], %[[VAL_19]] : index
-! CHECK: %[[VAL_44:.*]] = arith.addi %[[VAL_42]], %[[VAL_43]] : index
-! CHECK: %[[VAL_45:.*]] = fir.array_update %[[VAL_38]], %[[VAL_41]], %[[VAL_44]], %[[VAL_32]] : (!fir.array<10x10xi32>, i32, index, index) -> !fir.array<10x10xi32>
-! CHECK: fir.result %[[VAL_45]] : !fir.array<10x10xi32>
-! CHECK: }
-! CHECK: fir.result %[[VAL_46:.*]] : !fir.array<10x10xi32>
-! CHECK: }
-! CHECK: fir.array_merge_store %[[VAL_10]], %[[VAL_47:.*]] to %[[VAL_3]] : !fir.array<10x10xi32>, !fir.array<10x10xi32>, !fir.ref<!fir.array<10x10xi32>>
-! CHECK: return
-! CHECK: }
+! CHECK-LABEL: func.func @_QPslice_with_explicit_iters() {
+! CHECK: %[[A_ADDR:.*]] = fir.alloca !fir.array<10x10xi32>
+! CHECK: %[[A:.*]]:2 = hlfir.declare %[[A_ADDR]]
+! CHECK: %[[C1:.*]] = arith.constant 1 : i32
+! CHECK: %[[C5:.*]] = arith.constant 5 : i32
+! CHECK: hlfir.forall lb {
+! CHECK: hlfir.yield %[[C1]] : i32
+! CHECK: } ub {
+! CHECK: hlfir.yield %[[C5]] : i32
+! CHECK: } (%[[IARG:.*]]: i32) {
+! CHECK: %[[I:.*]] = hlfir.forall_index "i" %[[IARG]] : (i32) -> !fir.ref<i32>
+! CHECK: hlfir.region_assign {
+! CHECK: %[[IVAL:.*]] = fir.load %[[I]] : !fir.ref<i32>
+! CHECK: %[[C0:.*]] = arith.constant 0 : i32
+! CHECK: %[[NEG_I:.*]] = arith.subi %[[C0]], %[[IVAL]]
+! CHECK: hlfir.yield %[[NEG_I]] : i32
+! CHECK: } to {
+! CHECK: %[[IVAL:.*]] = fir.load %[[I]] : !fir.ref<i32>
+! CHECK: %[[IIDX:.*]] = fir.convert %[[IVAL]] : (i32) -> i64
+! CHECK: %{{.*}} = hlfir.designate %[[A]]#0 {{.*}} : (!fir.ref<!fir.array<10x10xi32>>, index, index, index, i64, !fir.shape<1>) -> !fir.box<!fir.array<?xi32>>
+! CHECK: hlfir.yield {{.*}} : !fir.box<!fir.array<?xi32>>
+! CHECK: }
+! CHECK: }
subroutine slice_with_explicit_iters
@@ -158,47 +124,32 @@ subroutine slice_with_explicit_iters
end forall
end subroutine slice_with_explicit_iters
-! CHECK-LABEL: func @_QPembox_argument_with_slice(
-! CHECK-SAME: %[[VAL_0:.*]]: !fir.ref<!fir.array<1xi32>>{{.*}}, %[[VAL_1:.*]]: !fir.ref<!fir.array<2x2xi32>>{{.*}}) {
-! CHECK: %[[VAL_2:.*]] = fir.alloca i32 {adapt.valuebyref, bindc_name = "i"}
-! CHECK: %[[VAL_3:.*]] = arith.constant 1 : index
-! CHECK: %[[VAL_4:.*]] = arith.constant 2 : index
-! CHECK: %[[VAL_5:.*]] = arith.constant 2 : index
-! CHECK: %[[VAL_6:.*]] = arith.constant 1 : i32
-! CHECK: %[[VAL_7:.*]] = fir.convert %[[VAL_6]] : (i32) -> index
-! CHECK: %[[VAL_8:.*]] = arith.constant 1 : i32
-! CHECK: %[[VAL_9:.*]] = fir.convert %[[VAL_8]] : (i32) -> index
-! CHECK: %[[VAL_10:.*]] = arith.constant 1 : index
-! CHECK: %[[VAL_11:.*]] = fir.shape %[[VAL_3]] : (index) -> !fir.shape<1>
-! CHECK: %[[VAL_12:.*]] = fir.array_load %[[VAL_0]](%[[VAL_11]]) : (!fir.ref<!fir.array<1xi32>>, !fir.shape<1>) -> !fir.array<1xi32>
-! CHECK: %[[VAL_13:.*]] = fir.do_loop %[[VAL_14:.*]] = %[[VAL_7]] to %[[VAL_9]] step %[[VAL_10]] unordered iter_args(%[[VAL_15:.*]] = %[[VAL_12]]) -> (!fir.array<1xi32>) {
-! CHECK: %[[VAL_16:.*]] = fir.convert %[[VAL_14]] : (index) -> i32
-! CHECK: fir.store %[[VAL_16]] to %[[VAL_2]] : !fir.ref<i32>
-! CHECK-DAG: %[[VAL_18:.*]] = arith.constant 1 : index
-! CHECK-DAG: %[[VAL_19:.*]] = arith.constant 1 : i64
-! CHECK: %[[VAL_20:.*]] = fir.convert %[[VAL_19]] : (i64) -> index
-! CHECK: %[[VAL_21:.*]] = arith.addi %[[VAL_18]], %[[VAL_4]] : index
-! CHECK: %[[VAL_22:.*]] = arith.subi %[[VAL_21]], %[[VAL_18]] : index
-! CHECK: %[[VAL_23:.*]] = fir.load %[[VAL_2]] : !fir.ref<i32>
-! CHECK: %[[VAL_24:.*]] = fir.convert %[[VAL_23]] : (i32) -> i64
-! CHECK: %[[VAL_25:.*]] = fir.undefined index
-! CHECK: %[[VAL_26:.*]] = fir.shape %[[VAL_4]], %[[VAL_5]] : (index, index) -> !fir.shape<2>
-! CHECK: %[[VAL_27:.*]] = fir.slice %[[VAL_18]], %[[VAL_22]], %[[VAL_20]], %[[VAL_24]], %[[VAL_25]], %[[VAL_25]] : (index, index, index, i64, index, index) -> !fir.slice<2>
-! CHECK: %[[VAL_28:.*]] = fir.embox %[[VAL_1]](%[[VAL_26]]) {{\[}}%[[VAL_27]]] : (!fir.ref<!fir.array<2x2xi32>>, !fir.shape<2>, !fir.slice<2>) -> !fir.box<!fir.array<?xi32>>
-! CHECK: %[[VAL_29:.*]] = fir.call @_QPe(%[[VAL_28]]) {{.*}}: (!fir.box<!fir.array<?xi32>>) -> i32
-! CHECK: %[[VAL_17:.*]] = arith.constant 1 : i32
-! CHECK: %[[VAL_30:.*]] = arith.addi %[[VAL_29]], %[[VAL_17]] : i32
-! CHECK: %[[VAL_31:.*]] = arith.constant 1 : index
-! CHECK: %[[VAL_32:.*]] = fir.load %[[VAL_2]] : !fir.ref<i32>
-! CHECK: %[[VAL_33:.*]] = fir.convert %[[VAL_32]] : (i32) -> i64
-! CHECK: %[[VAL_34:.*]] = fir.convert %[[VAL_33]] : (i64) -> index
-! CHECK: %[[VAL_35:.*]] = arith.subi %[[VAL_34]], %[[VAL_31]] : index
-! CHECK: %[[VAL_36:.*]] = fir.array_update %[[VAL_15]], %[[VAL_30]], %[[VAL_35]] : (!fir.array<1xi32>, i32, index) -> !fir.array<1xi32>
-! CHECK: fir.result %[[VAL_36]] : !fir.array<1xi32>
-! CHECK: }
-! CHECK: fir.array_merge_store %[[VAL_12]], %[[VAL_37:.*]] to %[[VAL_0]] : !fir.array<1xi32>, !fir.array<1xi32>, !fir.ref<!fir.array<1xi32>>
-! CHECK: return
-! CHECK: }
+! CHECK-LABEL: func.func @_QPembox_argument_with_slice(
+! CHECK-SAME: %[[AARG:.*]]: !fir.ref<!fir.array<1xi32>> {{.*}}, %[[BARG:.*]]: !fir.ref<!fir.array<2x2xi32>> {{.*}}) {
+! CHECK: %[[A:.*]]:2 = hlfir.declare %[[AARG]]
+! CHECK: %[[B:.*]]:2 = hlfir.declare %[[BARG]]
+! CHECK: hlfir.forall lb {
+! CHECK: hlfir.yield {{.*}} : i32
+! CHECK: } ub {
+! CHECK: hlfir.yield {{.*}} : i32
+! CHECK: } (%[[IARG:.*]]: i32) {
+! CHECK: %[[I:.*]] = hlfir.forall_index "i" %[[IARG]] : (i32) -> !fir.ref<i32>
+! CHECK: hlfir.region_assign {
+! CHECK: %[[IVAL:.*]] = fir.load %[[I]] : !fir.ref<i32>
+! CHECK: %[[IIDX:.*]] = fir.convert %[[IVAL]] : (i32) -> i64
+! CHECK: %[[BI:.*]] = hlfir.designate %[[B]]#0 ({{.*}}, %[[IIDX]]) {{.*}} : (!fir.ref<!fir.array<2x2xi32>>, index, index, index, i64, !fir.shape<1>) -> !fir.ref<!fir.array<2xi32>>
+! CHECK: %[[BIBOX:.*]] = fir.embox %[[BI]]({{.*}}) : (!fir.ref<!fir.array<2xi32>>, !fir.shape<1>) -> !fir.box<!fir.array<2xi32>>
+! CHECK: %[[BIBOX_NONE:.*]] = fir.convert %[[BIBOX]] : (!fir.box<!fir.array<2xi32>>) -> !fir.box<!fir.array<?xi32>>
+! CHECK: %[[RES:.*]] = fir.call @_QPe(%[[BIBOX_NONE]]) {{.*}} : (!fir.box<!fir.array<?xi32>>) -> i32
+! CHECK: %{{.*}} = arith.addi %[[RES]], {{.*}}
+! CHECK: hlfir.yield {{.*}} : i32
+! CHECK: } to {
+! CHECK: %[[IVAL:.*]] = fir.load %[[I]] : !fir.ref<i32>
+! CHECK: %[[IIDX:.*]] = fir.convert %[[IVAL]] : (i32) -> i64
+! CHECK: %[[AI:.*]] = hlfir.designate %[[A]]#0 (%[[IIDX]])
+! CHECK: hlfir.yield %[[AI]] : !fir.ref<i32>
+! CHECK: }
+! CHECK: }
subroutine embox_argument_with_slice(a,b)
interface
diff --git a/flang/test/Lower/goto-do-body.f90 b/flang/test/Lower/goto-do-body.f90
index 880417c888104..c2e986dac308e 100644
--- a/flang/test/Lower/goto-do-body.f90
+++ b/flang/test/Lower/goto-do-body.f90
@@ -1,17 +1,18 @@
-! RUN: bbc %s -emit-fir -hlfir=false -o - | FileCheck %s
+! RUN: %flang_fc1 %s -emit-hlfir -o - | FileCheck %s
! Test jumping to the body of a do loop.
subroutine sub1()
-! CHECK-LABEL: func @_QPsub1() {
+! CHECK-LABEL: func.func @_QPsub1() {
implicit none
integer :: i
external foo
! CHECK: %[[TRIP:.*]] = fir.alloca i32
-! CHECK: %[[I:.*]] = fir.alloca i32 {bindc_name = "i", {{.*}}}
+! CHECK: %[[I_ADDR:.*]] = fir.alloca i32 {bindc_name = "i", {{.*}}}
+! CHECK: %[[I:.*]]:2 = hlfir.declare %[[I_ADDR]]
do i = 1, 3
if (i .eq. 2) goto 70
-! CHECK: %[[TMP1:.*]] = fir.load %[[I]] : !fir.ref<i32>
+! CHECK: %[[TMP1:.*]] = fir.load %[[I]]#0 : !fir.ref<i32>
! CHECK: %[[C2_1:.*]] = arith.constant 2 : i32
! CHECK: %[[COND:.*]] = arith.cmpi eq, %[[TMP1]], %[[C2_1]] : i32
! CHECK: cf.cond_br %[[COND]], ^[[COND_TRUE:.*]], ^{{.*}}
@@ -31,7 +32,7 @@ subroutine sub1()
! CHECK: %[[TMP3:.*]] = arith.addi %[[TMP2]], %[[C1_2]] : i32
! CHECK: %[[TMP4:.*]] = arith.divsi %[[TMP3]], %[[C1_2]] : i32
! CHECK: fir.store %[[TMP4]] to %[[TRIP]] : !fir.ref<i32>
-! CHECK: fir.store %[[C1_1]] to %[[I]] : !fir.ref<i32>
+! CHECK: fir.store %[[C1_1]] to %[[I]]#0 : !fir.ref<i32>
! CHECK: cf.br ^[[HEADER:.*]]
! CHECK: ^[[HEADER]]:
! CHECK: %[[TMP5:.*]] = fir.load %[[TRIP]] : !fir.ref<i32>
@@ -46,10 +47,10 @@ subroutine sub1()
! CHECK: %[[C1_3:.*]] = arith.constant 1 : i32
! CHECK: %[[TMP8:.*]] = arith.subi %[[TMP7]], %[[C1_3]] : i32
! CHECK: fir.store %[[TMP8]] to %[[TRIP]] : !fir.ref<i32>
-! CHECK: %[[TMP9:.*]] = fir.load %[[I]] : !fir.ref<i32>
+! CHECK: %[[TMP9:.*]] = fir.load %[[I]]#0 : !fir.ref<i32>
! CHECK: %[[C1_4:.*]] = arith.constant 1 : i32
! CHECK: %[[TMP10:.*]] = arith.addi %[[TMP9]], %[[C1_4]] overflow<nsw> : i32
-! CHECK: fir.store %[[TMP10]] to %[[I]] : !fir.ref<i32>
+! CHECK: fir.store %[[TMP10]] to %[[I]]#0 : !fir.ref<i32>
! CHECK: cf.br ^[[HEADER]]
end do
end subroutine
@@ -59,17 +60,19 @@ subroutine sub1()
! Test jumping to the body of a do loop with a step expression.
subroutine sub2()
-! CHECK-LABEL: func @_QPsub2() {
+! CHECK-LABEL: func.func @_QPsub2() {
implicit none
integer :: i, j
external foo
! CHECK: %[[TRIP:.*]] = fir.alloca i32
-! CHECK: %[[I:.*]] = fir.alloca i32 {bindc_name = "i", {{.*}}}
-! CHECK: %[[J:.*]] = fir.alloca i32 {bindc_name = "j", {{.*}}}
+! CHECK: %[[I_ADDR:.*]] = fir.alloca i32 {bindc_name = "i", {{.*}}}
+! CHECK: %[[I:.*]]:2 = hlfir.declare %[[I_ADDR]]
+! CHECK: %[[J_ADDR:.*]] = fir.alloca i32 {bindc_name = "j", {{.*}}}
+! CHECK: %[[J:.*]]:2 = hlfir.declare %[[J_ADDR]]
do i = 1, 3
if (i .eq. 2) goto 70
-! CHECK: %[[TMP1:.*]] = fir.load %[[I]] : !fir.ref<i32>
+! CHECK: %[[TMP1:.*]] = fir.load %[[I]]#0 : !fir.ref<i32>
! CHECK: %[[C2_1:.*]] = arith.constant 2 : i32
! CHECK: %[[COND:.*]] = arith.cmpi eq, %[[TMP1]], %[[C2_1]] : i32
! CHECK: cf.cond_br %[[COND]], ^[[COND_TRUE:.*]], ^{{.*}}
@@ -83,13 +86,13 @@ subroutine sub2()
j = 3
! CHECK: %[[C3_1:.*]] = arith.constant 3 : i32
-! CHECK: fir.store %[[C3_1]] to %[[J]] : !fir.ref<i32>
+! CHECK: hlfir.assign %[[C3_1]] to %[[J]]#0
do i = 1, 2, 3 * j - 8
! CHECK: %[[C1_1:.*]] = arith.constant 1 : i32
! CHECK: %[[C2_2:.*]] = arith.constant 2 : i32
! CHECK: %[[C3_2:.*]] = arith.constant 3 : i32
-! CHECK: %[[TMP2:.*]] = fir.load %[[J]] : !fir.ref<i32>
+! CHECK: %[[TMP2:.*]] = fir.load %[[J]]#0 : !fir.ref<i32>
! CHECK: %[[TMP3:.*]] = arith.muli %[[C3_2]], %[[TMP2]] overflow<nsw> : i32
! CHECK: %[[C8_1:.*]] = arith.constant 8 : i32
! CHECK: %[[STEP:.*]] = arith.subi %[[TMP3]], %[[C8_1]] overflow<nsw> : i32
@@ -98,7 +101,7 @@ subroutine sub2()
! CHECK: %[[TMP5:.*]] = arith.addi %[[TMP4]], %[[STEP]] : i32
! CHECK: %[[TMP6:.*]] = arith.divsi %[[TMP5]], %[[STEP]] : i32
! CHECK: fir.store %[[TMP6]] to %[[TRIP]] : !fir.ref<i32>
-! CHECK: fir.store %[[C1_1]] to %[[I]] : !fir.ref<i32>
+! CHECK: fir.store %[[C1_1]] to %[[I]]#0 : !fir.ref<i32>
! CHECK: cf.br ^[[HEADER:.*]]
! CHECK: ^[[HEADER]]:
! CHECK: %[[TMP7:.*]] = fir.load %[[TRIP]] : !fir.ref<i32>
@@ -113,10 +116,10 @@ subroutine sub2()
! CHECK: %[[C1_2:.*]] = arith.constant 1 : i32
! CHECK: %[[TMP10:.*]] = arith.subi %[[TMP9]], %[[C1_2]] : i32
! CHECK: fir.store %[[TMP10]] to %[[TRIP]] : !fir.ref<i32>
-! CHECK: %[[TMP11:.*]] = fir.load %[[I]] : !fir.ref<i32>
+! CHECK: %[[TMP11:.*]] = fir.load %[[I]]#0 : !fir.ref<i32>
! CHECK: %[[STEP_VAL:.*]] = fir.load %[[STEP_VAR]] : !fir.ref<i32>
! CHECK: %[[TMP12:.*]] = arith.addi %[[TMP11]], %[[STEP_VAL]] overflow<nsw> : i32
-! CHECK: fir.store %[[TMP12]] to %[[I]] : !fir.ref<i32>
+! CHECK: fir.store %[[TMP12]] to %[[I]]#0 : !fir.ref<i32>
! CHECK: cf.br ^[[HEADER]]
end do
end subroutine
diff --git a/flang/test/Lower/mixed_loops.f90 b/flang/test/Lower/mixed_loops.f90
index b0e1114b8dcf1..11534ae9490d0 100644
--- a/flang/test/Lower/mixed_loops.f90
+++ b/flang/test/Lower/mixed_loops.f90
@@ -1,122 +1,117 @@
-! RUN: bbc -emit-fir -hlfir=false -o - %s | FileCheck %s
-! RUN: %flang_fc1 -emit-fir -flang-deprecated-no-hlfir -o - %s | FileCheck %s
+! RUN: %flang_fc1 -emit-hlfir -o - %s | FileCheck %s
! Test while loop inside do loop.
! CHECK-LABEL: while_inside_do_loop
subroutine while_inside_do_loop
! CHECK-DAG: %[[T_REF:.*]] = fir.alloca i32
- ! CHECK-DAG: %[[I_REF:.*]] = fir.alloca i32 {bindc_name = "i", uniq_name = "_QFwhile_inside_do_loopEi"}
- ! CHECK-DAG: %[[J_REF:.*]] = fir.alloca i32 {bindc_name = "j", uniq_name = "_QFwhile_inside_do_loopEj"}
+ ! CHECK-DAG: %[[I_ADDR:.*]] = fir.alloca i32 {bindc_name = "i", uniq_name = "_QFwhile_inside_do_loopEi"}
+ ! CHECK-DAG: %[[I:.*]]:2 = hlfir.declare %[[I_ADDR]]
+ ! CHECK-DAG: %[[J_ADDR:.*]] = fir.alloca i32 {bindc_name = "j", uniq_name = "_QFwhile_inside_do_loopEj"}
+ ! CHECK-DAG: %[[J:.*]]:2 = hlfir.declare %[[J_ADDR]]
integer :: i, j
- ! CHECK-DAG: %[[C1:.*]] = arith.constant 1 : i32
! CHECK-DAG: %[[C8:.*]] = arith.constant 8 : i32
! CHECK-DAG: %[[C13:.*]] = arith.constant 13 : i32
+ ! CHECK-DAG: %[[C1:.*]] = arith.constant 1 : i32
! CHECK: %[[DIFF:.*]] = arith.subi %[[C13]], %[[C8]] : i32
! CHECK: %[[RANGE:.*]] = arith.addi %[[DIFF]], %[[C1]] : i32
! CHECK: %[[HIGH:.*]] = arith.divsi %[[RANGE]], %[[C1]] : i32
! CHECK: fir.store %[[HIGH]] to %[[T_REF]] : !fir.ref<i32>
- ! CHECK: fir.store %[[C8]] to %[[I_REF]] : !fir.ref<i32>
+ ! CHECK: fir.store %[[C8]] to %[[I]]#0 : !fir.ref<i32>
- ! CHECK: br ^[[HDR1:.*]]
+ ! CHECK: cf.br ^[[HDR1:.*]]
! CHECK: ^[[HDR1]]: // 2 preds: ^{{.*}}, ^[[EXIT2:.*]]
- ! CHECK-DAG: %[[T:.*]] = fir.load %[[T_REF]] : !fir.ref<i32>
- ! CHECK-DAG: %[[C0:.*]] = arith.constant 0 : i32
+ ! CHECK: %[[T:.*]] = fir.load %[[T_REF]] : !fir.ref<i32>
+ ! CHECK: %[[C0:.*]] = arith.constant 0 : i32
! CHECK: %[[COND:.*]] = arith.cmpi sgt, %[[T]], %[[C0]] : i32
- ! CHECK: cond_br %[[COND]], ^[[BODY1:.*]], ^[[EXIT1:.*]]
+ ! CHECK: cf.cond_br %[[COND]], ^[[BODY1:.*]], ^[[EXIT1:.*]]
do i=8,13
! CHECK: ^[[BODY1]]: // pred: ^[[HDR1]]
! CHECK: %[[C3:.*]] = arith.constant 3 : i32
- ! CHECK: fir.store %[[C3]] to %[[J_REF]] : !fir.ref<i32>
+ ! CHECK: hlfir.assign %[[C3]] to %[[J]]#0 : i32, !fir.ref<i32>
j=3
- ! CHECK: br ^[[HDR2:.*]]
+ ! CHECK: cf.br ^[[HDR2:.*]]
! CHECK: ^[[HDR2]]: // 2 preds: ^[[BODY1]], ^[[BODY2:.*]]
- ! CHECK-DAG: %[[J:.*]] = fir.load %[[J_REF]] : !fir.ref<i32>
- ! CHECK-DAG: %[[I:.*]] = fir.load %[[I_REF]] : !fir.ref<i32>
- ! CHECK: %[[COND2:.*]] = arith.cmpi slt, %[[J]], %[[I]] : i32
- ! CHECK: cond_br %[[COND2]], ^[[BODY2]], ^[[EXIT2]]
+ ! CHECK: %[[JVAL:.*]] = fir.load %[[J]]#0 : !fir.ref<i32>
+ ! CHECK: %[[IVAL:.*]] = fir.load %[[I]]#0 : !fir.ref<i32>
+ ! CHECK: %[[COND2:.*]] = arith.cmpi slt, %[[JVAL]], %[[IVAL]] : i32
+ ! CHECK: cf.cond_br %[[COND2]], ^[[BODY2:.*]], ^[[EXIT2]]
do while (j .lt. i)
! CHECK: ^[[BODY2]]: // pred: ^[[HDR2]]
- ! CHECK-DAG: %[[J2:.*]] = fir.load %[[J_REF]] : !fir.ref<i32>
- ! CHECK-DAG: %[[C2:.*]] = arith.constant 2 : i32
- ! CHECK: %[[INC2:.*]] = arith.muli %[[C2]], %[[J2]] : i32
- ! CHECK: fir.store %[[INC2]] to %[[J_REF]] : !fir.ref<i32>
+ ! CHECK: %[[C2:.*]] = arith.constant 2 : i32
+ ! CHECK: %[[JVAL2:.*]] = fir.load %[[J]]#0 : !fir.ref<i32>
+ ! CHECK: %[[INC2:.*]] = arith.muli %[[C2]], %[[JVAL2]] : i32
+ ! CHECK: hlfir.assign %[[INC2]] to %[[J]]#0 : i32, !fir.ref<i32>
j=j*2
- ! CHECK: br ^[[HDR2]]
+ ! CHECK: cf.br ^[[HDR2]]
end do
! CHECK: ^[[EXIT2]]: // pred: ^[[HDR2]]
- ! CHECK-DAG: %[[T2:.*]] = fir.load %[[T_REF]] : !fir.ref<i32>
- ! CHECK-DAG: %[[C1_AGAIN:.*]] = arith.constant 1 : i32
- ! CHECK: %[[TDEC:.*]] = arith.subi %[[T2]], %[[C1_AGAIN]] : i32
+ ! CHECK: %[[T2:.*]] = fir.load %[[T_REF]] : !fir.ref<i32>
+ ! CHECK: %[[TDEC:.*]] = arith.subi %[[T2]], {{.*}} : i32
! CHECK: fir.store %[[TDEC]] to %[[T_REF]]
- ! CHECK: %[[I3:.*]] = fir.load %[[I_REF]] : !fir.ref<i32>
- ! CHECK: %[[C1_2:.*]] = arith.constant 1 : i32
- ! CHECK: %[[IINC:.*]] = arith.addi %[[I3]], %[[C1_2]] overflow<nsw> : i32
- ! CHECK: fir.store %[[IINC]] to %[[I_REF]] : !fir.ref<i32>
- ! CHECK: br ^[[HDR1]]
+ ! CHECK: %[[I3:.*]] = fir.load %[[I]]#0 : !fir.ref<i32>
+ ! CHECK: %[[IINC:.*]] = arith.addi %[[I3]], {{.*}} overflow<nsw> : i32
+ ! CHECK: fir.store %[[IINC]] to %[[I]]#0 : !fir.ref<i32>
+ ! CHECK: cf.br ^[[HDR1]]
end do
! CHECK: ^[[EXIT1]]: // pred: ^[[HDR1]]
- ! CHECK: %[[IPRINT:.*]] = fir.load %[[I_REF]] : !fir.ref<i32>
- ! CHECK: fir.call @_FortranAioOutputInteger32(%{{.*}}, %[[IPRINT]]) {{.*}}: (!fir.ref<i8>, i32) -> i1
- ! CHECK: %[[JPRINT:.*]] = fir.load %[[J_REF]] : !fir.ref<i32>
- ! CHECK: fir.call @_FortranAioOutputInteger32(%{{.*}}, %[[JPRINT]]) {{.*}}: (!fir.ref<i8>, i32) -> i1
+ ! CHECK: %[[IPRINT:.*]] = fir.load %[[I]]#0 : !fir.ref<i32>
+ ! CHECK: fir.call @_FortranAioOutputInteger32(%{{.*}}, %[[IPRINT]])
+ ! CHECK: %[[JPRINT:.*]] = fir.load %[[J]]#0 : !fir.ref<i32>
+ ! CHECK: fir.call @_FortranAioOutputInteger32(%{{.*}}, %[[JPRINT]])
print *, i, j
end subroutine
! Test do loop inside while loop.
! CHECK-LABEL: do_inside_while_loop
subroutine do_inside_while_loop
- ! CHECK-DAG: %[[I_REF:.*]] = fir.alloca i32 {bindc_name = "i", uniq_name = "_QFdo_inside_while_loopEi"}
- ! CHECK-DAG: %[[J_REF:.*]] = fir.alloca i32 {bindc_name = "j", uniq_name = "_QFdo_inside_while_loopEj"}
+ ! CHECK-DAG: %[[I_ADDR:.*]] = fir.alloca i32 {bindc_name = "i", uniq_name = "_QFdo_inside_while_loopEi"}
+ ! CHECK-DAG: %[[I:.*]]:2 = hlfir.declare %[[I_ADDR]]
+ ! CHECK-DAG: %[[J_ADDR:.*]] = fir.alloca i32 {bindc_name = "j", uniq_name = "_QFdo_inside_while_loopEj"}
+ ! CHECK-DAG: %[[J:.*]]:2 = hlfir.declare %[[J_ADDR]]
integer :: i, j
! CHECK: %[[C3:.*]] = arith.constant 3 : i32
- ! CHECK: fir.store %[[C3]] to %[[J_REF]] : !fir.ref<i32>
+ ! CHECK: hlfir.assign %[[C3]] to %[[J]]#0 : i32, !fir.ref<i32>
j=3
- ! CHECK: br ^[[HDR1:.*]]
+ ! CHECK: cf.br ^[[HDR1:.*]]
! CHECK: ^[[HDR1]]: // 2 preds: ^{{.*}}, ^[[BODY1:.*]]
- ! CHECK-DAG: %[[J:.*]] = fir.load %[[J_REF]] : !fir.ref<i32>
- ! CHECK-DAG: %[[UL:.*]] = arith.constant 21 : i32
- ! CHECK: %[[COND:.*]] = arith.cmpi slt, %[[J]], %[[UL]] : i32
- ! CHECK: cond_br %[[COND]], ^[[BODY1]], ^[[EXIT1:.*]]
+ ! CHECK: %[[JVAL:.*]] = fir.load %[[J]]#0 : !fir.ref<i32>
+ ! CHECK: %[[UL:.*]] = arith.constant 21 : i32
+ ! CHECK: %[[COND:.*]] = arith.cmpi slt, %[[JVAL]], %[[UL]] : i32
+ ! CHECK: cf.cond_br %[[COND]], ^[[BODY1]], ^[[EXIT1:.*]]
do while (j .lt. 21)
! CHECK: ^[[BODY1]]: // pred: ^[[HDR1]]
- ! CHECK-DAG: %[[C8_I32:.*]] = arith.constant 8 : i32
- ! CHECK-DAG: %[[C8:.*]] = fir.convert %[[C8_I32]] : (i32) -> index
- ! CHECK-DAG: %[[C13_I32:.*]] = arith.constant 13 : i32
- ! CHECK-DAG: %[[C13:.*]] = fir.convert %[[C13_I32]] : (i32) -> index
+ ! CHECK-DAG: %[[C8:.*]] = arith.constant 8 : i32
+ ! CHECK-DAG: %[[C13:.*]] = arith.constant 13 : i32
! CHECK-DAG: %[[C1:.*]] = arith.constant 1 : index
- ! CHECK: %[[I_LB:.*]] = fir.convert %[[C8]] : (index) -> i32
- ! CHECK: %[[RESULT:.*]] = fir.do_loop %[[IDX:[^ ]*]] =
- ! CHECK-SAME: %[[C8]] to %[[C13]] step %[[C1]]
- ! CHECK-SAME: iter_args(%[[I_IV:.*]] = %[[I_LB]]) -> (i32) {
- ! CHECK: fir.store %[[I_IV]] to %[[I_REF]] : !fir.ref<i32>
- ! CHECK-DAG: %[[J2:.*]] = fir.load %[[J_REF]] : !fir.ref<i32>
- ! CHECK-DAG: %[[C2:.*]] = arith.constant 2 : i32
- ! CHECK: %[[JINC:.*]] = arith.muli %[[C2]], %[[J2]] : i32
- ! CHECK: fir.store %[[JINC]] to %[[J_REF]] : !fir.ref<i32>
- ! CHECK: %[[I_STEPCAST:.*]] = fir.convert %[[C1]] : (index) -> i32
- ! CHECK: %[[I_IVLOAD:.*]] = fir.load %[[I_REF]] : !fir.ref<i32>
- ! CHECK: %[[I_IVINC:.*]] = arith.addi %[[I_IVLOAD]], %[[I_STEPCAST]] overflow<nsw> : i32
+ ! CHECK: %{{.*}} = fir.do_loop %{{.*}} = {{.*}} to {{.*}} step {{.*}} iter_args(%[[I_IV:.*]] = {{.*}}) -> (i32) {
+ ! CHECK: fir.store %[[I_IV]] to %[[I]]#0 : !fir.ref<i32>
+ ! CHECK: %[[C2:.*]] = arith.constant 2 : i32
+ ! CHECK: %[[J2VAL:.*]] = fir.load %[[J]]#0 : !fir.ref<i32>
+ ! CHECK: %[[JINC:.*]] = arith.muli %[[C2]], %[[J2VAL]] : i32
+ ! CHECK: hlfir.assign %[[JINC]] to %[[J]]#0 : i32, !fir.ref<i32>
+ ! CHECK: %[[I_IVLOAD:.*]] = fir.load %[[I]]#0 : !fir.ref<i32>
+ ! CHECK: %[[I_IVINC:.*]] = arith.addi %[[I_IVLOAD]], {{.*}} overflow<nsw> : i32
! CHECK: fir.result %[[I_IVINC]] : i32
do i=8,13
j=j*2
- ! CHECK: fir.store %[[RESULT]] to %[[I_REF]] : !fir.ref<i32>
+ ! CHECK: fir.store %{{.*}} to %[[I]]#0 : !fir.ref<i32>
end do
- ! CHECK: br ^[[HDR1]]
+ ! CHECK: cf.br ^[[HDR1]]
end do
! CHECK: ^[[EXIT1]]: // pred: ^[[HDR1]]
- ! CHECK: %[[IPRINT:.*]] = fir.load %[[I_REF]] : !fir.ref<i32>
- ! CHECK: fir.call @_FortranAioOutputInteger32(%{{.*}}, %[[IPRINT]]) {{.*}}: (!fir.ref<i8>, i32) -> i1
- ! CHECK: %[[JPRINT:.*]] = fir.load %[[J_REF]] : !fir.ref<i32>
- ! CHECK: fir.call @_FortranAioOutputInteger32(%{{.*}}, %[[JPRINT]]) {{.*}}: (!fir.ref<i8>, i32) -> i1
+ ! CHECK: %[[IPRINT:.*]] = fir.load %[[I]]#0 : !fir.ref<i32>
+ ! CHECK: fir.call @_FortranAioOutputInteger32(%{{.*}}, %[[IPRINT]])
+ ! CHECK: %[[JPRINT:.*]] = fir.load %[[J]]#0 : !fir.ref<i32>
+ ! CHECK: fir.call @_FortranAioOutputInteger32(%{{.*}}, %[[JPRINT]])
print *, i, j
end subroutine
diff --git a/flang/test/Lower/while_loop.f90 b/flang/test/Lower/while_loop.f90
index 8c03ff5ba9b18..8114394a39919 100644
--- a/flang/test/Lower/while_loop.f90
+++ b/flang/test/Lower/while_loop.f90
@@ -1,91 +1,93 @@
-! RUN: bbc -emit-fir -hlfir=false -o - %s | FileCheck %s
-! RUN: %flang_fc1 -emit-fir -flang-deprecated-no-hlfir -o - %s | FileCheck %s
+! RUN: %flang_fc1 -emit-hlfir -o - %s | FileCheck %s
! Test a simple while loop.
! CHECK-LABEL: simple_loop
subroutine simple_loop
- ! CHECK: %[[I_REF:.*]] = fir.alloca i32 {bindc_name = "i", uniq_name = "_QFsimple_loopEi"}
+ ! CHECK: %[[I_ADDR:.*]] = fir.alloca i32 {bindc_name = "i", uniq_name = "_QFsimple_loopEi"}
+ ! CHECK: %[[I:.*]]:2 = hlfir.declare %[[I_ADDR]]
integer :: i
! CHECK: %[[C5:.*]] = arith.constant 5 : i32
- ! CHECK: fir.store %[[C5]] to %[[I_REF]]
+ ! CHECK: hlfir.assign %[[C5]] to %[[I]]#0
i = 5
- ! CHECK: br ^[[BB1:.*]]
+ ! CHECK: cf.br ^[[BB1:.*]]
! CHECK: ^[[BB1]]: // 2 preds: ^{{.*}}, ^[[BB2:.*]]
- ! CHECK-DAG: %[[I:.*]] = fir.load %[[I_REF]] : !fir.ref<i32>
- ! CHECK-DAG: %[[C1:.*]] = arith.constant 1 : i32
- ! CHECK: %[[COND:.*]] = arith.cmpi sgt, %[[I]], %[[C1]] : i32
- ! CHECK: cond_br %[[COND]], ^[[BB2]], ^[[BB3:.*]]
+ ! CHECK: %[[IVAL:.*]] = fir.load %[[I]]#0 : !fir.ref<i32>
+ ! CHECK: %[[C1:.*]] = arith.constant 1 : i32
+ ! CHECK: %[[COND:.*]] = arith.cmpi sgt, %[[IVAL]], %[[C1]] : i32
+ ! CHECK: cf.cond_br %[[COND]], ^[[BB2]], ^[[BB3:.*]]
! CHECK: ^[[BB2]]: // pred: ^[[BB1]]
- ! CHECK-DAG: %[[I2:.*]] = fir.load %[[I_REF]] : !fir.ref<i32>
- ! CHECK-DAG: %[[C2:.*]] = arith.constant 2 : i32
- ! CHECK: %[[INC:.*]] = arith.subi %[[I2]], %[[C2]] : i32
- ! CHECK: fir.store %[[INC]] to %[[I_REF]] : !fir.ref<i32>
- ! CHECK: br ^[[BB1]]
+ ! CHECK: %[[IVAL2:.*]] = fir.load %[[I]]#0 : !fir.ref<i32>
+ ! CHECK: %[[C2:.*]] = arith.constant 2 : i32
+ ! CHECK: %[[INC:.*]] = arith.subi %[[IVAL2]], %[[C2]] : i32
+ ! CHECK: hlfir.assign %[[INC]] to %[[I]]#0 : i32, !fir.ref<i32>
+ ! CHECK: cf.br ^[[BB1]]
do while (i .gt. 1)
i = i - 2
end do
! CHECK: ^[[BB3]]: // pred: ^[[BB1]]
- ! CHECK: %[[I3:.*]] = fir.load %[[I_REF]] : !fir.ref<i32>
- ! CHECK: fir.call @_FortranAioOutputInteger32(%{{.*}}, %[[I3]]) {{.*}}: (!fir.ref<i8>, i32) -> i1
+ ! CHECK: %[[IVAL3:.*]] = fir.load %[[I]]#0 : !fir.ref<i32>
+ ! CHECK: fir.call @_FortranAioOutputInteger32(%{{.*}}, %[[IVAL3]])
print *, i
end subroutine
! Test 2 nested while loops.
! CHECK-LABEL: while_inside_while_loop
subroutine while_inside_while_loop
- ! CHECK-DAG: %[[I_REF:.*]] = fir.alloca i32 {bindc_name = "i", uniq_name = "_QFwhile_inside_while_loopEi"}
- ! CHECK-DAG: %[[J_REF:.*]] = fir.alloca i32 {bindc_name = "j", uniq_name = "_QFwhile_inside_while_loopEj"}
+ ! CHECK-DAG: %[[I_ADDR:.*]] = fir.alloca i32 {bindc_name = "i", uniq_name = "_QFwhile_inside_while_loopEi"}
+ ! CHECK-DAG: %[[I:.*]]:2 = hlfir.declare %[[I_ADDR]]
+ ! CHECK-DAG: %[[J_ADDR:.*]] = fir.alloca i32 {bindc_name = "j", uniq_name = "_QFwhile_inside_while_loopEj"}
+ ! CHECK-DAG: %[[J:.*]]:2 = hlfir.declare %[[J_ADDR]]
integer :: i, j
! CHECK: %[[C13:.*]] = arith.constant 13 : i32
- ! CHECK: fir.store %[[C13]] to %[[I_REF]]
+ ! CHECK: hlfir.assign %[[C13]] to %[[I]]#0
i = 13
- ! CHECK: br ^[[HDR1:.*]]
+ ! CHECK: cf.br ^[[HDR1:.*]]
! CHECK: ^[[HDR1]]: // 2 preds: ^{{.*}}, ^[[EXIT2:.*]]
- ! CHECK-DAG: %[[I:.*]] = fir.load %[[I_REF]] : !fir.ref<i32>
- ! CHECK-DAG: %[[C8:.*]] = arith.constant 8 : i32
- ! CHECK: %[[COND:.*]] = arith.cmpi sgt, %[[I]], %[[C8]] : i32
- ! CHECK: cond_br %[[COND]], ^[[BODY1:.*]], ^[[EXIT1:.*]]
+ ! CHECK: %[[IVAL:.*]] = fir.load %[[I]]#0 : !fir.ref<i32>
+ ! CHECK: %[[C8:.*]] = arith.constant 8 : i32
+ ! CHECK: %[[COND:.*]] = arith.cmpi sgt, %[[IVAL]], %[[C8]] : i32
+ ! CHECK: cf.cond_br %[[COND]], ^[[BODY1:.*]], ^[[EXIT1:.*]]
do while (i .gt. 8)
! CHECK: ^[[BODY1]]: // pred: ^[[HDR1]]
- ! CHECK-DAG: %[[I2:.*]] = fir.load %[[I_REF]] : !fir.ref<i32>
- ! CHECK-DAG: %[[C5:.*]] = arith.constant 5 : i32
- ! CHECK: %[[INC:.*]] = arith.subi %[[I2]], %[[C5]] : i32
- ! CHECK: fir.store %[[INC]] to %[[I_REF]] : !fir.ref<i32>
+ ! CHECK: %[[IVAL2:.*]] = fir.load %[[I]]#0 : !fir.ref<i32>
+ ! CHECK: %[[C5:.*]] = arith.constant 5 : i32
+ ! CHECK: %[[INC:.*]] = arith.subi %[[IVAL2]], %[[C5]] : i32
+ ! CHECK: hlfir.assign %[[INC]] to %[[I]]#0 : i32, !fir.ref<i32>
i = i - 5
! CHECK: %[[C3:.*]] = arith.constant 3 : i32
- ! CHECK: fir.store %[[C3]] to %[[J_REF]]
+ ! CHECK: hlfir.assign %[[C3]] to %[[J]]#0
j = 3
- ! CHECK: br ^[[HDR2:.*]]
+ ! CHECK: cf.br ^[[HDR2:.*]]
! CHECK: ^[[HDR2]]: // 2 preds: ^[[BODY1]], ^[[BODY2:.*]]
- ! CHECK-DAG: %[[J:.*]] = fir.load %[[J_REF]] : !fir.ref<i32>
- ! CHECK-DAG: %[[I3:.*]] = fir.load %[[I_REF]] : !fir.ref<i32>
- ! CHECK: %[[COND2:.*]] = arith.cmpi slt, %[[J]], %[[I3]] : i32
- ! CHECK: cond_br %[[COND2]], ^[[BODY2]], ^[[EXIT2]]
+ ! CHECK: %[[JVAL:.*]] = fir.load %[[J]]#0 : !fir.ref<i32>
+ ! CHECK: %[[IVAL3:.*]] = fir.load %[[I]]#0 : !fir.ref<i32>
+ ! CHECK: %[[COND2:.*]] = arith.cmpi slt, %[[JVAL]], %[[IVAL3]] : i32
+ ! CHECK: cf.cond_br %[[COND2]], ^[[BODY2]], ^[[EXIT2:.*]]
do while (j .lt. i)
! CHECK: ^[[BODY2]]: // pred: ^[[HDR2]]
- ! CHECK-DAG: %[[J2:.*]] = fir.load %[[J_REF]] : !fir.ref<i32>
- ! CHECK-DAG: %[[C2:.*]] = arith.constant 2 : i32
- ! CHECK: %[[INC2:.*]] = arith.muli %[[C2]], %[[J2]] : i32
- ! CHECK: fir.store %[[INC2]] to %[[J_REF]] : !fir.ref<i32>
+ ! CHECK: %[[C2:.*]] = arith.constant 2 : i32
+ ! CHECK: %[[JVAL2:.*]] = fir.load %[[J]]#0 : !fir.ref<i32>
+ ! CHECK: %[[INC2:.*]] = arith.muli %[[C2]], %[[JVAL2]] : i32
+ ! CHECK: hlfir.assign %[[INC2]] to %[[J]]#0 : i32, !fir.ref<i32>
j = j * 2
- ! CHECK: br ^[[HDR2]]
+ ! CHECK: cf.br ^[[HDR2]]
end do
! CHECK: ^[[EXIT2]]: // pred: ^[[HDR2]]
- ! CHECK: br ^[[HDR1]]
+ ! CHECK: cf.br ^[[HDR1]]
end do
! CHECK: ^[[EXIT1]]: // pred: ^[[HDR1]]
- ! CHECK: %[[IPRINT:.*]] = fir.load %[[I_REF]] : !fir.ref<i32>
- ! CHECK: fir.call @_FortranAioOutputInteger32(%{{.*}}, %[[IPRINT]]) {{.*}}: (!fir.ref<i8>, i32) -> i1
- ! CHECK: %[[JPRINT:.*]] = fir.load %[[J_REF]] : !fir.ref<i32>
- ! CHECK: fir.call @_FortranAioOutputInteger32(%{{.*}}, %[[JPRINT]]) {{.*}}: (!fir.ref<i8>, i32) -> i1
+ ! CHECK: %[[IPRINT:.*]] = fir.load %[[I]]#0 : !fir.ref<i32>
+ ! CHECK: fir.call @_FortranAioOutputInteger32(%{{.*}}, %[[IPRINT]])
+ ! CHECK: %[[JPRINT:.*]] = fir.load %[[J]]#0 : !fir.ref<i32>
+ ! CHECK: fir.call @_FortranAioOutputInteger32(%{{.*}}, %[[JPRINT]])
print *, i, j
end subroutine
More information about the flang-commits
mailing list