[flang-commits] [flang] 6e04d71 - [flang][NFC] Converted five tests from old lowering to new lowering (part 5) (#175008)
via flang-commits
flang-commits at lists.llvm.org
Tue Jan 13 03:36:50 PST 2026
Author: Eugene Epshteyn
Date: 2026-01-13T06:36:46-05:00
New Revision: 6e04d71ac91c36b927e01d043af302dfc35a68a2
URL: https://github.com/llvm/llvm-project/commit/6e04d71ac91c36b927e01d043af302dfc35a68a2
DIFF: https://github.com/llvm/llvm-project/commit/6e04d71ac91c36b927e01d043af302dfc35a68a2.diff
LOG: [flang][NFC] Converted five tests from old lowering to new lowering (part 5) (#175008)
Tests converted in Lower: array-elemental-subroutines.f90,
array-expression-slice-1.f90, array-expression-slice-2.f90,
array-expression-subscript.f90, array-substring.f90
Added:
Modified:
flang/test/Lower/array-elemental-subroutines.f90
flang/test/Lower/array-expression-slice-1.f90
flang/test/Lower/array-expression-slice-2.f90
flang/test/Lower/array-expression-subscript.f90
flang/test/Lower/array-substring.f90
Removed:
################################################################################
diff --git a/flang/test/Lower/array-elemental-subroutines.f90 b/flang/test/Lower/array-elemental-subroutines.f90
index b68d78fc3a800..e8166bb3271df 100644
--- a/flang/test/Lower/array-elemental-subroutines.f90
+++ b/flang/test/Lower/array-elemental-subroutines.f90
@@ -1,34 +1,20 @@
! Test lowering of elemental subroutine calls with array arguments
-! RUN: bbc -o - -emit-fir -hlfir=false %s | FileCheck %s
+! RUN: bbc -emit-hlfir %s -o - | FileCheck %s
! CHECK-LABEL: func @_QPtest_elem_sub(
! CHECK-SAME: %[[VAL_0:.*]]: !fir.box<!fir.array<?xf32>>{{.*}}, %[[VAL_1:.*]]: !fir.box<!fir.array<?x!fir.char<1,?>>>{{.*}}, %[[VAL_2:.*]]: !fir.ref<i32>{{.*}}, %[[VAL_3:.*]]: !fir.ref<complex<f32>>{{.*}}) {
-! CHECK: %[[VAL_5:.*]] = arith.constant 0 : index
-! CHECK: %[[VAL_6:.*]]:3 = fir.box_dims %[[VAL_0]], %[[VAL_5]] : (!fir.box<!fir.array<?xf32>>, index) -> (index, index, index)
-! CHECK: %[[VAL_7:.*]] = arith.constant 10 : i64
-! CHECK: %[[VAL_8:.*]] = fir.convert %[[VAL_7]] : (i64) -> index
-! CHECK: %[[VAL_9:.*]] = arith.constant -1 : i64
-! CHECK: %[[VAL_10:.*]] = fir.convert %[[VAL_9]] : (i64) -> index
-! CHECK: %[[VAL_11:.*]] = arith.constant 1 : i64
-! CHECK: %[[VAL_12:.*]] = fir.convert %[[VAL_11]] : (i64) -> index
-! CHECK: %[[VAL_13:.*]] = fir.slice %[[VAL_8]], %[[VAL_12]], %[[VAL_10]] : (index, index, index) -> !fir.slice<1>
-! CHECK: %[[VAL_14:.*]] = fir.load %[[VAL_3]] : !fir.ref<complex<f32>>
-! CHECK: %[[VAL_15:.*]] = arith.constant 1 : index
-! CHECK: %[[VAL_16:.*]] = arith.constant 0 : index
-! CHECK: %[[VAL_17:.*]] = arith.subi %[[VAL_6]]#1, %[[VAL_15]] : index
-! CHECK: fir.do_loop %[[VAL_18:.*]] = %[[VAL_16]] to %[[VAL_17]] step %[[VAL_15]] {
-! CHECK: %[[VAL_19:.*]] = arith.constant 1 : index
-! CHECK: %[[VAL_20:.*]] = arith.addi %[[VAL_18]], %[[VAL_19]] : index
-! CHECK: %[[VAL_21:.*]] = fir.array_coor %[[VAL_0]] %[[VAL_20]] : (!fir.box<!fir.array<?xf32>>, index) -> !fir.ref<f32>
-! CHECK: %[[VAL_22:.*]] = arith.constant 1 : index
-! CHECK: %[[VAL_23:.*]] = arith.addi %[[VAL_18]], %[[VAL_22]] : index
-! CHECK: %[[VAL_24:.*]] = fir.array_coor %[[VAL_1]] {{\[}}%[[VAL_13]]] %[[VAL_23]] : (!fir.box<!fir.array<?x!fir.char<1,?>>>, !fir.slice<1>, index) -> !fir.ref<!fir.char<1,?>>
-! CHECK: %[[VAL_25:.*]] = fir.box_elesize %[[VAL_1]] : (!fir.box<!fir.array<?x!fir.char<1,?>>>) -> index
-! CHECK: %[[VAL_26:.*]] = fir.emboxchar %[[VAL_24]], %[[VAL_25]] : (!fir.ref<!fir.char<1,?>>, index) -> !fir.boxchar<1>
-! CHECK: fir.call @_QPfoo(%[[VAL_21]], %[[VAL_26]], %[[VAL_2]], %[[VAL_14]]) {{.*}}: (!fir.ref<f32>, !fir.boxchar<1>, !fir.ref<i32>, complex<f32>) -> ()
+! CHECK: %[[c_decl:.*]]:2 = hlfir.declare %[[VAL_1]]
+! CHECK: %[[i_decl:.*]]:2 = hlfir.declare %[[VAL_2]]
+! CHECK: %[[x_decl:.*]]:2 = hlfir.declare %[[VAL_0]]
+! CHECK: %[[z_decl:.*]]:2 = hlfir.declare %[[VAL_3]]
+! CHECK: %[[len:.*]] = fir.box_elesize %[[c_decl]]#1
+! CHECK: %[[slice:.*]] = hlfir.designate %[[c_decl]]#0 ({{.*}}) shape {{.*}} typeparams %[[len]]
+! CHECK: %[[z_val:.*]] = fir.load %[[z_decl]]#0
+! CHECK: fir.do_loop %[[arg:.*]] = {{.*}} {
+! CHECK: %[[x_elem:.*]] = hlfir.designate %[[x_decl]]#0 (%[[arg]])
+! CHECK: %[[c_elem:.*]] = hlfir.designate %[[slice]] (%[[arg]]) typeparams %[[len]]
+! CHECK: fir.call @_QPfoo(%[[x_elem]], %[[c_elem]], %[[i_decl]]#0, %[[z_val]])
! CHECK: }
-! CHECK: return
-! CHECK: }
subroutine test_elem_sub(x, c, i, z)
real :: x(:)
@@ -58,5 +44,5 @@ elemental subroutine bar(i, j)
end subroutine
end interface
call bar(i, j)
- ! CHECK: fir.call @_QPbar(%[[VAL_0]], %[[VAL_1]]) {{.*}}: (!fir.ref<i32>, !fir.ref<i32>) -> ()
+ ! CHECK: fir.call @_QPbar(%{{.*}}, %{{.*}})
end subroutine
diff --git a/flang/test/Lower/array-expression-slice-1.f90 b/flang/test/Lower/array-expression-slice-1.f90
index 73943137cb18d..a78b12e553ffa 100644
--- a/flang/test/Lower/array-expression-slice-1.f90
+++ b/flang/test/Lower/array-expression-slice-1.f90
@@ -1,345 +1,40 @@
-! RUN: bbc -hlfir=false -fwrapv -o - --outline-intrinsics %s | FileCheck %s
+! RUN: bbc -emit-hlfir -fwrapv -o - --outline-intrinsics %s | FileCheck %s
! CHECK-LABEL: func @_QQmain() attributes {fir.bindc_name = "P"} {
-! CHECK-DAG: %[[VAL_0:.*]] = arith.constant 10 : index
-! CHECK-DAG: %[[VAL_4:.*]] = arith.constant 2 : index
-! CHECK-DAG: %[[VAL_5:.*]] = arith.constant 1 : index
-! CHECK-DAG: %[[VAL_6:.*]] = arith.constant 0 : index
-! CHECK-DAG: %[[VAL_8:.*]] = arith.constant 8 : i64
-! CHECK-DAG: %[[VAL_11:.*]] = arith.constant 3 : index
-! CHECK-DAG: %[[VAL_13:.*]] = arith.constant 2 : i64
-! CHECK-DAG: %[[VAL_14:.*]] = arith.constant 7 : i64
-! CHECK-DAG: %[[VAL_16:.*]] = arith.constant 4 : i64
-! CHECK-DAG: %[[VAL_18:.*]] = arith.constant 6 : i32
-! CHECK-DAG: %[[VAL_19:.*]] = arith.constant 0 : i64
-! CHECK-DAG: %[[VAL_20:.*]] = arith.constant 1 : i64
-! CHECK-DAG: %[[VAL_21:.*]] = arith.constant 3 : i64
-! CHECK-DAG: %[[VAL_22:.*]] = arith.constant 4 : index
-! CHECK-DAG: %[[VAL_23:.*]] = arith.constant 1 : i32
-! CHECK-DAG: %[[VAL_24:.*]] = arith.constant 0 : i32
-! CHECK-DAG: %[[VAL_25:.*]] = fir.address_of(@_QFEa1) : !fir.ref<!fir.array<10x10xf32>>
-! CHECK-DAG: %[[VAL_26:.*]] = fir.alloca !fir.array<3xf32> {bindc_name = "a2", uniq_name = "_QFEa2"}
-! CHECK-DAG: %[[VAL_27:.*]] = fir.address_of(@_QFEa3) : !fir.ref<!fir.array<10xf32>>
-! CHECK-DAG: %[[VAL_28:.*]] = fir.alloca i32 {bindc_name = "i", uniq_name = "_QFEi"}
-! CHECK-DAG: %[[VAL_29:.*]] = fir.alloca !fir.array<3xi32> {bindc_name = "iv", uniq_name = "_QFEiv"}
-! CHECK-DAG: %[[VAL_30:.*]] = fir.alloca i32 {bindc_name = "j", uniq_name = "_QFEj"}
-! CHECK-DAG: %[[VAL_31:.*]] = fir.alloca i32 {bindc_name = "k", uniq_name = "_QFEk"}
-! CHECK: fir.store %[[VAL_24]] to %[[VAL_31]] : !fir.ref<i32>
-! CHECK: %[[STEP:.*]] = fir.convert %[[VAL_5]] : (index) -> i32
-! CHECK: br ^bb1(%[[STEP]], %[[VAL_0]] : i32, index)
-! CHECK: ^bb1(%[[VAL_32:.*]]: i32, %[[VAL_33:.*]]: index):
-! CHECK: %[[VAL_34:.*]] = arith.cmpi sgt, %[[VAL_33]], %[[VAL_6]] : index
-! CHECK: cond_br %[[VAL_34]], ^bb2, ^bb6
-! CHECK: ^bb2:
-! CHECK: fir.store %[[VAL_32]] to %[[VAL_30]] : !fir.ref<i32>
-! CHECK: br ^bb3(%[[STEP]], %[[VAL_0]] : i32, index)
-! CHECK: ^bb3(%[[VAL_36:.*]]: i32, %[[VAL_37:.*]]: index):
-! CHECK: %[[VAL_38:.*]] = arith.cmpi sgt, %[[VAL_37]], %[[VAL_6]] : index
-! CHECK: cond_br %[[VAL_38]], ^bb4, ^bb5
-! CHECK: ^bb4:
-! CHECK: fir.store %[[VAL_36]] to %[[VAL_28]] : !fir.ref<i32>
-! CHECK: %[[VAL_40:.*]] = fir.load %[[VAL_31]] : !fir.ref<i32>
-! CHECK: %[[VAL_41:.*]] = arith.addi %[[VAL_40]], %[[VAL_23]] : i32
-! CHECK: fir.store %[[VAL_41]] to %[[VAL_31]] : !fir.ref<i32>
-! CHECK: %[[VAL_42:.*]] = fir.load %[[VAL_31]] : !fir.ref<i32>
-! CHECK: %[[VAL_43:.*]] = fir.convert %[[VAL_42]] : (i32) -> f32
-! CHECK: %[[VAL_44:.*]] = fir.call @fir.cos.contract.f32.f32(%[[VAL_43]]) {{.*}}: (f32) -> f32
-! CHECK: %[[VAL_45:.*]] = fir.load %[[VAL_28]] : !fir.ref<i32>
-! CHECK: %[[VAL_46:.*]] = fir.convert %[[VAL_45]] : (i32) -> i64
-! CHECK: %[[VAL_47:.*]] = arith.subi %[[VAL_46]], %[[VAL_20]] : i64
-! CHECK: %[[VAL_48:.*]] = fir.load %[[VAL_30]] : !fir.ref<i32>
-! CHECK: %[[VAL_49:.*]] = fir.convert %[[VAL_48]] : (i32) -> i64
-! CHECK: %[[VAL_50:.*]] = arith.subi %[[VAL_49]], %[[VAL_20]] : i64
-! CHECK: %[[VAL_51:.*]] = fir.coordinate_of %[[VAL_25]], %[[VAL_47]], %[[VAL_50]] : (!fir.ref<!fir.array<10x10xf32>>, i64, i64) -> !fir.ref<f32>
-! CHECK: fir.store %[[VAL_44]] to %[[VAL_51]] : !fir.ref<f32>
-! CHECK: %[[LOADI:.*]] = fir.load %[[VAL_28]] : !fir.ref<i32>
-! CHECK: %[[VAL_52:.*]] = arith.addi %[[LOADI]], %[[STEP]] : i32
-! CHECK: %[[VAL_53:.*]] = arith.subi %[[VAL_37]], %[[VAL_5]] : index
-! CHECK: br ^bb3(%[[VAL_52]], %[[VAL_53]] : i32, index)
-! CHECK: ^bb5:
-! CHECK: fir.store %[[VAL_36]] to %[[VAL_28]] : !fir.ref<i32>
-! CHECK: %[[VAL_55:.*]] = fir.load %[[VAL_31]] : !fir.ref<i32>
-! CHECK: %[[VAL_56:.*]] = fir.convert %[[VAL_55]] : (i32) -> f32
-! CHECK: %[[VAL_57:.*]] = fir.call @fir.sin.contract.f32.f32(%[[VAL_56]]) {{.*}}: (f32) -> f32
-! CHECK: %[[VAL_58:.*]] = fir.load %[[VAL_30]] : !fir.ref<i32>
-! CHECK: %[[VAL_59:.*]] = fir.convert %[[VAL_58]] : (i32) -> i64
-! CHECK: %[[VAL_60:.*]] = arith.subi %[[VAL_59]], %[[VAL_20]] : i64
-! CHECK: %[[VAL_61:.*]] = fir.coordinate_of %[[VAL_27]], %[[VAL_60]] : (!fir.ref<!fir.array<10xf32>>, i64) -> !fir.ref<f32>
-! CHECK: fir.store %[[VAL_57]] to %[[VAL_61]] : !fir.ref<f32>
-! CHECK: %[[LOADJ:.*]] = fir.load %[[VAL_30]] : !fir.ref<i32>
-! CHECK: %[[VAL_62:.*]] = arith.addi %[[LOADJ]], %[[STEP]] : i32
-! CHECK: %[[VAL_63:.*]] = arith.subi %[[VAL_33]], %[[VAL_5]] : index
-! CHECK: br ^bb1(%[[VAL_62]], %[[VAL_63]] : i32, index)
-! CHECK: ^bb6:
-! CHECK: fir.store %[[VAL_32]] to %[[VAL_30]] : !fir.ref<i32>
-! CHECK: %[[VAL_65:.*]] = fir.shape %[[VAL_11]] : (index) -> !fir.shape<1>
-! CHECK: %[[VAL_66:.*]] = fir.undefined index
-! CHECK: %[[VAL_67:.*]] = fir.shape %[[VAL_0]], %[[VAL_0]] : (index, index) -> !fir.shape<2>
-! CHECK: %[[VAL_68:.*]] = fir.slice %[[VAL_16]], %[[VAL_66]], %[[VAL_66]], %[[VAL_4]], %[[VAL_0]], %[[VAL_11]] : (i64, index, index, index, index, index) -> !fir.slice<2>
-! CHECK: br ^bb7(%[[VAL_6]], %[[VAL_11]] : index, index)
-! CHECK: ^bb7(%[[VAL_69:.*]]: index, %[[VAL_70:.*]]: index):
-! CHECK: %[[VAL_71:.*]] = arith.cmpi sgt, %[[VAL_70]], %[[VAL_6]] : index
-! CHECK: cond_br %[[VAL_71]], ^bb8, ^bb9
-! CHECK: ^bb8:
-! CHECK: %[[VAL_72:.*]] = arith.addi %[[VAL_69]], %[[VAL_5]] : index
-! CHECK: %[[VAL_73:.*]] = fir.array_coor %[[VAL_25]](%[[VAL_67]]) {{\[}}%[[VAL_68]]] %[[VAL_22]], %[[VAL_72]] : (!fir.ref<!fir.array<10x10xf32>>, !fir.shape<2>, !fir.slice<2>, index, index) -> !fir.ref<f32>
-! CHECK: %[[VAL_74:.*]] = fir.load %[[VAL_73]] : !fir.ref<f32>
-! CHECK: %[[VAL_75:.*]] = fir.array_coor %[[VAL_26]](%[[VAL_65]]) %[[VAL_72]] : (!fir.ref<!fir.array<3xf32>>, !fir.shape<1>, index) -> !fir.ref<f32>
-! CHECK: fir.store %[[VAL_74]] to %[[VAL_75]] : !fir.ref<f32>
-! CHECK: %[[VAL_76:.*]] = arith.subi %[[VAL_70]], %[[VAL_5]] : index
-! CHECK: br ^bb7(%[[VAL_72]], %[[VAL_76]] : index, index)
-! CHECK: ^bb9:
-! CHECK: %[[VAL_77:.*]] = fir.coordinate_of %[[VAL_25]], %[[VAL_21]], %[[VAL_20]] : (!fir.ref<!fir.array<10x10xf32>>, i64, i64) -> !fir.ref<f32>
-! CHECK: %[[VAL_78:.*]] = fir.load %[[VAL_77]] : !fir.ref<f32>
-! CHECK: %[[VAL_79:.*]] = fir.coordinate_of %[[VAL_26]], %[[VAL_19]] : (!fir.ref<!fir.array<3xf32>>, i64) -> !fir.ref<f32>
-! CHECK: %[[VAL_80:.*]] = fir.load %[[VAL_79]] : !fir.ref<f32>
-! CHECK: %[[VAL_81:.*]] = arith.cmpf une, %[[VAL_78]], %[[VAL_80]] {{.*}} : f32
-! CHECK: cond_br %[[VAL_81]], ^bb10, ^bb11
-! CHECK: ^bb10:
-! CHECK: %[[VAL_82:.*]] = fir.address_of(@_QQclX{{.*}}) : !fir.ref<!fir.char<1,
-! CHECK: %[[VAL_83:.*]] = fir.convert %[[VAL_82]] : (!fir.ref<!fir.char<1,{{.*}}>>) -> !fir.ref<i8>
-! CHECK: %[[VAL_84:.*]] = fir.call @_FortranAioBeginExternalListOutput(%[[VAL_18]], %[[VAL_83]], %{{.*}}) {{.*}}: (i32, !fir.ref<i8>, i32) -> !fir.ref<i8>
-! CHECK: %[[VAL_85:.*]] = fir.address_of(@_QQclX6D69736D617463682031) : !fir.ref<!fir.char<1,10>>
-! CHECK: %[[VAL_86:.*]] = fir.convert %[[VAL_85]] : (!fir.ref<!fir.char<1,10>>) -> !fir.ref<i8>
-! CHECK: %[[VAL_87:.*]] = fir.convert %[[VAL_0]] : (index) -> i64
-! CHECK: %[[VAL_88:.*]] = fir.call @_FortranAioOutputAscii(%[[VAL_84]], %[[VAL_86]], %[[VAL_87]]) {{.*}}: (!fir.ref<i8>, !fir.ref<i8>, i64) -> i1
-! CHECK: %[[VAL_89:.*]] = fir.load %[[VAL_79]] : !fir.ref<f32>
-! CHECK: %[[VAL_90:.*]] = fir.call @_FortranAioOutputReal32(%[[VAL_84]], %[[VAL_89]]) {{.*}}: (!fir.ref<i8>, f32) -> i1
-! CHECK: %[[VAL_91:.*]] = fir.load %[[VAL_77]] : !fir.ref<f32>
-! CHECK: %[[VAL_92:.*]] = fir.call @_FortranAioOutputReal32(%[[VAL_84]], %[[VAL_91]]) {{.*}}: (!fir.ref<i8>, f32) -> i1
-! CHECK: %[[VAL_93:.*]] = fir.call @_FortranAioEndIoStatement(%[[VAL_84]]) {{.*}}: (!fir.ref<i8>) -> i32
-! CHECK: br ^bb11
-! CHECK: ^bb11:
-! CHECK: %[[VAL_94:.*]] = fir.coordinate_of %[[VAL_25]], %[[VAL_21]], %[[VAL_16]] : (!fir.ref<!fir.array<10x10xf32>>, i64, i64) -> !fir.ref<f32>
-! CHECK: %[[VAL_95:.*]] = fir.load %[[VAL_94]] : !fir.ref<f32>
-! CHECK: %[[VAL_96:.*]] = fir.coordinate_of %[[VAL_26]], %[[VAL_20]] : (!fir.ref<!fir.array<3xf32>>, i64) -> !fir.ref<f32>
-! CHECK: %[[VAL_97:.*]] = fir.load %[[VAL_96]] : !fir.ref<f32>
-! CHECK: %[[VAL_98:.*]] = arith.cmpf une, %[[VAL_95]], %[[VAL_97]] {{.*}} : f32
-! CHECK: cond_br %[[VAL_98]], ^bb12, ^bb13
-! CHECK: ^bb12:
-! CHECK: %[[VAL_99:.*]] = fir.address_of(@_QQclX{{.*}}) : !fir.ref<!fir.char<1,
-! CHECK: %[[VAL_100:.*]] = fir.convert %[[VAL_99]] : (!fir.ref<!fir.char<1,{{.*}}>>) -> !fir.ref<i8>
-! CHECK: %[[VAL_101:.*]] = fir.call @_FortranAioBeginExternalListOutput(%[[VAL_18]], %[[VAL_100]], %{{.*}}) {{.*}}: (i32, !fir.ref<i8>, i32) -> !fir.ref<i8>
-! CHECK: %[[VAL_102:.*]] = fir.address_of(@_QQclX6D69736D617463682032) : !fir.ref<!fir.char<1,10>>
-! CHECK: %[[VAL_103:.*]] = fir.convert %[[VAL_102]] : (!fir.ref<!fir.char<1,10>>) -> !fir.ref<i8>
-! CHECK: %[[VAL_104:.*]] = fir.convert %[[VAL_0]] : (index) -> i64
-! CHECK: %[[VAL_105:.*]] = fir.call @_FortranAioOutputAscii(%[[VAL_101]], %[[VAL_103]], %[[VAL_104]]) {{.*}}: (!fir.ref<i8>, !fir.ref<i8>, i64) -> i1
-! CHECK: %[[VAL_106:.*]] = fir.load %[[VAL_96]] : !fir.ref<f32>
-! CHECK: %[[VAL_107:.*]] = fir.call @_FortranAioOutputReal32(%[[VAL_101]], %[[VAL_106]]) {{.*}}: (!fir.ref<i8>, f32) -> i1
-! CHECK: %[[VAL_108:.*]] = fir.load %[[VAL_94]] : !fir.ref<f32>
-! CHECK: %[[VAL_109:.*]] = fir.call @_FortranAioOutputReal32(%[[VAL_101]], %[[VAL_108]]) {{.*}}: (!fir.ref<i8>, f32) -> i1
-! CHECK: %[[VAL_110:.*]] = fir.call @_FortranAioEndIoStatement(%[[VAL_101]]) {{.*}}: (!fir.ref<i8>) -> i32
-! CHECK: br ^bb13
-! CHECK: ^bb13:
-! CHECK: %[[VAL_111:.*]] = fir.coordinate_of %[[VAL_25]], %[[VAL_21]], %[[VAL_14]] : (!fir.ref<!fir.array<10x10xf32>>, i64, i64) -> !fir.ref<f32>
-! CHECK: %[[VAL_112:.*]] = fir.load %[[VAL_111]] : !fir.ref<f32>
-! CHECK: %[[VAL_113:.*]] = fir.coordinate_of %[[VAL_26]], %[[VAL_13]] : (!fir.ref<!fir.array<3xf32>>, i64) -> !fir.ref<f32>
-! CHECK: %[[VAL_114:.*]] = fir.load %[[VAL_113]] : !fir.ref<f32>
-! CHECK: %[[VAL_115:.*]] = arith.cmpf une, %[[VAL_112]], %[[VAL_114]] {{.*}} : f32
-! CHECK: cond_br %[[VAL_115]], ^bb14, ^bb15
-! CHECK: ^bb14:
-! CHECK: %[[VAL_116:.*]] = fir.address_of(@_QQclX{{.*}} : !fir.ref<!fir.char<1,
-! CHECK: %[[VAL_117:.*]] = fir.convert %[[VAL_116]] : (!fir.ref<!fir.char<1,{{.*}}>>) -> !fir.ref<i8>
-! CHECK: %[[VAL_118:.*]] = fir.call @_FortranAioBeginExternalListOutput(%[[VAL_18]], %[[VAL_117]], %{{.*}}) {{.*}}: (i32, !fir.ref<i8>, i32) -> !fir.ref<i8>
-! CHECK: %[[VAL_119:.*]] = fir.address_of(@_QQclX6D69736D617463682033) : !fir.ref<!fir.char<1,10>>
-! CHECK: %[[VAL_120:.*]] = fir.convert %[[VAL_119]] : (!fir.ref<!fir.char<1,10>>) -> !fir.ref<i8>
-! CHECK: %[[VAL_121:.*]] = fir.convert %[[VAL_0]] : (index) -> i64
-! CHECK: %[[VAL_122:.*]] = fir.call @_FortranAioOutputAscii(%[[VAL_118]], %[[VAL_120]], %[[VAL_121]]) {{.*}}: (!fir.ref<i8>, !fir.ref<i8>, i64) -> i1
-! CHECK: %[[VAL_123:.*]] = fir.load %[[VAL_113]] : !fir.ref<f32>
-! CHECK: %[[VAL_124:.*]] = fir.call @_FortranAioOutputReal32(%[[VAL_118]], %[[VAL_123]]) {{.*}}: (!fir.ref<i8>, f32) -> i1
-! CHECK: %[[VAL_125:.*]] = fir.load %[[VAL_111]] : !fir.ref<f32>
-! CHECK: %[[VAL_126:.*]] = fir.call @_FortranAioOutputReal32(%[[VAL_118]], %[[VAL_125]]) {{.*}}: (!fir.ref<i8>, f32) -> i1
-! CHECK: %[[VAL_127:.*]] = fir.call @_FortranAioEndIoStatement(%[[VAL_118]]) {{.*}}: (!fir.ref<i8>) -> i32
-! CHECK: br ^bb15
-! CHECK: ^bb15:
-! CHECK: %[[VAL_128:.*]] = fir.shape %[[VAL_0]] : (index) -> !fir.shape<1>
-! CHECK: %[[VAL_129:.*]] = fir.slice %[[VAL_5]], %[[VAL_0]], %[[VAL_22]] : (index, index, index) -> !fir.slice<1>
-! CHECK: br ^bb16(%[[VAL_6]], %[[VAL_11]] : index, index)
-! CHECK: ^bb16(%[[VAL_130:.*]]: index, %[[VAL_131:.*]]: index):
-! CHECK: %[[VAL_132:.*]] = arith.cmpi sgt, %[[VAL_131]], %[[VAL_6]] : index
-! CHECK: cond_br %[[VAL_132]], ^bb17, ^bb18
-! CHECK: ^bb17:
-! CHECK: %[[VAL_133:.*]] = arith.addi %[[VAL_130]], %[[VAL_5]] : index
-! CHECK: %[[VAL_134:.*]] = fir.array_coor %[[VAL_26]](%[[VAL_65]]) %[[VAL_133]] : (!fir.ref<!fir.array<3xf32>>, !fir.shape<1>, index) -> !fir.ref<f32>
-! CHECK: %[[VAL_135:.*]] = fir.load %[[VAL_134]] : !fir.ref<f32>
-! CHECK: %[[VAL_136:.*]] = fir.array_coor %[[VAL_27]](%[[VAL_128]]) {{\[}}%[[VAL_129]]] %[[VAL_133]] : (!fir.ref<!fir.array<10xf32>>, !fir.shape<1>, !fir.slice<1>, index) -> !fir.ref<f32>
-! CHECK: fir.store %[[VAL_135]] to %[[VAL_136]] : !fir.ref<f32>
-! CHECK: %[[VAL_137:.*]] = arith.subi %[[VAL_131]], %[[VAL_5]] : index
-! CHECK: br ^bb16(%[[VAL_133]], %[[VAL_137]] : index, index)
-! CHECK: ^bb18:
-! CHECK: %[[VAL_138:.*]] = fir.load %[[VAL_77]] : !fir.ref<f32>
-! CHECK: %[[VAL_139:.*]] = fir.coordinate_of %[[VAL_27]], %[[VAL_19]] : (!fir.ref<!fir.array<10xf32>>, i64) -> !fir.ref<f32>
-! CHECK: %[[VAL_140:.*]] = fir.load %[[VAL_139]] : !fir.ref<f32>
-! CHECK: %[[VAL_141:.*]] = arith.cmpf une, %[[VAL_138]], %[[VAL_140]] {{.*}} : f32
-! CHECK: cond_br %[[VAL_141]], ^bb19, ^bb20
-! CHECK: ^bb19:
-! CHECK: %[[VAL_142:.*]] = fir.address_of(@_QQclX{{.*}}) : !fir.ref<!fir.char<1,
-! CHECK: %[[VAL_143:.*]] = fir.convert %[[VAL_142]] : (!fir.ref<!fir.char<1,{{.*}}>>) -> !fir.ref<i8>
-! CHECK: %[[VAL_144:.*]] = fir.call @_FortranAioBeginExternalListOutput(%[[VAL_18]], %[[VAL_143]], %{{.*}}) {{.*}}: (i32, !fir.ref<i8>, i32) -> !fir.ref<i8>
-! CHECK: %[[VAL_145:.*]] = fir.address_of(@_QQclX6D69736D617463682034) : !fir.ref<!fir.char<1,10>>
-! CHECK: %[[VAL_146:.*]] = fir.convert %[[VAL_145]] : (!fir.ref<!fir.char<1,10>>) -> !fir.ref<i8>
-! CHECK: %[[VAL_147:.*]] = fir.convert %[[VAL_0]] : (index) -> i64
-! CHECK: %[[VAL_148:.*]] = fir.call @_FortranAioOutputAscii(%[[VAL_144]], %[[VAL_146]], %[[VAL_147]]) {{.*}}: (!fir.ref<i8>, !fir.ref<i8>, i64) -> i1
-! CHECK: %[[VAL_149:.*]] = fir.load %[[VAL_77]] : !fir.ref<f32>
-! CHECK: %[[VAL_150:.*]] = fir.call @_FortranAioOutputReal32(%[[VAL_144]], %[[VAL_149]]) {{.*}}: (!fir.ref<i8>, f32) -> i1
-! CHECK: %[[VAL_151:.*]] = fir.load %[[VAL_139]] : !fir.ref<f32>
-! CHECK: %[[VAL_152:.*]] = fir.call @_FortranAioOutputReal32(%[[VAL_144]], %[[VAL_151]]) {{.*}}: (!fir.ref<i8>, f32) -> i1
-! CHECK: %[[VAL_153:.*]] = fir.call @_FortranAioEndIoStatement(%[[VAL_144]]) {{.*}}: (!fir.ref<i8>) -> i32
-! CHECK: br ^bb20
-! CHECK: ^bb20:
-! CHECK: %[[VAL_154:.*]] = fir.load %[[VAL_94]] : !fir.ref<f32>
-! CHECK: %[[VAL_155:.*]] = fir.coordinate_of %[[VAL_27]], %[[VAL_16]] : (!fir.ref<!fir.array<10xf32>>, i64) -> !fir.ref<f32>
-! CHECK: %[[VAL_156:.*]] = fir.load %[[VAL_155]] : !fir.ref<f32>
-! CHECK: %[[VAL_157:.*]] = arith.cmpf une, %[[VAL_154]], %[[VAL_156]] {{.*}} : f32
-! CHECK: cond_br %[[VAL_157]], ^bb21, ^bb22
-! CHECK: ^bb21:
-! CHECK: %[[VAL_158:.*]] = fir.address_of(@_QQclX{{.*}}) : !fir.ref<!fir.char<1,
-! CHECK: %[[VAL_159:.*]] = fir.convert %[[VAL_158]] : (!fir.ref<!fir.char<1,{{.*}}>>) -> !fir.ref<i8>
-! CHECK: %[[VAL_160:.*]] = fir.call @_FortranAioBeginExternalListOutput(%[[VAL_18]], %[[VAL_159]], %{{.*}}) {{.*}}: (i32, !fir.ref<i8>, i32) -> !fir.ref<i8>
-! CHECK: %[[VAL_161:.*]] = fir.address_of(@_QQclX6D69736D617463682035) : !fir.ref<!fir.char<1,10>>
-! CHECK: %[[VAL_162:.*]] = fir.convert %[[VAL_161]] : (!fir.ref<!fir.char<1,10>>) -> !fir.ref<i8>
-! CHECK: %[[VAL_163:.*]] = fir.convert %[[VAL_0]] : (index) -> i64
-! CHECK: %[[VAL_164:.*]] = fir.call @_FortranAioOutputAscii(%[[VAL_160]], %[[VAL_162]], %[[VAL_163]]) {{.*}}: (!fir.ref<i8>, !fir.ref<i8>, i64) -> i1
-! CHECK: %[[VAL_165:.*]] = fir.load %[[VAL_94]] : !fir.ref<f32>
-! CHECK: %[[VAL_166:.*]] = fir.call @_FortranAioOutputReal32(%[[VAL_160]], %[[VAL_165]]) {{.*}}: (!fir.ref<i8>, f32) -> i1
-! CHECK: %[[VAL_167:.*]] = fir.load %[[VAL_155]] : !fir.ref<f32>
-! CHECK: %[[VAL_168:.*]] = fir.call @_FortranAioOutputReal32(%[[VAL_160]], %[[VAL_167]]) {{.*}}: (!fir.ref<i8>, f32) -> i1
-! CHECK: %[[VAL_169:.*]] = fir.call @_FortranAioEndIoStatement(%[[VAL_160]]) {{.*}}: (!fir.ref<i8>) -> i32
-! CHECK: br ^bb22
-! CHECK: ^bb22:
-! CHECK: %[[VAL_170:.*]] = fir.load %[[VAL_111]] : !fir.ref<f32>
-! CHECK: %[[VAL_171:.*]] = fir.coordinate_of %[[VAL_27]], %[[VAL_8]] : (!fir.ref<!fir.array<10xf32>>, i64) -> !fir.ref<f32>
-! CHECK: %[[VAL_172:.*]] = fir.load %[[VAL_171]] : !fir.ref<f32>
-! CHECK: %[[VAL_173:.*]] = arith.cmpf une, %[[VAL_170]], %[[VAL_172]] {{.*}} : f32
-! CHECK: cond_br %[[VAL_173]], ^bb23, ^bb24
-! CHECK: ^bb23:
-! CHECK: %[[VAL_174:.*]] = fir.address_of(@_QQclX{{.*}}) : !fir.ref<!fir.char<1,
-! CHECK: %[[VAL_175:.*]] = fir.convert %[[VAL_174]] : (!fir.ref<!fir.char<1,{{.*}}>>) -> !fir.ref<i8>
-! CHECK: %[[VAL_176:.*]] = fir.call @_FortranAioBeginExternalListOutput(%[[VAL_18]], %[[VAL_175]], %{{.*}}) {{.*}}: (i32, !fir.ref<i8>, i32) -> !fir.ref<i8>
-! CHECK: %[[VAL_177:.*]] = fir.address_of(@_QQclX6D69736D617463682036) : !fir.ref<!fir.char<1,10>>
-! CHECK: %[[VAL_178:.*]] = fir.convert %[[VAL_177]] : (!fir.ref<!fir.char<1,10>>) -> !fir.ref<i8>
-! CHECK: %[[VAL_179:.*]] = fir.convert %[[VAL_0]] : (index) -> i64
-! CHECK: %[[VAL_180:.*]] = fir.call @_FortranAioOutputAscii(%[[VAL_176]], %[[VAL_178]], %[[VAL_179]]) {{.*}}: (!fir.ref<i8>, !fir.ref<i8>, i64) -> i1
-! CHECK: %[[VAL_181:.*]] = fir.load %[[VAL_111]] : !fir.ref<f32>
-! CHECK: %[[VAL_182:.*]] = fir.call @_FortranAioOutputReal32(%[[VAL_176]], %[[VAL_181]]) {{.*}}: (!fir.ref<i8>, f32) -> i1
-! CHECK: %[[VAL_183:.*]] = fir.load %[[VAL_171]] : !fir.ref<f32>
-! CHECK: %[[VAL_184:.*]] = fir.call @_FortranAioOutputReal32(%[[VAL_176]], %[[VAL_183]]) {{.*}}: (!fir.ref<i8>, f32) -> i1
-! CHECK: %[[VAL_185:.*]] = fir.call @_FortranAioEndIoStatement(%[[VAL_176]]) {{.*}}: (!fir.ref<i8>) -> i32
-! CHECK: br ^bb24
-! CHECK: ^bb24:
-! CHECK: %[[VAL_186:.*]] = fir.address_of(@_QQro.3xi4.0) : !fir.ref<!fir.array<3xi32>>
-! CHECK: br ^bb25(%[[VAL_6]], %[[VAL_11]] : index, index)
-! CHECK: ^bb25(%[[VAL_187:.*]]: index, %[[VAL_188:.*]]: index):
-! CHECK: %[[VAL_189:.*]] = arith.cmpi sgt, %[[VAL_188]], %[[VAL_6]] : index
-! CHECK: cond_br %[[VAL_189]], ^bb26, ^bb27
-! CHECK: ^bb26:
-! CHECK: %[[VAL_190:.*]] = arith.addi %[[VAL_187]], %[[VAL_5]] : index
-! CHECK: %[[VAL_191:.*]] = fir.array_coor %[[VAL_186]](%[[VAL_65]]) %[[VAL_190]] : (!fir.ref<!fir.array<3xi32>>, !fir.shape<1>, index) -> !fir.ref<i32>
-! CHECK: %[[VAL_192:.*]] = fir.load %[[VAL_191]] : !fir.ref<i32>
-! CHECK: %[[VAL_193:.*]] = fir.array_coor %[[VAL_29]](%[[VAL_65]]) %[[VAL_190]] : (!fir.ref<!fir.array<3xi32>>, !fir.shape<1>, index) -> !fir.ref<i32>
-! CHECK: fir.store %[[VAL_192]] to %[[VAL_193]] : !fir.ref<i32>
-! CHECK: %[[VAL_194:.*]] = arith.subi %[[VAL_188]], %[[VAL_5]] : index
-! CHECK: br ^bb25(%[[VAL_190]], %[[VAL_194]] : index, index)
-! CHECK: ^bb27:
-! CHECK: %[[VAL_195:.*]] = fir.allocmem !fir.array<3xf32>
-! CHECK: br ^bb28(%[[VAL_6]], %[[VAL_11]] : index, index)
-! CHECK: ^bb28(%[[VAL_196:.*]]: index, %[[VAL_197:.*]]: index):
-! CHECK: %[[VAL_198:.*]] = arith.cmpi sgt, %[[VAL_197]], %[[VAL_6]] : index
-! CHECK: cond_br %[[VAL_198]], ^bb29, ^bb30
-! CHECK: ^bb29:
-! CHECK: %[[VAL_199:.*]] = arith.addi %[[VAL_196]], %[[VAL_5]] : index
-! CHECK: %[[VAL_200:.*]] = fir.array_coor %[[VAL_26]](%[[VAL_65]]) %[[VAL_199]] : (!fir.ref<!fir.array<3xf32>>, !fir.shape<1>, index) -> !fir.ref<f32>
-! CHECK: %[[VAL_201:.*]] = fir.array_coor %[[VAL_195]](%[[VAL_65]]) %[[VAL_199]] : (!fir.heap<!fir.array<3xf32>>, !fir.shape<1>, index) -> !fir.ref<f32>
-! CHECK: %[[VAL_202:.*]] = fir.load %[[VAL_200]] : !fir.ref<f32>
-! CHECK: fir.store %[[VAL_202]] to %[[VAL_201]] : !fir.ref<f32>
-! CHECK: %[[VAL_203:.*]] = arith.subi %[[VAL_197]], %[[VAL_5]] : index
-! CHECK: br ^bb28(%[[VAL_199]], %[[VAL_203]] : index, index)
-! CHECK: ^bb30(%[[VAL_205:.*]]: index, %[[VAL_206:.*]]: index):
-! CHECK: %[[VAL_207:.*]] = arith.cmpi sgt, %[[VAL_206]], %[[VAL_6]] : index
-! CHECK: cond_br %[[VAL_207]], ^bb31, ^bb32(%[[VAL_6]], %[[VAL_11]] : index, index)
-! CHECK: ^bb31:
-! CHECK: %[[VAL_208:.*]] = arith.addi %[[VAL_205]], %[[VAL_5]] : index
-! CHECK: %[[VAL_209:.*]] = fir.array_coor %[[VAL_29]](%[[VAL_65]]) %[[VAL_208]] : (!fir.ref<!fir.array<3xi32>>, !fir.shape<1>, index) -> !fir.ref<i32>
-! CHECK: %[[VAL_210:.*]] = fir.load %[[VAL_209]] : !fir.ref<i32>
-! CHECK: %[[VAL_211:.*]] = fir.convert %[[VAL_210]] : (i32) -> index
-! CHECK: %[[VAL_212:.*]] = fir.array_coor %[[VAL_26]](%[[VAL_65]]) %[[VAL_211]] : (!fir.ref<!fir.array<3xf32>>, !fir.shape<1>, index) -> !fir.ref<f32>
-! CHECK: %[[VAL_213:.*]] = fir.load %[[VAL_212]] : !fir.ref<f32>
-! CHECK: %[[VAL_214:.*]] = fir.array_coor %[[VAL_195]](%[[VAL_65]]) %[[VAL_208]] : (!fir.heap<!fir.array<3xf32>>, !fir.shape<1>, index) -> !fir.ref<f32>
-! CHECK: fir.store %[[VAL_213]] to %[[VAL_214]] : !fir.ref<f32>
-! CHECK: %[[VAL_215:.*]] = arith.subi %[[VAL_206]], %[[VAL_5]] : index
-! CHECK: br ^bb30(%[[VAL_208]], %[[VAL_215]] : index, index)
-! CHECK: ^bb32(%[[VAL_216:.*]]: index, %[[VAL_217:.*]]: index):
-! CHECK: %[[VAL_218:.*]] = arith.cmpi sgt, %[[VAL_217]], %[[VAL_6]] : index
-! CHECK: cond_br %[[VAL_218]], ^bb33, ^bb34
-! CHECK: ^bb33:
-! CHECK: %[[VAL_219:.*]] = arith.addi %[[VAL_216]], %[[VAL_5]] : index
-! CHECK: %[[VAL_220:.*]] = fir.array_coor %[[VAL_195]](%[[VAL_65]]) %[[VAL_219]] : (!fir.heap<!fir.array<3xf32>>, !fir.shape<1>, index) -> !fir.ref<f32>
-! CHECK: %[[VAL_221:.*]] = fir.array_coor %[[VAL_26]](%[[VAL_65]]) %[[VAL_219]] : (!fir.ref<!fir.array<3xf32>>, !fir.shape<1>, index) -> !fir.ref<f32>
-! CHECK: %[[VAL_222:.*]] = fir.load %[[VAL_220]] : !fir.ref<f32>
-! CHECK: fir.store %[[VAL_222]] to %[[VAL_221]] : !fir.ref<f32>
-! CHECK: %[[VAL_223:.*]] = arith.subi %[[VAL_217]], %[[VAL_5]] : index
-! CHECK: br ^bb32(%[[VAL_219]], %[[VAL_223]] : index, index)
-! CHECK: ^bb34:
-! CHECK: fir.freemem %[[VAL_195]] : !fir.heap<!fir.array<3xf32>>
-! CHECK: %[[VAL_224:.*]] = fir.load %[[VAL_77]] : !fir.ref<f32>
-! CHECK: %[[VAL_225:.*]] = fir.load %[[VAL_96]] : !fir.ref<f32>
-! CHECK: %[[VAL_226:.*]] = arith.cmpf une, %[[VAL_224]], %[[VAL_225]] {{.*}} : f32
-! CHECK: cond_br %[[VAL_226]], ^bb35, ^bb36
-! CHECK: ^bb35:
-! CHECK: %[[VAL_227:.*]] = fir.address_of(@_QQclX{{.*}}) : !fir.ref<!fir.char<1,
-! CHECK: %[[VAL_228:.*]] = fir.convert %[[VAL_227]] : (!fir.ref<!fir.char<1,{{.*}}>>) -> !fir.ref<i8>
-! CHECK: %[[VAL_229:.*]] = fir.call @_FortranAioBeginExternalListOutput(%[[VAL_18]], %[[VAL_228]], %{{.*}}) {{.*}}: (i32, !fir.ref<i8>, i32) -> !fir.ref<i8>
-! CHECK: %[[VAL_230:.*]] = fir.address_of(@_QQclX6D69736D617463682037) : !fir.ref<!fir.char<1,10>>
-! CHECK: %[[VAL_231:.*]] = fir.convert %[[VAL_230]] : (!fir.ref<!fir.char<1,10>>) -> !fir.ref<i8>
-! CHECK: %[[VAL_232:.*]] = fir.convert %[[VAL_0]] : (index) -> i64
-! CHECK: %[[VAL_233:.*]] = fir.call @_FortranAioOutputAscii(%[[VAL_229]], %[[VAL_231]], %[[VAL_232]]) {{.*}}: (!fir.ref<i8>, !fir.ref<i8>, i64) -> i1
-! CHECK: %[[VAL_234:.*]] = fir.load %[[VAL_77]] : !fir.ref<f32>
-! CHECK: %[[VAL_235:.*]] = fir.call @_FortranAioOutputReal32(%[[VAL_229]], %[[VAL_234]]) {{.*}}: (!fir.ref<i8>, f32) -> i1
-! CHECK: %[[VAL_236:.*]] = fir.load %[[VAL_96]] : !fir.ref<f32>
-! CHECK: %[[VAL_237:.*]] = fir.call @_FortranAioOutputReal32(%[[VAL_229]], %[[VAL_236]]) {{.*}}: (!fir.ref<i8>, f32) -> i1
-! CHECK: %[[VAL_238:.*]] = fir.call @_FortranAioEndIoStatement(%[[VAL_229]]) {{.*}}: (!fir.ref<i8>) -> i32
-! CHECK: br ^bb36
-! CHECK: ^bb36:
-! CHECK: %[[VAL_239:.*]] = fir.load %[[VAL_94]] : !fir.ref<f32>
-! CHECK: %[[VAL_240:.*]] = fir.load %[[VAL_113]] : !fir.ref<f32>
-! CHECK: %[[VAL_241:.*]] = arith.cmpf une, %[[VAL_239]], %[[VAL_240]] {{.*}} : f32
-! CHECK: cond_br %[[VAL_241]], ^bb37, ^bb38
-! CHECK: ^bb37:
-! CHECK: %[[VAL_242:.*]] = fir.address_of(@_QQclX{{.*}}) : !fir.ref<!fir.char<1,
-! CHECK: %[[VAL_243:.*]] = fir.convert %[[VAL_242]] : (!fir.ref<!fir.char<1,{{.*}}>>) -> !fir.ref<i8>
-! CHECK: %[[VAL_244:.*]] = fir.call @_FortranAioBeginExternalListOutput(%[[VAL_18]], %[[VAL_243]], %{{.*}}) {{.*}}: (i32, !fir.ref<i8>, i32) -> !fir.ref<i8>
-! CHECK: %[[VAL_245:.*]] = fir.address_of(@_QQclX6D69736D617463682038) : !fir.ref<!fir.char<1,10>>
-! CHECK: %[[VAL_246:.*]] = fir.convert %[[VAL_245]] : (!fir.ref<!fir.char<1,10>>) -> !fir.ref<i8>
-! CHECK: %[[VAL_247:.*]] = fir.convert %[[VAL_0]] : (index) -> i64
-! CHECK: %[[VAL_248:.*]] = fir.call @_FortranAioOutputAscii(%[[VAL_244]], %[[VAL_246]], %[[VAL_247]]) {{.*}}: (!fir.ref<i8>, !fir.ref<i8>, i64) -> i1
-! CHECK: %[[VAL_249:.*]] = fir.load %[[VAL_94]] : !fir.ref<f32>
-! CHECK: %[[VAL_250:.*]] = fir.call @_FortranAioOutputReal32(%[[VAL_244]], %[[VAL_249]]) {{.*}}: (!fir.ref<i8>, f32) -> i1
-! CHECK: %[[VAL_251:.*]] = fir.load %[[VAL_113]] : !fir.ref<f32>
-! CHECK: %[[VAL_252:.*]] = fir.call @_FortranAioOutputReal32(%[[VAL_244]], %[[VAL_251]]) {{.*}}: (!fir.ref<i8>, f32) -> i1
-! CHECK: %[[VAL_253:.*]] = fir.call @_FortranAioEndIoStatement(%[[VAL_244]]) {{.*}}: (!fir.ref<i8>) -> i32
-! CHECK: br ^bb38
-! CHECK: ^bb38:
-! CHECK: %[[VAL_254:.*]] = fir.load %[[VAL_111]] : !fir.ref<f32>
-! CHECK: %[[VAL_255:.*]] = fir.load %[[VAL_79]] : !fir.ref<f32>
-! CHECK: %[[VAL_256:.*]] = arith.cmpf une, %[[VAL_254]], %[[VAL_255]] {{.*}} : f32
-! CHECK: cond_br %[[VAL_256]], ^bb39, ^bb40
-! CHECK: ^bb39:
-! CHECK: %[[VAL_257:.*]] = fir.address_of(@_QQclX{{.*}}) : !fir.ref<!fir.char<1,
-! CHECK: %[[VAL_258:.*]] = fir.convert %[[VAL_257]] : (!fir.ref<!fir.char<1,{{.*}}>>) -> !fir.ref<i8>
-! CHECK: %[[VAL_259:.*]] = fir.call @_FortranAioBeginExternalListOutput(%[[VAL_18]], %[[VAL_258]], %{{.*}}) {{.*}}: (i32, !fir.ref<i8>, i32) -> !fir.ref<i8>
-! CHECK: %[[VAL_260:.*]] = fir.address_of(@_QQclX6D69736D617463682039) : !fir.ref<!fir.char<1,10>>
-! CHECK: %[[VAL_261:.*]] = fir.convert %[[VAL_260]] : (!fir.ref<!fir.char<1,10>>) -> !fir.ref<i8>
-! CHECK: %[[VAL_262:.*]] = fir.convert %[[VAL_0]] : (index) -> i64
-! CHECK: %[[VAL_263:.*]] = fir.call @_FortranAioOutputAscii(%[[VAL_259]], %[[VAL_261]], %[[VAL_262]]) {{.*}}: (!fir.ref<i8>, !fir.ref<i8>, i64) -> i1
-! CHECK: %[[VAL_264:.*]] = fir.load %[[VAL_111]] : !fir.ref<f32>
-! CHECK: %[[VAL_265:.*]] = fir.call @_FortranAioOutputReal32(%[[VAL_259]], %[[VAL_264]]) {{.*}}: (!fir.ref<i8>, f32) -> i1
-! CHECK: %[[VAL_266:.*]] = fir.load %[[VAL_79]] : !fir.ref<f32>
-! CHECK: %[[VAL_267:.*]] = fir.call @_FortranAioOutputReal32(%[[VAL_259]], %[[VAL_266]]) {{.*}}: (!fir.ref<i8>, f32) -> i1
-! CHECK: %[[VAL_268:.*]] = fir.call @_FortranAioEndIoStatement(%[[VAL_259]]) {{.*}}: (!fir.ref<i8>) -> i32
-! CHECK: br ^bb40
-! CHECK: ^bb40:
-! CHECK: return
-! CHECK: }
+! CHECK: %[[a1:.*]]:2 = hlfir.declare %{{.*}} {uniq_name = "_QFEa1"}
+! CHECK: %[[a2:.*]]:2 = hlfir.declare %{{.*}} {uniq_name = "_QFEa2"}
+! CHECK: %[[a3:.*]]:2 = hlfir.declare %{{.*}} {uniq_name = "_QFEa3"}
+! CHECK: %[[iv:.*]]:2 = hlfir.declare %{{.*}} {uniq_name = "_QFEiv"}
+
+! CHECK: fir.do_loop
+! CHECK: fir.do_loop
+! CHECK: fir.call @fir.cos
+! CHECK: hlfir.assign
+! CHECK: fir.call @fir.sin
+! CHECK: hlfir.assign
+
+! a2 = a1(4, 2:10:3)
+! CHECK: %[[slice1:.*]] = hlfir.designate %[[a1]]#0 (%c4{{.*}}, %c2{{.*}}:%c10{{.*}}:%c3{{.*}})
+! CHECK: hlfir.assign %[[slice1]] to %[[a2]]#0
+
+! a3(1:10:4) = a2
+! CHECK: %[[slice2:.*]] = hlfir.designate %[[a3]]#0 (%c1{{.*}}:%c10{{.*}}:%c4{{.*}})
+! CHECK: hlfir.assign %[[a2]]#0 to %[[slice2]]
+
+! a2 = a2(iv)
+! CHECK: %[[iv_expr:.*]] = hlfir.elemental %{{.*}} unordered : (!fir.shape<1>) -> !hlfir.expr<3xi64> {
+! CHECK: fir.load
+! CHECK: fir.convert
+! CHECK: hlfir.yield_element
+! CHECK: }
+! CHECK: %[[vec_slice:.*]] = hlfir.elemental %{{.*}} unordered : (!fir.shape<1>) -> !hlfir.expr<3xf32> {
+! CHECK: ^bb0(%[[idx:.*]]: index):
+! CHECK: %[[iv_val:.*]] = hlfir.apply %[[iv_expr]], %[[idx]]
+! CHECK: %[[a2_elem:.*]] = hlfir.designate %[[a2]]#0 (%[[iv_val]])
+! CHECK: %[[val:.*]] = fir.load %[[a2_elem]]
+! CHECK: hlfir.yield_element %[[val]]
+! CHECK: }
+! CHECK: hlfir.assign %[[vec_slice]] to %[[a2]]#0
program p
real :: a1(10,10)
@@ -380,29 +75,12 @@ program p
end program p
! CHECK-LABEL: func @_QPsub(
-! CHECK-SAME: %[[VAL_0:.*]]: !fir.boxchar<1>{{.*}}) {
-! CHECK-DAG: %[[VAL_1:.*]] = arith.constant 5 : index
-! CHECK-DAG: %[[VAL_2:.*]] = arith.constant 2 : index
-! CHECK-DAG: %[[VAL_3:.*]] = arith.constant 1 : index
-! CHECK-DAG: %[[VAL_4:.*]] = arith.constant 4 : index
-! CHECK-DAG: %[[VAL_6:.*]] = arith.constant 6 : i32
-! CHECK-DAG: %[[VAL_7:.*]] = arith.constant 10 : index
-! CHECK: %[[VAL_8:.*]]:2 = fir.unboxchar %[[VAL_0]] : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1,?>>, index)
-! CHECK: %[[VAL_9:.*]] = fir.convert %[[VAL_8]]#0 : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<!fir.array<10x!fir.char<1>>>
-! CHECK: %[[VAL_10:.*]] = fir.address_of(@_QQclX{{.*}}) : !fir.ref<!fir.char<1,
-! CHECK: %[[VAL_11:.*]] = fir.convert %[[VAL_10]] : (!fir.ref<!fir.char<1,{{.*}}>>) -> !fir.ref<i8>
-! CHECK: %[[VAL_12:.*]] = fir.call @_FortranAioBeginExternalListOutput(%[[VAL_6]], %[[VAL_11]], %{{.*}}) {{.*}}: (i32, !fir.ref<i8>, i32) -> !fir.ref<i8>
-! CHECK: %[[VAL_13:.*]] = fir.address_of(@_QQclX61203D20) : !fir.ref<!fir.char<1,4>>
-! CHECK: %[[VAL_14:.*]] = fir.convert %[[VAL_13]] : (!fir.ref<!fir.char<1,4>>) -> !fir.ref<i8>
-! CHECK: %[[VAL_15:.*]] = fir.convert %[[VAL_4]] : (index) -> i64
-! CHECK: %[[VAL_16:.*]] = fir.call @_FortranAioOutputAscii(%[[VAL_12]], %[[VAL_14]], %[[VAL_15]]) {{.*}}: (!fir.ref<i8>, !fir.ref<i8>, i64) -> i1
-! CHECK: %[[VAL_17:.*]] = fir.shape %[[VAL_7]] : (index) -> !fir.shape<1>
-! CHECK: %[[VAL_18:.*]] = fir.slice %[[VAL_3]], %[[VAL_1]], %[[VAL_2]] : (index, index, index) -> !fir.slice<1>
-! CHECK: %[[VAL_19:.*]] = fir.embox %[[VAL_9]](%[[VAL_17]]) {{\[}}%[[VAL_18]]] : (!fir.ref<!fir.array<10x!fir.char<1>>>, !fir.shape<1>, !fir.slice<1>) -> !fir.box<!fir.array<3x!fir.char<1>>>
-! CHECK: %[[VAL_20:.*]] = fir.convert %[[VAL_19]] : (!fir.box<!fir.array<3x!fir.char<1>>>) -> !fir.box<none>
-! CHECK: %[[VAL_21:.*]] = fir.call @_FortranAioOutputDescriptor(%[[VAL_12]], %[[VAL_20]]) {{.*}}: (!fir.ref<i8>, !fir.box<none>) -> i1
-! CHECK: %[[VAL_22:.*]] = fir.call @_FortranAioEndIoStatement(%[[VAL_12]]) {{.*}}: (!fir.ref<i8>) -> i32
-! CHECK: return
+! CHECK-SAME: %[[arg:.*]]: !fir.boxchar<1>{{.*}}) {
+! CHECK: %[[unbox:.*]]:2 = fir.unboxchar %[[arg]]
+! CHECK: %[[addr:.*]] = fir.convert %[[unbox]]#0
+! CHECK: %[[a:.*]]:2 = hlfir.declare %[[addr]](%{{.*}}) typeparams %{{.*}}
+! CHECK: %[[slice:.*]] = hlfir.designate %[[a]]#0 (%c1{{.*}}:%c5{{.*}}:%c2{{.*}})
+! CHECK: fir.call @_FortranAioOutputDescriptor
! CHECK: }
! Slice operation on array of CHARACTER
diff --git a/flang/test/Lower/array-expression-slice-2.f90 b/flang/test/Lower/array-expression-slice-2.f90
index 61499ec3027f8..ba987baed003b 100644
--- a/flang/test/Lower/array-expression-slice-2.f90
+++ b/flang/test/Lower/array-expression-slice-2.f90
@@ -1,4 +1,4 @@
-! RUN: bbc -hlfir=false %s -o - | FileCheck %s
+! RUN: bbc -emit-hlfir %s -o - | FileCheck %s
! CHECK-LABEL: func @_QPi
subroutine i
@@ -15,6 +15,21 @@ subroutine s
real (kind = LONGreal) :: gs(13)
x(1) = 4.0
g(1) = 5.0
+ ! CHECK: %[[g_decl:.*]]:2 = hlfir.declare %{{.*}} {uniq_name = "_QFsEg"}
+ ! CHECK: %[[gs_decl:.*]]:2 = hlfir.declare %{{.*}} {uniq_name = "_QFsEgs"}
+ ! CHECK: %[[x_decl:.*]]:2 = hlfir.declare %{{.*}} {uniq_name = "_QFsEx"}
+ ! CHECK: %[[g_slice:.*]] = hlfir.designate %[[g_decl]]#0 (%c0{{.*}}:%c12{{.*}}:%c1{{.*}})
+ ! CHECK: %[[x_slice:.*]] = hlfir.designate %[[x_decl]]#0 (%c11{{.*}}:%c-1{{.*}}:%c-1{{.*}})
+ ! CHECK: %[[res:.*]] = hlfir.elemental %{{.*}} unordered : (!fir.shape<1>) -> !hlfir.expr<13xf64> {
+ ! CHECK: ^bb0(%[[idx:.*]]: index):
+ ! CHECK: %[[g_elem:.*]] = hlfir.designate %[[g_slice]] (%[[idx]])
+ ! CHECK: %[[x_elem:.*]] = hlfir.designate %[[x_slice]] (%[[idx]])
+ ! CHECK: %[[g_val:.*]] = fir.load %[[g_elem]]
+ ! CHECK: %[[x_val:.*]] = fir.load %[[x_elem]]
+ ! CHECK: %[[sum:.*]] = arith.addf %[[g_val]], %[[x_val]]
+ ! CHECK: hlfir.yield_element %[[sum]]
+ ! CHECK: }
+ ! CHECK: hlfir.assign %[[res]] to %[[gs_decl]]#0
gs = g(0:12:1) + x(11:(-1):(-1))
print *, gs
!print *, dot_product(g(0:12:1), x(11:(-1):(-1)))
@@ -23,12 +38,12 @@ end subroutine s
! CHECK-LABEL: func @_QPs2
subroutine s2
real :: x(10)
+ ! CHECK: %[[x:.*]]:2 = hlfir.declare %{{.*}} {uniq_name = "_QFs2Ex"}
x = 0.0
! CHECK: fir.call @_FortranAioBeginExternalListOutput
print *, x
- ! CHECK: %[[s:.*]] = fir.slice {{.*}} !fir.slice<1>
- ! CHECK: %[[p:.*]] = fir.array_coor %{{.*}} [%[[s]]] %
- ! CHECK: fir.store %{{.*}} to %[[p]] : !fir.ref<f32>
+ ! CHECK: %[[slice:.*]] = hlfir.designate %[[x]]#0 (%c1{{.*}}:%c10{{.*}}:%c3{{.*}})
+ ! CHECK: hlfir.assign %cst{{.*}} to %[[slice]]
x(1:10:3) = 2.0
! CHECK: fir.call @_FortranAioBeginExternalListOutput
print *, x
@@ -41,10 +56,10 @@ program main
A(2) = 2
A(3) = 3
print *, A
- ! CHECK: %[[A:.*]] = fir.address_of(@_QFEa)
- ! CHECK: %[[shape:.*]] = fir.shape %c10
- ! CHECK: %[[slice:.*]] = fir.slice %
- ! CHECK: fir.embox %[[A]](%[[shape]]) [%[[slice]]] :
+ ! CHECK: %[[A:.*]]:2 = hlfir.declare %{{.*}} {uniq_name = "_QFEa"}
+ ! CHECK: %[[slice:.*]] = hlfir.designate %[[A]]#0 (%c1{{.*}}:%c3{{.*}}:%c1{{.*}})
+ ! CHECK: %[[box:.*]] = fir.embox %[[slice]]
+ ! CHECK: fir.convert %[[box]] : (!fir.box<!fir.array<3xi32>>) -> !fir.box<none>
print*, A(1:3:1)
call s
call i
diff --git a/flang/test/Lower/array-expression-subscript.f90 b/flang/test/Lower/array-expression-subscript.f90
index 60180b5e305df..140a3f130157e 100644
--- a/flang/test/Lower/array-expression-subscript.f90
+++ b/flang/test/Lower/array-expression-subscript.f90
@@ -1,46 +1,26 @@
-! RUN: bbc --emit-fir -hlfir=false %s -o - | FileCheck %s
+! RUN: bbc -emit-hlfir %s -o - | FileCheck %s
! CHECK-LABEL: func @_QPtest1a(
-! CHECK-SAME: %[[VAL_0:.*]]: !fir.ref<!fir.array<10xi32>>{{.*}}, %[[VAL_1:.*]]: !fir.ref<!fir.array<10xi32>>{{.*}}, %[[VAL_2:.*]]: !fir.ref<!fir.array<20xi32>>{{.*}}) {
-! CHECK: %[[VAL_3:.*]] = arith.constant 10 : index
-! CHECK: %[[VAL_4:.*]] = arith.constant 10 : index
-! CHECK: %[[VAL_5:.*]] = arith.constant 20 : index
-! CHECK: %[[VAL_6:.*]] = fir.shape %[[VAL_3]] : (index) -> !fir.shape<1>
-! CHECK: %[[VAL_7:.*]] = fir.array_load %[[VAL_0]](%[[VAL_6]]) : (!fir.ref<!fir.array<10xi32>>, !fir.shape<1>) -> !fir.array<10xi32>
-! CHECK: %[[VAL_8:.*]] = arith.constant 1 : index
-! CHECK: %[[VAL_9:.*]] = arith.constant 1 : i64
-! CHECK: %[[VAL_10:.*]] = fir.convert %[[VAL_9]] : (i64) -> index
-! CHECK: %[[VAL_11:.*]] = arith.constant 2 : i64
-! CHECK: %[[VAL_12:.*]] = fir.convert %[[VAL_11]] : (i64) -> index
-! CHECK: %[[VAL_13:.*]] = arith.constant 20 : i64
-! CHECK: %[[VAL_14:.*]] = fir.convert %[[VAL_13]] : (i64) -> index
-! CHECK: %[[VAL_15:.*]] = arith.constant 0 : index
-! CHECK: %[[VAL_16:.*]] = arith.subi %[[VAL_14]], %[[VAL_10]] : index
-! CHECK: %[[VAL_17:.*]] = arith.addi %[[VAL_16]], %[[VAL_12]] : index
-! CHECK: %[[VAL_18:.*]] = arith.divsi %[[VAL_17]], %[[VAL_12]] : index
-! CHECK: %[[VAL_19:.*]] = arith.cmpi sgt, %[[VAL_18]], %[[VAL_15]] : index
-! CHECK: %[[VAL_20:.*]] = arith.select %[[VAL_19]], %[[VAL_18]], %[[VAL_15]] : index
-! CHECK: %[[VAL_21:.*]] = fir.shape %[[VAL_5]] : (index) -> !fir.shape<1>
-! CHECK: %[[VAL_22:.*]] = fir.slice %[[VAL_10]], %[[VAL_14]], %[[VAL_12]] : (index, index, index) -> !fir.slice<1>
-! CHECK: %[[VAL_23:.*]] = fir.array_load %[[VAL_2]](%[[VAL_21]]) {{\[}}%[[VAL_22]]] : (!fir.ref<!fir.array<20xi32>>, !fir.shape<1>, !fir.slice<1>) -> !fir.array<20xi32>
-! CHECK: %[[VAL_24:.*]] = arith.cmpi sgt, %[[VAL_20]], %[[VAL_3]] : index
-! CHECK: %[[VAL_25:.*]] = arith.select %[[VAL_24]], %[[VAL_3]], %[[VAL_20]] : index
-! CHECK: %[[VAL_32:.*]] = fir.shape %[[VAL_4]] : (index) -> !fir.shape<1>
-! CHECK: %[[VAL_34:.*]] = fir.array_load %[[VAL_1]](%[[VAL_32]]) : (!fir.ref<!fir.array<10xi32>>, !fir.shape<1>) -> !fir.array<10xi32>
-! CHECK: %[[VAL_35:.*]] = arith.constant 1 : index
-! CHECK: %[[VAL_36:.*]] = arith.constant 0 : index
-! CHECK: %[[VAL_37:.*]] = arith.subi %[[VAL_25]], %[[VAL_35]] : index
-! CHECK: %[[VAL_38:.*]] = fir.do_loop %[[VAL_39:.*]] = %[[VAL_36]] to %[[VAL_37]] step %[[VAL_35]] unordered iter_args(%[[VAL_40:.*]] = %[[VAL_7]]) -> (!fir.array<10xi32>) {
-! CHECK: %[[VAL_41:.*]] = fir.array_fetch %[[VAL_23]], %[[VAL_39]] : (!fir.array<20xi32>, index) -> i32
-! CHECK: %[[VAL_42:.*]] = fir.convert %[[VAL_41]] : (i32) -> index
-! CHECK: %[[VAL_43:.*]] = arith.subi %[[VAL_42]], %[[VAL_8]] : index
-! CHECK: %[[VAL_44:.*]] = fir.array_fetch %[[VAL_34]], %[[VAL_43]] : (!fir.array<10xi32>, index) -> i32
-! CHECK: %[[VAL_45:.*]] = fir.array_update %[[VAL_40]], %[[VAL_44]], %[[VAL_39]] : (!fir.array<10xi32>, i32, index) -> !fir.array<10xi32>
-! CHECK: fir.result %[[VAL_45]] : !fir.array<10xi32>
+! CHECK-SAME: %[[a:.*]]: !fir.ref<!fir.array<10xi32>>{{.*}}, %[[b:.*]]: !fir.ref<!fir.array<10xi32>>{{.*}}, %[[c:.*]]: !fir.ref<!fir.array<20xi32>>{{.*}}) {
+! CHECK: %[[a_decl:.*]]:2 = hlfir.declare %[[a]]
+! CHECK: %[[b_decl:.*]]:2 = hlfir.declare %[[b]]
+! CHECK: %[[c_decl:.*]]:2 = hlfir.declare %[[c]]
+! CHECK: %[[c_slice:.*]] = hlfir.designate %[[c_decl]]#0 (%c1{{.*}}:%c20{{.*}}:%c2{{.*}})
+! CHECK: %[[c_expr:.*]] = hlfir.elemental %{{.*}} unordered : (!fir.shape<1>) -> !hlfir.expr<10xi64> {
+! CHECK: ^bb0(%[[idx:.*]]: index):
+! CHECK: %[[c_elem:.*]] = hlfir.designate %[[c_slice]] (%[[idx]])
+! CHECK: %[[val:.*]] = fir.load %[[c_elem]]
+! CHECK: %[[cast:.*]] = fir.convert %[[val]]
+! CHECK: hlfir.yield_element %[[cast]]
! CHECK: }
-! CHECK: fir.array_merge_store %[[VAL_7]], %[[VAL_46:.*]] to %[[VAL_0]] : !fir.array<10xi32>, !fir.array<10xi32>, !fir.ref<!fir.array<10xi32>>
-! CHECK: return
-! CHECK: }
+! CHECK: %[[res:.*]] = hlfir.elemental %{{.*}} unordered : (!fir.shape<1>) -> !hlfir.expr<10xi32> {
+! CHECK: ^bb0(%[[idx:.*]]: index):
+! CHECK: %[[c_val:.*]] = hlfir.apply %[[c_expr]], %[[idx]]
+! CHECK: %[[b_elem:.*]] = hlfir.designate %[[b_decl]]#0 (%[[c_val]])
+! CHECK: %[[b_val:.*]] = fir.load %[[b_elem]]
+! CHECK: hlfir.yield_element %[[b_val]]
+! CHECK: }
+! CHECK: hlfir.assign %[[res]] to %[[a_decl]]#0
subroutine test1a(a,b,c)
integer :: a(10), b(10), c(20)
@@ -49,46 +29,28 @@ subroutine test1a(a,b,c)
end subroutine test1a
! CHECK-LABEL: func @_QPtest1b(
-! CHECK-SAME: %[[VAL_0:.*]]: !fir.ref<!fir.array<10xi32>>{{.*}}, %[[VAL_1:.*]]: !fir.ref<!fir.array<10xi32>>{{.*}}, %[[VAL_2:.*]]: !fir.ref<!fir.array<20xi32>>{{.*}}) {
-! CHECK: %[[VAL_3:.*]] = arith.constant 10 : index
-! CHECK: %[[VAL_4:.*]] = arith.constant 10 : index
-! CHECK: %[[VAL_5:.*]] = arith.constant 20 : index
-! CHECK: %[[VAL_6:.*]] = arith.constant 1 : index
-! CHECK: %[[VAL_7:.*]] = arith.constant 1 : i64
-! CHECK: %[[VAL_8:.*]] = fir.convert %[[VAL_7]] : (i64) -> index
-! CHECK: %[[VAL_9:.*]] = arith.constant 2 : i64
-! CHECK: %[[VAL_10:.*]] = fir.convert %[[VAL_9]] : (i64) -> index
-! CHECK: %[[VAL_11:.*]] = arith.constant 20 : i64
-! CHECK: %[[VAL_12:.*]] = fir.convert %[[VAL_11]] : (i64) -> index
-! CHECK: %[[VAL_13:.*]] = arith.constant 0 : index
-! CHECK: %[[VAL_14:.*]] = arith.subi %[[VAL_12]], %[[VAL_8]] : index
-! CHECK: %[[VAL_15:.*]] = arith.addi %[[VAL_14]], %[[VAL_10]] : index
-! CHECK: %[[VAL_16:.*]] = arith.divsi %[[VAL_15]], %[[VAL_10]] : index
-! CHECK: %[[VAL_17:.*]] = arith.cmpi sgt, %[[VAL_16]], %[[VAL_13]] : index
-! CHECK: %[[VAL_18:.*]] = arith.select %[[VAL_17]], %[[VAL_16]], %[[VAL_13]] : index
-! CHECK: %[[VAL_19:.*]] = fir.shape %[[VAL_5]] : (index) -> !fir.shape<1>
-! CHECK: %[[VAL_20:.*]] = fir.slice %[[VAL_8]], %[[VAL_12]], %[[VAL_10]] : (index, index, index) -> !fir.slice<1>
-! CHECK: %[[VAL_21:.*]] = fir.array_load %[[VAL_2]](%[[VAL_19]]) {{\[}}%[[VAL_20]]] : (!fir.ref<!fir.array<20xi32>>, !fir.shape<1>, !fir.slice<1>) -> !fir.array<20xi32>
-! CHECK: %[[VAL_22:.*]] = arith.cmpi sgt, %[[VAL_18]], %[[VAL_4]] : index
-! CHECK: %[[VAL_23:.*]] = arith.select %[[VAL_22]], %[[VAL_4]], %[[VAL_18]] : index
-! CHECK: %[[VAL_30:.*]] = fir.shape %[[VAL_4]] : (index) -> !fir.shape<1>
-! CHECK: %[[VAL_32:.*]] = fir.array_load %[[VAL_1]](%[[VAL_30]]) : (!fir.ref<!fir.array<10xi32>>, !fir.shape<1>) -> !fir.array<10xi32>
-! CHECK: %[[VAL_33:.*]] = fir.shape %[[VAL_3]] : (index) -> !fir.shape<1>
-! CHECK: %[[VAL_34:.*]] = fir.array_load %[[VAL_0]](%[[VAL_33]]) : (!fir.ref<!fir.array<10xi32>>, !fir.shape<1>) -> !fir.array<10xi32>
-! CHECK: %[[VAL_35:.*]] = arith.constant 1 : index
-! CHECK: %[[VAL_36:.*]] = arith.constant 0 : index
-! CHECK: %[[VAL_37:.*]] = arith.subi %[[VAL_23]], %[[VAL_35]] : index
-! CHECK: %[[VAL_38:.*]] = fir.do_loop %[[VAL_39:.*]] = %[[VAL_36]] to %[[VAL_37]] step %[[VAL_35]] unordered iter_args(%[[VAL_40:.*]] = %[[VAL_32]]) -> (!fir.array<10xi32>) {
-! CHECK: %[[VAL_41:.*]] = fir.array_fetch %[[VAL_34]], %[[VAL_39]] : (!fir.array<10xi32>, index) -> i32
-! CHECK: %[[VAL_42:.*]] = fir.array_fetch %[[VAL_21]], %[[VAL_39]] : (!fir.array<20xi32>, index) -> i32
-! CHECK: %[[VAL_43:.*]] = fir.convert %[[VAL_42]] : (i32) -> index
-! CHECK: %[[VAL_44:.*]] = arith.subi %[[VAL_43]], %[[VAL_6]] : index
-! CHECK: %[[VAL_45:.*]] = fir.array_update %[[VAL_40]], %[[VAL_41]], %[[VAL_44]] : (!fir.array<10xi32>, i32, index) -> !fir.array<10xi32>
-! CHECK: fir.result %[[VAL_45]] : !fir.array<10xi32>
+! CHECK-SAME: %[[a:.*]]: !fir.ref<!fir.array<10xi32>>{{.*}}, %[[b:.*]]: !fir.ref<!fir.array<10xi32>>{{.*}}, %[[c:.*]]: !fir.ref<!fir.array<20xi32>>{{.*}}) {
+! CHECK: %[[a_decl:.*]]:2 = hlfir.declare %[[a]]
+! CHECK: %[[b_decl:.*]]:2 = hlfir.declare %[[b]]
+! CHECK: %[[c_decl:.*]]:2 = hlfir.declare %[[c]]
+! CHECK: hlfir.region_assign {
+! CHECK: hlfir.yield %[[a_decl]]#0
+! CHECK: } to {
+! CHECK: %[[c_slice:.*]] = hlfir.designate %[[c_decl]]#0 (%c1{{.*}}:%c20{{.*}}:%c2{{.*}})
+! CHECK: %[[c_expr:.*]] = hlfir.elemental %{{.*}} unordered : (!fir.shape<1>) -> !hlfir.expr<10xi64> {
+! CHECK: ^bb0(%[[idx:.*]]: index):
+! CHECK: %[[c_elem:.*]] = hlfir.designate %[[c_slice]] (%[[idx]])
+! CHECK: %[[val:.*]] = fir.load %[[c_elem]]
+! CHECK: %[[cast:.*]] = fir.convert %[[val]]
+! CHECK: hlfir.yield_element %[[cast]]
+! CHECK: }
+! CHECK: hlfir.elemental_addr %{{.*}} unordered : !fir.shape<1> {
+! CHECK: ^bb0(%[[idx:.*]]: index):
+! CHECK: %[[c_val:.*]] = hlfir.apply %[[c_expr]], %[[idx]]
+! CHECK: %[[b_elem:.*]] = hlfir.designate %[[b_decl]]#0 (%[[c_val]])
+! CHECK: hlfir.yield %[[b_elem]]
+! CHECK: }
! CHECK: }
-! CHECK: fir.array_merge_store %[[VAL_32]], %[[VAL_46:.*]] to %[[VAL_1]] : !fir.array<10xi32>, !fir.array<10xi32>, !fir.ref<!fir.array<10xi32>>
-! CHECK: return
-! CHECK: }
subroutine test1b(a,b,c)
integer :: a(10), b(10), c(20)
@@ -97,42 +59,35 @@ subroutine test1b(a,b,c)
end subroutine test1b
! CHECK-LABEL: func @_QPtest2a(
-! CHECK-SAME: %[[VAL_0:.*]]: !fir.ref<!fir.array<10xi32>>{{.*}}, %[[VAL_1:.*]]: !fir.ref<!fir.array<10xi32>>{{.*}}, %[[VAL_2:.*]]: !fir.ref<!fir.array<10xi32>>{{.*}}, %[[VAL_3:.*]]: !fir.ref<!fir.array<10xi32>>{{.*}}) {
-! CHECK: %[[VAL_4:.*]] = arith.constant 10 : index
-! CHECK: %[[VAL_5:.*]] = arith.constant 10 : index
-! CHECK: %[[VAL_6:.*]] = arith.constant 10 : index
-! CHECK: %[[VAL_7:.*]] = arith.constant 10 : index
-! CHECK: %[[VAL_8:.*]] = fir.shape %[[VAL_4]] : (index) -> !fir.shape<1>
-! CHECK: %[[VAL_9:.*]] = fir.array_load %[[VAL_0]](%[[VAL_8]]) : (!fir.ref<!fir.array<10xi32>>, !fir.shape<1>) -> !fir.array<10xi32>
-! CHECK: %[[VAL_10:.*]] = arith.constant 1 : index
-! CHECK: %[[VAL_11:.*]] = arith.constant 1 : index
-! CHECK: %[[VAL_12:.*]] = fir.shape %[[VAL_7]] : (index) -> !fir.shape<1>
-! CHECK: %[[VAL_13:.*]] = fir.array_load %[[VAL_3]](%[[VAL_12]]) : (!fir.ref<!fir.array<10xi32>>, !fir.shape<1>) -> !fir.array<10xi32>
-! CHECK: %[[VAL_14:.*]] = arith.cmpi sgt, %[[VAL_7]], %[[VAL_6]] : index
-! CHECK: %[[VAL_15:.*]] = arith.select %[[VAL_14]], %[[VAL_6]], %[[VAL_7]] : index
-! CHECK: %[[VAL_16:.*]] = fir.shape %[[VAL_6]] : (index) -> !fir.shape<1>
-! CHECK: %[[VAL_18:.*]] = fir.array_load %[[VAL_2]](%[[VAL_16]]) : (!fir.ref<!fir.array<10xi32>>, !fir.shape<1>) -> !fir.array<10xi32>
-! CHECK: %[[VAL_19:.*]] = arith.cmpi sgt, %[[VAL_15]], %[[VAL_4]] : index
-! CHECK: %[[VAL_20:.*]] = arith.select %[[VAL_19]], %[[VAL_4]], %[[VAL_15]] : index
-! CHECK: %[[VAL_27:.*]] = fir.shape %[[VAL_5]] : (index) -> !fir.shape<1>
-! CHECK: %[[VAL_29:.*]] = fir.array_load %[[VAL_1]](%[[VAL_27]]) : (!fir.ref<!fir.array<10xi32>>, !fir.shape<1>) -> !fir.array<10xi32>
-! CHECK: %[[VAL_30:.*]] = arith.constant 1 : index
-! CHECK: %[[VAL_31:.*]] = arith.constant 0 : index
-! CHECK: %[[VAL_32:.*]] = arith.subi %[[VAL_20]], %[[VAL_30]] : index
-! CHECK: %[[VAL_33:.*]] = fir.do_loop %[[VAL_34:.*]] = %[[VAL_31]] to %[[VAL_32]] step %[[VAL_30]] unordered iter_args(%[[VAL_35:.*]] = %[[VAL_9]]) -> (!fir.array<10xi32>) {
-! CHECK: %[[VAL_36:.*]] = fir.array_fetch %[[VAL_13]], %[[VAL_34]] : (!fir.array<10xi32>, index) -> i32
-! CHECK: %[[VAL_37:.*]] = fir.convert %[[VAL_36]] : (i32) -> index
-! CHECK: %[[VAL_38:.*]] = arith.subi %[[VAL_37]], %[[VAL_11]] : index
-! CHECK: %[[VAL_39:.*]] = fir.array_fetch %[[VAL_18]], %[[VAL_38]] : (!fir.array<10xi32>, index) -> i32
-! CHECK: %[[VAL_40:.*]] = fir.convert %[[VAL_39]] : (i32) -> index
-! CHECK: %[[VAL_41:.*]] = arith.subi %[[VAL_40]], %[[VAL_10]] : index
-! CHECK: %[[VAL_42:.*]] = fir.array_fetch %[[VAL_29]], %[[VAL_41]] : (!fir.array<10xi32>, index) -> i32
-! CHECK: %[[VAL_43:.*]] = fir.array_update %[[VAL_35]], %[[VAL_42]], %[[VAL_34]] : (!fir.array<10xi32>, i32, index) -> !fir.array<10xi32>
-! CHECK: fir.result %[[VAL_43]] : !fir.array<10xi32>
+! CHECK-SAME: %[[a:.*]]: !fir.ref<!fir.array<10xi32>>{{.*}}, %[[b:.*]]: !fir.ref<!fir.array<10xi32>>{{.*}}, %[[c:.*]]: !fir.ref<!fir.array<10xi32>>{{.*}}, %[[d:.*]]: !fir.ref<!fir.array<10xi32>>{{.*}}) {
+! CHECK: %[[a_decl:.*]]:2 = hlfir.declare %[[a]]
+! CHECK: %[[b_decl:.*]]:2 = hlfir.declare %[[b]]
+! CHECK: %[[c_decl:.*]]:2 = hlfir.declare %[[c]]
+! CHECK: %[[d_decl:.*]]:2 = hlfir.declare %[[d]]
+! CHECK: %[[d_expr:.*]] = hlfir.elemental %{{.*}} unordered : (!fir.shape<1>) -> !hlfir.expr<10xi64> {
+! CHECK: fir.load
+! CHECK: fir.convert
+! CHECK: hlfir.yield_element
! CHECK: }
-! CHECK: fir.array_merge_store %[[VAL_9]], %[[VAL_44:.*]] to %[[VAL_0]] : !fir.array<10xi32>, !fir.array<10xi32>, !fir.ref<!fir.array<10xi32>>
-! CHECK: return
-! CHECK: }
+! CHECK: %[[c_expr:.*]] = hlfir.elemental %{{.*}} unordered : (!fir.shape<1>) -> !hlfir.expr<10xi32> {
+! CHECK: ^bb0(%[[idx:.*]]: index):
+! CHECK: %[[d_val:.*]] = hlfir.apply %[[d_expr]], %[[idx]]
+! CHECK: %[[c_elem:.*]] = hlfir.designate %[[c_decl]]#0 (%[[d_val]])
+! CHECK: %[[c_val:.*]] = fir.load %[[c_elem]]
+! CHECK: hlfir.yield_element %[[c_val]]
+! CHECK: }
+! CHECK: %[[c_expr_cast:.*]] = hlfir.elemental %{{.*}} unordered : (!fir.shape<1>) -> !hlfir.expr<10xi64> {
+! CHECK: fir.convert
+! CHECK: hlfir.yield_element
+! CHECK: }
+! CHECK: %[[res:.*]] = hlfir.elemental %{{.*}} unordered : (!fir.shape<1>) -> !hlfir.expr<10xi32> {
+! CHECK: ^bb0(%[[idx:.*]]: index):
+! CHECK: %[[c_val:.*]] = hlfir.apply %[[c_expr_cast]], %[[idx]]
+! CHECK: %[[b_elem:.*]] = hlfir.designate %[[b_decl]]#0 (%[[c_val]])
+! CHECK: %[[b_val:.*]] = fir.load %[[b_elem]]
+! CHECK: hlfir.yield_element %[[b_val]]
+! CHECK: }
+! CHECK: hlfir.assign %[[res]] to %[[a_decl]]#0
subroutine test2a(a,b,c,d)
integer :: a(10), b(10), c(10), d(10)
@@ -141,42 +96,37 @@ subroutine test2a(a,b,c,d)
end subroutine test2a
! CHECK-LABEL: func @_QPtest2b(
-! CHECK-SAME: %[[VAL_0:.*]]: !fir.ref<!fir.array<10xi32>>{{.*}}, %[[VAL_1:.*]]: !fir.ref<!fir.array<10xi32>>{{.*}}, %[[VAL_2:.*]]: !fir.ref<!fir.array<10xi32>>{{.*}}, %[[VAL_3:.*]]: !fir.ref<!fir.array<10xi32>>{{.*}}) {
-! CHECK: %[[VAL_4:.*]] = arith.constant 10 : index
-! CHECK: %[[VAL_5:.*]] = arith.constant 10 : index
-! CHECK: %[[VAL_6:.*]] = arith.constant 10 : index
-! CHECK: %[[VAL_7:.*]] = arith.constant 10 : index
-! CHECK: %[[VAL_8:.*]] = arith.constant 1 : index
-! CHECK: %[[VAL_9:.*]] = arith.constant 1 : index
-! CHECK: %[[VAL_10:.*]] = fir.shape %[[VAL_7]] : (index) -> !fir.shape<1>
-! CHECK: %[[VAL_11:.*]] = fir.array_load %[[VAL_3]](%[[VAL_10]]) : (!fir.ref<!fir.array<10xi32>>, !fir.shape<1>) -> !fir.array<10xi32>
-! CHECK: %[[VAL_12:.*]] = arith.cmpi sgt, %[[VAL_7]], %[[VAL_6]] : index
-! CHECK: %[[VAL_13:.*]] = arith.select %[[VAL_12]], %[[VAL_6]], %[[VAL_7]] : index
-! CHECK: %[[VAL_14:.*]] = fir.shape %[[VAL_6]] : (index) -> !fir.shape<1>
-! CHECK: %[[VAL_16:.*]] = fir.array_load %[[VAL_2]](%[[VAL_14]]) : (!fir.ref<!fir.array<10xi32>>, !fir.shape<1>) -> !fir.array<10xi32>
-! CHECK: %[[VAL_17:.*]] = arith.cmpi sgt, %[[VAL_13]], %[[VAL_5]] : index
-! CHECK: %[[VAL_18:.*]] = arith.select %[[VAL_17]], %[[VAL_5]], %[[VAL_13]] : index
-! CHECK: %[[VAL_25:.*]] = fir.shape %[[VAL_5]] : (index) -> !fir.shape<1>
-! CHECK: %[[VAL_27:.*]] = fir.array_load %[[VAL_1]](%[[VAL_25]]) : (!fir.ref<!fir.array<10xi32>>, !fir.shape<1>) -> !fir.array<10xi32>
-! CHECK: %[[VAL_28:.*]] = fir.shape %[[VAL_4]] : (index) -> !fir.shape<1>
-! CHECK: %[[VAL_29:.*]] = fir.array_load %[[VAL_0]](%[[VAL_28]]) : (!fir.ref<!fir.array<10xi32>>, !fir.shape<1>) -> !fir.array<10xi32>
-! CHECK: %[[VAL_30:.*]] = arith.constant 1 : index
-! CHECK: %[[VAL_31:.*]] = arith.constant 0 : index
-! CHECK: %[[VAL_32:.*]] = arith.subi %[[VAL_18]], %[[VAL_30]] : index
-! CHECK: %[[VAL_33:.*]] = fir.do_loop %[[VAL_34:.*]] = %[[VAL_31]] to %[[VAL_32]] step %[[VAL_30]] unordered iter_args(%[[VAL_35:.*]] = %[[VAL_27]]) -> (!fir.array<10xi32>) {
-! CHECK: %[[VAL_36:.*]] = fir.array_fetch %[[VAL_29]], %[[VAL_34]] : (!fir.array<10xi32>, index) -> i32
-! CHECK: %[[VAL_37:.*]] = fir.array_fetch %[[VAL_11]], %[[VAL_34]] : (!fir.array<10xi32>, index) -> i32
-! CHECK: %[[VAL_38:.*]] = fir.convert %[[VAL_37]] : (i32) -> index
-! CHECK: %[[VAL_39:.*]] = arith.subi %[[VAL_38]], %[[VAL_9]] : index
-! CHECK: %[[VAL_40:.*]] = fir.array_fetch %[[VAL_16]], %[[VAL_39]] : (!fir.array<10xi32>, index) -> i32
-! CHECK: %[[VAL_41:.*]] = fir.convert %[[VAL_40]] : (i32) -> index
-! CHECK: %[[VAL_42:.*]] = arith.subi %[[VAL_41]], %[[VAL_8]] : index
-! CHECK: %[[VAL_43:.*]] = fir.array_update %[[VAL_35]], %[[VAL_36]], %[[VAL_42]] : (!fir.array<10xi32>, i32, index) -> !fir.array<10xi32>
-! CHECK: fir.result %[[VAL_43]] : !fir.array<10xi32>
+! CHECK-SAME: %[[a:.*]]: !fir.ref<!fir.array<10xi32>>{{.*}}, %[[b:.*]]: !fir.ref<!fir.array<10xi32>>{{.*}}, %[[c:.*]]: !fir.ref<!fir.array<10xi32>>{{.*}}, %[[d:.*]]: !fir.ref<!fir.array<10xi32>>{{.*}}) {
+! CHECK: %[[a_decl:.*]]:2 = hlfir.declare %[[a]]
+! CHECK: %[[b_decl:.*]]:2 = hlfir.declare %[[b]]
+! CHECK: %[[c_decl:.*]]:2 = hlfir.declare %[[c]]
+! CHECK: %[[d_decl:.*]]:2 = hlfir.declare %[[d]]
+! CHECK: hlfir.region_assign {
+! CHECK: hlfir.yield %[[a_decl]]#0
+! CHECK: } to {
+! CHECK: %[[d_expr:.*]] = hlfir.elemental %{{.*}} unordered : (!fir.shape<1>) -> !hlfir.expr<10xi64> {
+! CHECK: fir.load
+! CHECK: fir.convert
+! CHECK: hlfir.yield_element
+! CHECK: }
+! CHECK: %[[c_expr:.*]] = hlfir.elemental %{{.*}} unordered : (!fir.shape<1>) -> !hlfir.expr<10xi32> {
+! CHECK: ^bb0(%[[idx:.*]]: index):
+! CHECK: %[[d_val:.*]] = hlfir.apply %[[d_expr]], %[[idx]]
+! CHECK: %[[c_elem:.*]] = hlfir.designate %[[c_decl]]#0 (%[[d_val]])
+! CHECK: %[[c_val:.*]] = fir.load %[[c_elem]]
+! CHECK: hlfir.yield_element %[[c_val]]
+! CHECK: }
+! CHECK: %[[c_expr_cast:.*]] = hlfir.elemental %{{.*}} unordered : (!fir.shape<1>) -> !hlfir.expr<10xi64> {
+! CHECK: fir.convert
+! CHECK: hlfir.yield_element
+! CHECK: }
+! CHECK: hlfir.elemental_addr %{{.*}} unordered : !fir.shape<1> {
+! CHECK: ^bb0(%[[idx:.*]]: index):
+! CHECK: %[[c_val:.*]] = hlfir.apply %[[c_expr_cast]], %[[idx]]
+! CHECK: %[[b_elem:.*]] = hlfir.designate %[[b_decl]]#0 (%[[c_val]])
+! CHECK: hlfir.yield %[[b_elem]]
+! CHECK: }
! CHECK: }
-! CHECK: fir.array_merge_store %[[VAL_27]], %[[VAL_44:.*]] to %[[VAL_1]] : !fir.array<10xi32>, !fir.array<10xi32>, !fir.ref<!fir.array<10xi32>>
-! CHECK: return
-! CHECK: }
subroutine test2b(a,b,c,d)
integer :: a(10), b(10), c(10), d(10)
diff --git a/flang/test/Lower/array-substring.f90 b/flang/test/Lower/array-substring.f90
index 0ede04f0bb2f8..60015de5b07c8 100644
--- a/flang/test/Lower/array-substring.f90
+++ b/flang/test/Lower/array-substring.f90
@@ -1,46 +1,27 @@
-! RUN: bbc -hlfir=false %s -o - | FileCheck %s
-! RUN: bbc -hlfir=false -fwrapv %s -o - | FileCheck %s --check-prefix=NO-NSW
+! RUN: bbc -emit-hlfir %s -o - | FileCheck %s
+! RUN: bbc -emit-hlfir -fwrapv %s -o - | FileCheck %s --check-prefix=NO-NSW
! NO-NSW-NOT: overflow<nsw>
! CHECK-LABEL: func @_QPtest(
-! CHECK-SAME: %[[VAL_0:.*]]: !fir.boxchar<1>{{.*}}) -> !fir.array<1x!fir.logical<4>> {
-! CHECK-DAG: %[[VAL_1:.*]] = arith.constant 1 : index
-! CHECK-DAG: %[[VAL_2:.*]] = arith.constant 0 : index
-! CHECK-DAG: %[[VAL_3:.*]] = arith.constant 0 : i32
-! CHECK-DAG: %[[VAL_4:.*]] = arith.constant 8 : index
-! CHECK: %[[VAL_6:.*]]:2 = fir.unboxchar %[[VAL_0]] : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1,?>>, index)
-! CHECK: %[[VAL_7:.*]] = fir.convert %[[VAL_6]]#0 : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<!fir.array<1x!fir.char<1,12>>>
-! CHECK: %[[VAL_8:.*]] = fir.alloca !fir.array<1x!fir.logical<4>> {bindc_name = "test", uniq_name = "_QFtestEtest"}
-! CHECK: %[[VAL_9:.*]] = fir.shape %[[VAL_1]] : (index) -> !fir.shape<1>
-! CHECK: %[[VAL_10:.*]] = fir.slice %[[VAL_1]], %[[VAL_1]], %[[VAL_1]] : (index, index, index) -> !fir.slice<1>
-! CHECK: %[[VAL_11:.*]] = fir.address_of(@_QQ{{.*}}) : !fir.ref<!fir.array<1x!fir.char<1,8>>>
-! CHECK: br ^bb1(%[[VAL_2]], %[[VAL_1]] : index, index)
-! CHECK: ^bb1(%[[VAL_12:.*]]: index, %[[VAL_13:.*]]: index):
-! CHECK: %[[VAL_14:.*]] = arith.cmpi sgt, %[[VAL_13]], %[[VAL_2]] : index
-! CHECK: cond_br %[[VAL_14]], ^bb2, ^bb3
-! CHECK: ^bb2:
-! CHECK: %[[VAL_15:.*]] = arith.addi %[[VAL_12]], %[[VAL_1]] : index
-! CHECK: %[[VAL_16:.*]] = fir.array_coor %[[VAL_7]](%[[VAL_9]]) {{\[}}%[[VAL_10]]] %[[VAL_15]] : (!fir.ref<!fir.array<1x!fir.char<1,12>>>, !fir.shape<1>, !fir.slice<1>, index) -> !fir.ref<!fir.char<1,12>>
-! CHECK: %[[VAL_17:.*]] = fir.convert %[[VAL_16]] : (!fir.ref<!fir.char<1,12>>) -> !fir.ref<!fir.array<12x!fir.char<1>>>
-! CHECK: %[[VAL_18:.*]] = fir.coordinate_of %[[VAL_17]], %[[VAL_2]] : (!fir.ref<!fir.array<12x!fir.char<1>>>, index) -> !fir.ref<!fir.char<1>>
-! CHECK: %[[VAL_20:.*]] = fir.array_coor %[[VAL_11]](%[[VAL_9]]) %[[VAL_15]] : (!fir.ref<!fir.array<1x!fir.char<1,8>>>, !fir.shape<1>, index) -> !fir.ref<!fir.char<1,8>>
-! CHECK: %[[VAL_21:.*]] = fir.convert %[[VAL_18]] : (!fir.ref<!fir.char<1>>) -> !fir.ref<i8>
-! CHECK: %[[VAL_22:.*]] = fir.convert %[[VAL_20]] : (!fir.ref<!fir.char<1,8>>) -> !fir.ref<i8>
-! CHECK: %[[VAL_23:.*]] = fir.convert %[[VAL_4]] : (index) -> i64
-! CHECK: %[[VAL_24:.*]] = fir.call @_FortranACharacterCompareScalar1(%[[VAL_21]], %[[VAL_22]], %[[VAL_23]], %[[VAL_23]]) {{.*}}: (!fir.ref<i8>, !fir.ref<i8>, i64, i64) -> i32
-! CHECK: %[[VAL_25:.*]] = arith.cmpi eq, %[[VAL_24]], %[[VAL_3]] : i32
-! CHECK: %[[VAL_26:.*]] = fir.convert %[[VAL_25]] : (i1) -> !fir.logical<4>
-! CHECK: %[[VAL_27:.*]] = fir.array_coor %[[VAL_8]](%[[VAL_9]]) %[[VAL_15]] : (!fir.ref<!fir.array<1x!fir.logical<4>>>, !fir.shape<1>, index) -> !fir.ref<!fir.logical<4>>
-! CHECK: fir.store %[[VAL_26]] to %[[VAL_27]] : !fir.ref<!fir.logical<4>>
-! CHECK: %[[VAL_15_NSW:.*]] = arith.addi %[[VAL_12]], %[[VAL_1]] overflow<nsw> : index
-! CHECK: %[[VAL_28:.*]] = arith.subi %[[VAL_13]], %[[VAL_1]] : index
-! CHECK: br ^bb1(%[[VAL_15_NSW]], %[[VAL_28]] : index, index)
-! CHECK: ^bb3:
-! CHECK: %[[VAL_29:.*]] = fir.load %[[VAL_8]] : !fir.ref<!fir.array<1x!fir.logical<4>>>
-! CHECK: return %[[VAL_29]] : !fir.array<1x!fir.logical<4>>
-! CHECK: }
-
+! CHECK-SAME: %[[arg0:.*]]: !fir.boxchar<1>{{.*}}) -> !fir.array<1x!fir.logical<4>> {
+! CHECK: %[[unbox:.*]]:2 = fir.unboxchar %[[arg0]]
+! CHECK: %[[addr:.*]] = fir.convert %[[unbox]]#0
+! CHECK: %[[c:.*]]:2 = hlfir.declare %[[addr]](%{{.*}}) typeparams %{{.*}}
+! CHECK: %[[test:.*]]:2 = hlfir.declare %{{.*}} {uniq_name = "_QFtestEtest"}
+! CHECK: %[[slice:.*]] = hlfir.designate %[[c]]#0 (%c1{{.*}}:%c1{{.*}}:%c1{{.*}}) substr %c1{{.*}}, %c8{{.*}}
+! CHECK: %[[const:.*]]:2 = hlfir.declare %{{.*}} {fortran_attrs = #fir.var_attrs<parameter>, uniq_name = "_QQro.1x8xc1.0"}
+! CHECK: %[[res:.*]] = hlfir.elemental %{{.*}} unordered : (!fir.shape<1>) -> !hlfir.expr<1x!fir.logical<4>> {
+! CHECK: ^bb0(%[[idx:.*]]: index):
+! CHECK: %[[lhs_addr:.*]] = hlfir.designate %[[slice]] (%[[idx]])
+! CHECK: %[[rhs_addr:.*]] = hlfir.designate %[[const]]#0 (%[[idx]])
+! CHECK: %[[cmp:.*]] = hlfir.cmpchar eq %[[lhs_addr]] %[[rhs_addr]]
+! CHECK: %[[cast:.*]] = fir.convert %[[cmp]]
+! CHECK: hlfir.yield_element %[[cast]]
+! CHECK: }
+! CHECK: hlfir.assign %[[res]] to %[[test]]#0
+! CHECK: %[[ret:.*]] = fir.load %[[test]]#0
+! CHECK: return %[[ret]]
function test(C)
logical :: test(1)
More information about the flang-commits
mailing list