[flang-commits] [flang] 1422181 - [flang][NFC] Converted five tests from old lowering to new lowering (part 20) (#182997)
via flang-commits
flang-commits at lists.llvm.org
Tue Feb 24 06:39:34 PST 2026
Author: Eugene Epshteyn
Date: 2026-02-24T09:39:28-05:00
New Revision: 142218186d9c56165b7710e2b2ead2fe02482b15
URL: https://github.com/llvm/llvm-project/commit/142218186d9c56165b7710e2b2ead2fe02482b15
DIFF: https://github.com/llvm/llvm-project/commit/142218186d9c56165b7710e2b2ead2fe02482b15.diff
LOG: [flang][NFC] Converted five tests from old lowering to new lowering (part 20) (#182997)
Tests converted from test/Lower/forall: forall-where.f90,
forall-where-2.f90, test9.f90.
Tests converted from test/Lower: host-associated-functions.f90,
host-associated.f90
Added:
Modified:
flang/test/Lower/forall/forall-where-2.f90
flang/test/Lower/forall/forall-where.f90
flang/test/Lower/forall/test9.f90
flang/test/Lower/host-associated-functions.f90
flang/test/Lower/host-associated.f90
Removed:
################################################################################
diff --git a/flang/test/Lower/forall/forall-where-2.f90 b/flang/test/Lower/forall/forall-where-2.f90
index 85aab87559c3c..02119734397a1 100644
--- a/flang/test/Lower/forall/forall-where-2.f90
+++ b/flang/test/Lower/forall/forall-where-2.f90
@@ -1,7 +1,6 @@
! Test forall lowering
-! RUN: bbc -emit-fir -hlfir=false %s -o - | FileCheck %s
-
+! RUN: %flang_fc1 -emit-hlfir %s -o - | FileCheck %s
! Test a FORALL construct with a nested WHERE construct where the mask
! contains temporary array expressions.
@@ -26,51 +25,38 @@ function temp_foo(i, j)
end forall
end subroutine
-! CHECK: func @_QPtest_nested_forall_where_with_temp_in_mask({{.*}}) {
+! CHECK-LABEL: func.func @_QPtest_nested_forall_where_with_temp_in_mask({{.*}}) {
! CHECK: %[[tempResultBox:.*]] = fir.alloca !fir.box<!fir.heap<!fir.array<?xf32>>> {bindc_name = ".result"}
- ! Where condition pre-evaluation
-! CHECK: fir.do_loop {{.*}} {
-! CHECK: fir.do_loop {{.*}} {
- ! Evaluation of mask for iteration (i,j) into ragged array temp
-! CHECK: %[[tempResult:.*]] = fir.call @_QPtemp_foo
-! CHECK: fir.save_result %[[tempResult]] to %[[tempResultBox]] : !fir.box<!fir.heap<!fir.array<?xf32>>>, !fir.ref<!fir.box<!fir.heap<!fir.array<?xf32>>>>
-! CHECK: fir.if {{.*}} {
-! CHECK: @_FortranARaggedArrayAllocate
-! CHECK: }
-! CHECK: fir.do_loop {{.*}} {
- ! store into ragged array temp element
-! CHECK: }
-! CHECK: %[[box:.*]] = fir.load %[[tempResultBox]] : !fir.ref<!fir.box<!fir.heap<!fir.array<?xf32>>>>
-! CHECK: %[[tempAddr:.*]] = fir.box_addr %[[box]] : (!fir.box<!fir.heap<!fir.array<?xf32>>>) -> !fir.heap<!fir.array<?xf32>>
- ! local temps that were generated during the evaluation are cleaned-up after the value were stored
- ! into the ragged array temp.
-! CHECK: fir.freemem %[[tempAddr]] : !fir.heap<!fir.array<?xf32>>
-! CHECK: }
-! CHECK: }
- ! Where assignment
-! CHECK: fir.do_loop {{.*}} {
-! CHECK: fir.do_loop {{.*}} {
- ! Array assignment at iteration (i, j)
-! CHECK: fir.do_loop {{.*}} {
-! CHECK: fir.if {{.*}} {
-! CHECK: arith.divf
-! CHECK: } else {
-! CHECK: }
-! CHECK: }
-! CHECK: }
-! CHECK: }
- ! Elsewhere assignment
-! CHECK: fir.do_loop {{.*}} {
-! CHECK: fir.do_loop {{.*}} {
- ! Array assignment at iteration (i, j)
-! CHECK: fir.do_loop {{.*}} {
-! CHECK: fir.if {{.*}} {
-! CHECK: } else {
-! CHECK: arith.negf
-! CHECK: }
-! CHECK: }
-! CHECK: }
-! CHECK: }
- ! Ragged array clean-up
-! CHECK: fir.call @_FortranARaggedArrayDeallocate
-! CHECK: }
+! CHECK: hlfir.forall
+! CHECK: (%[[arg2:.*]]: i32) {
+! CHECK: %[[i:.*]] = hlfir.forall_index "i" %[[arg2]] : (i32) -> !fir.ref<i32>
+! CHECK: hlfir.forall
+! CHECK: (%[[arg3:.*]]: i32) {
+! CHECK: %[[j:.*]] = hlfir.forall_index "j" %[[arg3]] : (i32) -> !fir.ref<i32>
+! CHECK: hlfir.where {
+! CHECK: %[[tempResult:.*]] = fir.call @_QPtemp_foo(%[[i]], %[[j]])
+! CHECK: fir.save_result %[[tempResult]] to {{.*}}
+! CHECK: %[[mask:.*]] = hlfir.elemental {{.*}} {
+! CHECK: arith.cmpf ogt, {{.*}}
+! CHECK: }
+! CHECK: hlfir.yield %[[mask]]
+! CHECK: } do {
+! CHECK: hlfir.region_assign {
+! CHECK: %[[res:.*]] = hlfir.elemental {{.*}} {
+! CHECK: arith.divf {{.*}}
+! CHECK: }
+! CHECK: hlfir.yield %[[res]]
+! CHECK: } to {
+! CHECK: }
+! CHECK: hlfir.elsewhere do {
+! CHECK: hlfir.region_assign {
+! CHECK: %[[res:.*]] = hlfir.elemental {{.*}} {
+! CHECK: arith.negf {{.*}}
+! CHECK: }
+! CHECK: hlfir.yield %[[res]]
+! CHECK: } to {
+! CHECK: }
+! CHECK: }
+! CHECK: }
+! CHECK: }
+! CHECK: }
diff --git a/flang/test/Lower/forall/forall-where.f90 b/flang/test/Lower/forall/forall-where.f90
index 3202edbaec808..f20497dcb4d30 100644
--- a/flang/test/Lower/forall/forall-where.f90
+++ b/flang/test/Lower/forall/forall-where.f90
@@ -1,6 +1,6 @@
! Test forall lowering
-! RUN: bbc -emit-fir -hlfir=false %s -o - | FileCheck %s
+! RUN: %flang_fc1 -emit-hlfir %s -o - | FileCheck %s
!*** Test a FORALL construct with a nested WHERE construct.
! This has both an explicit and implicit iteration space. The WHERE construct
@@ -20,365 +20,34 @@ subroutine test_nested_forall_where(a,b)
end forall
end subroutine test_nested_forall_where
-! CHECK-LABEL: func @_QPtest_nested_forall_where(
-! CHECK-SAME: %[[VAL_0:.*]]: !fir.box<!fir.array<?x?x!fir.type<_QFtest_nested_forall_whereTt{data:!fir.array<100xf32>}>>>{{.*}}, %[[VAL_1:.*]]: !fir.box<!fir.array<?x?x!fir.type<_QFtest_nested_forall_whereTt{data:!fir.array<100xf32>}>>>{{.*}}) {
-! CHECK: %[[VAL_2:.*]] = fir.alloca i32 {adapt.valuebyref, bindc_name = "j"}
-! CHECK: %[[VAL_3:.*]] = fir.alloca i32 {adapt.valuebyref, bindc_name = "i"}
-! CHECK: %[[VAL_4:.*]] = fir.alloca i32 {adapt.valuebyref, bindc_name = "j"}
-! CHECK: %[[VAL_5:.*]] = fir.alloca i32 {adapt.valuebyref, bindc_name = "i"}
-! CHECK: %[[VAL_6:.*]] = fir.alloca i32 {adapt.valuebyref, bindc_name = "j"}
-! CHECK: %[[VAL_7:.*]] = fir.alloca i32 {adapt.valuebyref, bindc_name = "i"}
-! CHECK: %[[VAL_8:.*]] = fir.alloca tuple<i64, !fir.heap<!fir.array<?xi8>>, !fir.heap<!fir.array<?xi64>>>
-! CHECK: %[[VAL_9:.*]] = arith.constant 0 : i32
-! CHECK: %[[VAL_10:.*]] = arith.constant 0 : i64
-! CHECK: %[[VAL_11:.*]] = fir.coordinate_of %[[VAL_8]], %[[VAL_9]] : (!fir.ref<tuple<i64, !fir.heap<!fir.array<?xi8>>, !fir.heap<!fir.array<?xi64>>>>, i32) -> !fir.ref<i64>
-! CHECK: fir.store %[[VAL_10]] to %[[VAL_11]] : !fir.ref<i64>
-! CHECK: %[[VAL_12:.*]] = arith.constant 1 : i32
-! CHECK: %[[VAL_13:.*]] = fir.zero_bits !fir.heap<!fir.array<?xi8>>
-! CHECK: %[[VAL_14:.*]] = fir.coordinate_of %[[VAL_8]], %[[VAL_12]] : (!fir.ref<tuple<i64, !fir.heap<!fir.array<?xi8>>, !fir.heap<!fir.array<?xi64>>>>, i32) -> !fir.ref<!fir.heap<!fir.array<?xi8>>>
-! CHECK: fir.store %[[VAL_13]] to %[[VAL_14]] : !fir.ref<!fir.heap<!fir.array<?xi8>>>
-! CHECK: %[[VAL_15:.*]] = arith.constant 2 : i32
-! CHECK: %[[VAL_16:.*]] = fir.zero_bits !fir.heap<!fir.array<?xi64>>
-! CHECK: %[[VAL_17:.*]] = fir.coordinate_of %[[VAL_8]], %[[VAL_15]] : (!fir.ref<tuple<i64, !fir.heap<!fir.array<?xi8>>, !fir.heap<!fir.array<?xi64>>>>, i32) -> !fir.ref<!fir.heap<!fir.array<?xi64>>>
-! CHECK: fir.store %[[VAL_16]] to %[[VAL_17]] : !fir.ref<!fir.heap<!fir.array<?xi64>>>
-! CHECK: %[[VAL_18:.*]] = arith.constant 1 : i32
-! CHECK: %[[VAL_19:.*]] = fir.convert %[[VAL_18]] : (i32) -> index
-! CHECK: %[[VAL_20:.*]] = arith.constant 0 : index
-! CHECK: %[[VAL_21:.*]]:3 = fir.box_dims %[[VAL_0]], %[[VAL_20]] : (!fir.box<!fir.array<?x?x!fir.type<_QFtest_nested_forall_whereTt{data:!fir.array<100xf32>}>>>, index) -> (index, index, index)
-! CHECK: %[[VAL_22:.*]] = fir.convert %[[VAL_21]]#1 : (index) -> i64
-! CHECK: %[[VAL_23:.*]] = arith.constant 1 : index
-! CHECK: %[[VAL_24:.*]] = fir.convert %[[VAL_23]] : (index) -> i64
-! CHECK: %[[VAL_25:.*]] = arith.addi %[[VAL_22]], %[[VAL_24]] : i64
-! CHECK: %[[VAL_26:.*]] = arith.constant 1 : i64
-! CHECK: %[[VAL_27:.*]] = arith.subi %[[VAL_25]], %[[VAL_26]] : i64
-! CHECK: %[[VAL_28:.*]] = fir.convert %[[VAL_27]] : (i64) -> i32
-! CHECK: %[[VAL_29:.*]] = fir.convert %[[VAL_28]] : (i32) -> index
-! CHECK: %[[VAL_30:.*]] = arith.constant 1 : index
-! CHECK: %[[VAL_31:.*]] = arith.constant 1 : i32
-! CHECK: %[[VAL_32:.*]] = fir.convert %[[VAL_31]] : (i32) -> index
-! CHECK: %[[VAL_33:.*]] = arith.constant 1 : index
-! CHECK: %[[VAL_34:.*]]:3 = fir.box_dims %[[VAL_0]], %[[VAL_33]] : (!fir.box<!fir.array<?x?x!fir.type<_QFtest_nested_forall_whereTt{data:!fir.array<100xf32>}>>>, index) -> (index, index, index)
-! CHECK: %[[VAL_35:.*]] = fir.convert %[[VAL_34]]#1 : (index) -> i64
-! CHECK: %[[VAL_36:.*]] = arith.constant 1 : index
-! CHECK: %[[VAL_37:.*]] = fir.convert %[[VAL_36]] : (index) -> i64
-! CHECK: %[[VAL_38:.*]] = arith.addi %[[VAL_35]], %[[VAL_37]] : i64
-! CHECK: %[[VAL_39:.*]] = arith.constant 1 : i64
-! CHECK: %[[VAL_40:.*]] = arith.subi %[[VAL_38]], %[[VAL_39]] : i64
-! CHECK: %[[VAL_41:.*]] = fir.convert %[[VAL_40]] : (i64) -> i32
-! CHECK: %[[VAL_42:.*]] = fir.convert %[[VAL_41]] : (i32) -> index
-! CHECK: %[[VAL_43:.*]] = arith.constant 1 : index
-! CHECK: %[[VAL_44:.*]] = fir.array_load %[[VAL_0]] : (!fir.box<!fir.array<?x?x!fir.type<_QFtest_nested_forall_whereTt{data:!fir.array<100xf32>}>>>) -> !fir.array<?x?x!fir.type<_QFtest_nested_forall_whereTt{data:!fir.array<100xf32>}>>
-! CHECK: %[[VAL_45:.*]] = fir.array_load %[[VAL_1]] : (!fir.box<!fir.array<?x?x!fir.type<_QFtest_nested_forall_whereTt{data:!fir.array<100xf32>}>>>) -> !fir.array<?x?x!fir.type<_QFtest_nested_forall_whereTt{data:!fir.array<100xf32>}>>
-! CHECK: %[[VAL_46:.*]] = fir.do_loop %[[VAL_47:.*]] = %[[VAL_19]] to %[[VAL_29]] step %[[VAL_30]] unordered iter_args(%[[VAL_48:.*]] = %[[VAL_44]]) -> (!fir.array<?x?x!fir.type<_QFtest_nested_forall_whereTt{data:!fir.array<100xf32>}>>) {
-! CHECK: %[[VAL_49:.*]] = fir.convert %[[VAL_47]] : (index) -> i32
-! CHECK: fir.store %[[VAL_49]] to %[[VAL_7]] : !fir.ref<i32>
-! CHECK: %[[VAL_50:.*]] = fir.do_loop %[[VAL_51:.*]] = %[[VAL_32]] to %[[VAL_42]] step %[[VAL_43]] unordered iter_args(%[[VAL_52:.*]] = %[[VAL_48]]) -> (!fir.array<?x?x!fir.type<_QFtest_nested_forall_whereTt{data:!fir.array<100xf32>}>>) {
-! CHECK: %[[VAL_53:.*]] = fir.convert %[[VAL_51]] : (index) -> i32
-! CHECK: fir.store %[[VAL_53]] to %[[VAL_6]] : !fir.ref<i32>
-! CHECK: %[[VAL_54:.*]] = arith.constant 1 : i64
-! CHECK: %[[VAL_55:.*]] = arith.constant 0 : i64
-! CHECK: %[[VAL_56:.*]] = fir.convert %[[VAL_19]] : (index) -> i64
-! CHECK: %[[VAL_57:.*]] = fir.convert %[[VAL_29]] : (index) -> i64
-! CHECK: %[[VAL_58:.*]] = fir.convert %[[VAL_30]] : (index) -> i64
-! CHECK: %[[VAL_59:.*]] = arith.subi %[[VAL_57]], %[[VAL_56]] : i64
-! CHECK: %[[VAL_60:.*]] = arith.addi %[[VAL_59]], %[[VAL_58]] : i64
-! CHECK: %[[VAL_61:.*]] = arith.divsi %[[VAL_60]], %[[VAL_58]] : i64
-! CHECK: %[[VAL_62:.*]] = arith.cmpi sgt, %[[VAL_61]], %[[VAL_55]] : i64
-! CHECK: %[[VAL_63:.*]] = arith.select %[[VAL_62]], %[[VAL_61]], %[[VAL_55]] : i64
-! CHECK: %[[VAL_64:.*]] = arith.constant 0 : i64
-! CHECK: %[[VAL_65:.*]] = fir.convert %[[VAL_32]] : (index) -> i64
-! CHECK: %[[VAL_66:.*]] = fir.convert %[[VAL_42]] : (index) -> i64
-! CHECK: %[[VAL_67:.*]] = fir.convert %[[VAL_43]] : (index) -> i64
-! CHECK: %[[VAL_68:.*]] = arith.subi %[[VAL_66]], %[[VAL_65]] : i64
-! CHECK: %[[VAL_69:.*]] = arith.addi %[[VAL_68]], %[[VAL_67]] : i64
-! CHECK: %[[VAL_70:.*]] = arith.divsi %[[VAL_69]], %[[VAL_67]] : i64
-! CHECK: %[[VAL_71:.*]] = arith.cmpi sgt, %[[VAL_70]], %[[VAL_64]] : i64
-! CHECK: %[[VAL_72:.*]] = arith.select %[[VAL_71]], %[[VAL_70]], %[[VAL_64]] : i64
-! CHECK: %[[VAL_73:.*]] = arith.constant 1 : i32
-! CHECK: %[[VAL_74:.*]] = fir.coordinate_of %[[VAL_8]], %[[VAL_73]] : (!fir.ref<tuple<i64, !fir.heap<!fir.array<?xi8>>, !fir.heap<!fir.array<?xi64>>>>, i32) -> !fir.ref<!fir.heap<!fir.array<?xi8>>>
-! CHECK: %[[VAL_75:.*]] = fir.load %[[VAL_74]] : !fir.ref<!fir.heap<!fir.array<?xi8>>>
-! CHECK: %[[VAL_76:.*]] = fir.convert %[[VAL_75]] : (!fir.heap<!fir.array<?xi8>>) -> i64
-! CHECK: %[[VAL_77:.*]] = arith.constant 0 : i64
-! CHECK: %[[VAL_78:.*]] = arith.cmpi eq, %[[VAL_76]], %[[VAL_77]] : i64
-! CHECK: fir.if %[[VAL_78]] {
-! CHECK: %[[VAL_79:.*]] = arith.constant true
-! CHECK: %[[VAL_80:.*]] = arith.constant 2 : i64
-! CHECK: %[[VAL_81:.*]] = fir.allocmem !fir.array<2xi64>
-! CHECK: %[[VAL_82:.*]] = arith.constant 0 : i32
-! CHECK: %[[VAL_83:.*]] = fir.coordinate_of %[[VAL_81]], %[[VAL_82]] : (!fir.heap<!fir.array<2xi64>>, i32) -> !fir.ref<i64>
-! CHECK: fir.store %[[VAL_63]] to %[[VAL_83]] : !fir.ref<i64>
-! CHECK: %[[VAL_84:.*]] = arith.constant 1 : i32
-! CHECK: %[[VAL_85:.*]] = fir.coordinate_of %[[VAL_81]], %[[VAL_84]] : (!fir.heap<!fir.array<2xi64>>, i32) -> !fir.ref<i64>
-! CHECK: fir.store %[[VAL_72]] to %[[VAL_85]] : !fir.ref<i64>
-! CHECK: %[[VAL_86:.*]] = fir.convert %[[VAL_8]] : (!fir.ref<tuple<i64, !fir.heap<!fir.array<?xi8>>, !fir.heap<!fir.array<?xi64>>>>) -> !fir.llvm_ptr<i8>
-! CHECK: %[[VAL_87:.*]] = fir.convert %[[VAL_81]] : (!fir.heap<!fir.array<2xi64>>) -> !fir.ref<i64>
-! CHECK: %[[VAL_88:.*]] = fir.call @_FortranARaggedArrayAllocate(%[[VAL_86]], %[[VAL_79]], %[[VAL_80]], %[[VAL_54]], %[[VAL_87]]) {{.*}}: (!fir.llvm_ptr<i8>, i1, i64, i64, !fir.ref<i64>) -> !fir.llvm_ptr<i8>
-! CHECK: }
-! CHECK: %[[VAL_89:.*]] = arith.subi %[[VAL_47]], %[[VAL_19]] : index
-! CHECK: %[[VAL_90:.*]] = arith.divsi %[[VAL_89]], %[[VAL_30]] : index
-! CHECK: %[[VAL_91:.*]] = arith.constant 1 : index
-! CHECK: %[[VAL_92:.*]] = arith.addi %[[VAL_90]], %[[VAL_91]] : index
-! CHECK: %[[VAL_93:.*]] = arith.subi %[[VAL_51]], %[[VAL_32]] : index
-! CHECK: %[[VAL_94:.*]] = arith.divsi %[[VAL_93]], %[[VAL_43]] : index
-! CHECK: %[[VAL_95:.*]] = arith.constant 1 : index
-! CHECK: %[[VAL_96:.*]] = arith.addi %[[VAL_94]], %[[VAL_95]] : index
-! CHECK: %[[VAL_97:.*]] = arith.constant 1 : i32
-! CHECK: %[[VAL_98:.*]] = fir.coordinate_of %[[VAL_8]], %[[VAL_97]] : (!fir.ref<tuple<i64, !fir.heap<!fir.array<?xi8>>, !fir.heap<!fir.array<?xi64>>>>, i32) -> !fir.ref<!fir.heap<!fir.array<?xi8>>>
-! CHECK: %[[VAL_99:.*]] = fir.load %[[VAL_98]] : !fir.ref<!fir.heap<!fir.array<?xi8>>>
-! CHECK: %[[VAL_100:.*]] = fir.convert %[[VAL_99]] : (!fir.heap<!fir.array<?xi8>>) -> !fir.ref<!fir.array<?x?xtuple<i64, !fir.heap<!fir.array<?xi8>>, !fir.heap<!fir.array<?xi64>>>>>
-! CHECK: %[[VAL_101:.*]] = fir.shape %[[VAL_63]], %[[VAL_72]] : (i64, i64) -> !fir.shape<2>
-! CHECK: %[[VAL_102:.*]] = fir.array_coor %[[VAL_100]](%[[VAL_101]]) %[[VAL_92]], %[[VAL_96]] : (!fir.ref<!fir.array<?x?xtuple<i64, !fir.heap<!fir.array<?xi8>>, !fir.heap<!fir.array<?xi64>>>>>, !fir.shape<2>, index, index) -> !fir.ref<tuple<i64, !fir.heap<!fir.array<?xi8>>, !fir.heap<!fir.array<?xi64>>>>
-! CHECK: %[[VAL_103:.*]] = fir.load %[[VAL_6]] : !fir.ref<i32>
-! CHECK: %[[VAL_104:.*]] = fir.convert %[[VAL_103]] : (i32) -> i64
-! CHECK: %[[VAL_105:.*]] = arith.constant 1 : i64
-! CHECK: %[[VAL_106:.*]] = arith.subi %[[VAL_104]], %[[VAL_105]] : i64
-! CHECK: %[[VAL_107:.*]] = fir.load %[[VAL_7]] : !fir.ref<i32>
-! CHECK: %[[VAL_108:.*]] = fir.convert %[[VAL_107]] : (i32) -> i64
-! CHECK: %[[VAL_109:.*]] = arith.constant 1 : i64
-! CHECK: %[[VAL_110:.*]] = arith.subi %[[VAL_108]], %[[VAL_109]] : i64
-! CHECK: %[[VAL_111:.*]] = fir.coordinate_of %[[VAL_1]], %[[VAL_106]], %[[VAL_110]] : (!fir.box<!fir.array<?x?x!fir.type<_QFtest_nested_forall_whereTt{data:!fir.array<100xf32>}>>>, i64, i64) -> !fir.ref<!fir.type<_QFtest_nested_forall_whereTt{data:!fir.array<100xf32>}>>
-! CHECK: %[[VAL_113:.*]] = fir.coordinate_of %[[VAL_111]], data : (!fir.ref<!fir.type<_QFtest_nested_forall_whereTt{data:!fir.array<100xf32>}>>) -> !fir.ref<!fir.array<100xf32>>
-! CHECK: %[[VAL_114:.*]] = arith.constant 100 : index
-! CHECK: %[[VAL_115:.*]] = fir.shape %[[VAL_114]] : (index) -> !fir.shape<1>
-! CHECK: %[[VAL_116:.*]] = fir.array_load %[[VAL_113]](%[[VAL_115]]) : (!fir.ref<!fir.array<100xf32>>, !fir.shape<1>) -> !fir.array<100xf32>
-! CHECK: %[[VAL_117:.*]] = arith.constant 0.000000e+00 : f32
-! CHECK: %[[VAL_118:.*]] = arith.constant 1 : i32
-! CHECK: %[[VAL_119:.*]] = fir.coordinate_of %[[VAL_102]], %[[VAL_118]] : (!fir.ref<tuple<i64, !fir.heap<!fir.array<?xi8>>, !fir.heap<!fir.array<?xi64>>>>, i32) -> !fir.ref<!fir.heap<!fir.array<?xi8>>>
-! CHECK: %[[VAL_120:.*]] = fir.load %[[VAL_119]] : !fir.ref<!fir.heap<!fir.array<?xi8>>>
-! CHECK: %[[VAL_121:.*]] = fir.shape %[[VAL_114]] : (index) -> !fir.shape<1>
-! CHECK: %[[VAL_122:.*]] = fir.array_load %[[VAL_120]](%[[VAL_121]]) : (!fir.heap<!fir.array<?xi8>>, !fir.shape<1>) -> !fir.array<?xi8>
-! CHECK: %[[VAL_123:.*]] = arith.constant 1 : i64
-! CHECK: %[[VAL_124:.*]] = arith.constant 1 : i32
-! CHECK: %[[VAL_125:.*]] = fir.coordinate_of %[[VAL_102]], %[[VAL_124]] : (!fir.ref<tuple<i64, !fir.heap<!fir.array<?xi8>>, !fir.heap<!fir.array<?xi64>>>>, i32) -> !fir.ref<!fir.heap<!fir.array<?xi8>>>
-! CHECK: %[[VAL_126:.*]] = fir.load %[[VAL_125]] : !fir.ref<!fir.heap<!fir.array<?xi8>>>
-! CHECK: %[[VAL_127:.*]] = fir.convert %[[VAL_126]] : (!fir.heap<!fir.array<?xi8>>) -> i64
-! CHECK: %[[VAL_128:.*]] = arith.constant 0 : i64
-! CHECK: %[[VAL_129:.*]] = arith.cmpi eq, %[[VAL_127]], %[[VAL_128]] : i64
-! CHECK: fir.if %[[VAL_129]] {
-! CHECK: %[[VAL_130:.*]] = arith.constant false
-! CHECK: %[[VAL_131:.*]] = arith.constant 1 : i64
-! CHECK: %[[VAL_132:.*]] = fir.allocmem !fir.array<1xi64>
-! CHECK: %[[VAL_133:.*]] = arith.constant 0 : i32
-! CHECK: %[[VAL_134:.*]] = fir.coordinate_of %[[VAL_132]], %[[VAL_133]] : (!fir.heap<!fir.array<1xi64>>, i32) -> !fir.ref<i64>
-! CHECK: %[[VAL_135:.*]] = fir.convert %[[VAL_114]] : (index) -> i64
-! CHECK: fir.store %[[VAL_135]] to %[[VAL_134]] : !fir.ref<i64>
-! CHECK: %[[VAL_136:.*]] = fir.convert %[[VAL_102]] : (!fir.ref<tuple<i64, !fir.heap<!fir.array<?xi8>>, !fir.heap<!fir.array<?xi64>>>>) -> !fir.llvm_ptr<i8>
-! CHECK: %[[VAL_137:.*]] = fir.convert %[[VAL_132]] : (!fir.heap<!fir.array<1xi64>>) -> !fir.ref<i64>
-! CHECK: %[[VAL_138:.*]] = fir.call @_FortranARaggedArrayAllocate(%[[VAL_136]], %[[VAL_130]], %[[VAL_131]], %[[VAL_123]], %[[VAL_137]]) {{.*}}: (!fir.llvm_ptr<i8>, i1, i64, i64, !fir.ref<i64>) -> !fir.llvm_ptr<i8>
-! CHECK: }
-! CHECK: %[[VAL_139:.*]] = arith.constant 1 : index
-! CHECK: %[[VAL_140:.*]] = arith.constant 0 : index
-! CHECK: %[[VAL_141:.*]] = arith.subi %[[VAL_114]], %[[VAL_139]] : index
-! CHECK: %[[VAL_142:.*]] = fir.do_loop %[[VAL_143:.*]] = %[[VAL_140]] to %[[VAL_141]] step %[[VAL_139]] unordered iter_args(%[[VAL_144:.*]] = %[[VAL_122]]) -> (!fir.array<?xi8>) {
-! CHECK: %[[VAL_145:.*]] = fir.array_fetch %[[VAL_116]], %[[VAL_143]] : (!fir.array<100xf32>, index) -> f32
-! CHECK: %[[VAL_146:.*]] = arith.cmpf ogt, %[[VAL_145]], %[[VAL_117]] {{.*}} : f32
-! CHECK: %[[VAL_147:.*]] = arith.constant 1 : i32
-! CHECK: %[[VAL_148:.*]] = fir.coordinate_of %[[VAL_102]], %[[VAL_147]] : (!fir.ref<tuple<i64, !fir.heap<!fir.array<?xi8>>, !fir.heap<!fir.array<?xi64>>>>, i32) -> !fir.ref<!fir.heap<!fir.array<?xi8>>>
-! CHECK: %[[VAL_149:.*]] = fir.load %[[VAL_148]] : !fir.ref<!fir.heap<!fir.array<?xi8>>>
-! CHECK: %[[VAL_150:.*]] = fir.shape %[[VAL_114]] : (index) -> !fir.shape<1>
-! CHECK: %[[VAL_151:.*]] = arith.constant 1 : index
-! CHECK: %[[VAL_152:.*]] = arith.addi %[[VAL_143]], %[[VAL_151]] : index
-! CHECK: %[[VAL_153:.*]] = fir.array_coor %[[VAL_149]](%[[VAL_150]]) %[[VAL_152]] : (!fir.heap<!fir.array<?xi8>>, !fir.shape<1>, index) -> !fir.ref<i8>
-! CHECK: %[[VAL_154:.*]] = fir.convert %[[VAL_146]] : (i1) -> i8
-! CHECK: fir.store %[[VAL_154]] to %[[VAL_153]] : !fir.ref<i8>
-! CHECK: fir.result %[[VAL_144]] : !fir.array<?xi8>
-! CHECK: }
-! CHECK: fir.result %[[VAL_52]] : !fir.array<?x?x!fir.type<_QFtest_nested_forall_whereTt{data:!fir.array<100xf32>}>>
-! CHECK: }
-! CHECK: fir.result %[[VAL_155:.*]] : !fir.array<?x?x!fir.type<_QFtest_nested_forall_whereTt{data:!fir.array<100xf32>}>>
-! CHECK: }
-! CHECK: %[[VAL_156:.*]] = fir.do_loop %[[VAL_157:.*]] = %[[VAL_19]] to %[[VAL_29]] step %[[VAL_30]] unordered iter_args(%[[VAL_158:.*]] = %[[VAL_44]]) -> (!fir.array<?x?x!fir.type<_QFtest_nested_forall_whereTt{data:!fir.array<100xf32>}>>) {
-! CHECK: %[[VAL_159:.*]] = fir.convert %[[VAL_157]] : (index) -> i32
-! CHECK: fir.store %[[VAL_159]] to %[[VAL_5]] : !fir.ref<i32>
-! CHECK: %[[VAL_160:.*]] = fir.do_loop %[[VAL_161:.*]] = %[[VAL_32]] to %[[VAL_42]] step %[[VAL_43]] unordered iter_args(%[[VAL_162:.*]] = %[[VAL_158]]) -> (!fir.array<?x?x!fir.type<_QFtest_nested_forall_whereTt{data:!fir.array<100xf32>}>>) {
-! CHECK: %[[VAL_163:.*]] = fir.convert %[[VAL_161]] : (index) -> i32
-! CHECK: fir.store %[[VAL_163]] to %[[VAL_4]] : !fir.ref<i32>
-! CHECK: %[[VAL_164:.*]] = arith.constant 0 : i64
-! CHECK: %[[VAL_165:.*]] = fir.convert %[[VAL_19]] : (index) -> i64
-! CHECK: %[[VAL_166:.*]] = fir.convert %[[VAL_29]] : (index) -> i64
-! CHECK: %[[VAL_167:.*]] = fir.convert %[[VAL_30]] : (index) -> i64
-! CHECK: %[[VAL_168:.*]] = arith.subi %[[VAL_166]], %[[VAL_165]] : i64
-! CHECK: %[[VAL_169:.*]] = arith.addi %[[VAL_168]], %[[VAL_167]] : i64
-! CHECK: %[[VAL_170:.*]] = arith.divsi %[[VAL_169]], %[[VAL_167]] : i64
-! CHECK: %[[VAL_171:.*]] = arith.cmpi sgt, %[[VAL_170]], %[[VAL_164]] : i64
-! CHECK: %[[VAL_172:.*]] = arith.select %[[VAL_171]], %[[VAL_170]], %[[VAL_164]] : i64
-! CHECK: %[[VAL_173:.*]] = arith.constant 0 : i64
-! CHECK: %[[VAL_174:.*]] = fir.convert %[[VAL_32]] : (index) -> i64
-! CHECK: %[[VAL_175:.*]] = fir.convert %[[VAL_42]] : (index) -> i64
-! CHECK: %[[VAL_176:.*]] = fir.convert %[[VAL_43]] : (index) -> i64
-! CHECK: %[[VAL_177:.*]] = arith.subi %[[VAL_175]], %[[VAL_174]] : i64
-! CHECK: %[[VAL_178:.*]] = arith.addi %[[VAL_177]], %[[VAL_176]] : i64
-! CHECK: %[[VAL_179:.*]] = arith.divsi %[[VAL_178]], %[[VAL_176]] : i64
-! CHECK: %[[VAL_180:.*]] = arith.cmpi sgt, %[[VAL_179]], %[[VAL_173]] : i64
-! CHECK: %[[VAL_181:.*]] = arith.select %[[VAL_180]], %[[VAL_179]], %[[VAL_173]] : i64
-! CHECK: %[[VAL_182:.*]] = arith.subi %[[VAL_157]], %[[VAL_19]] : index
-! CHECK: %[[VAL_183:.*]] = arith.divsi %[[VAL_182]], %[[VAL_30]] : index
-! CHECK: %[[VAL_184:.*]] = arith.constant 1 : index
-! CHECK: %[[VAL_185:.*]] = arith.addi %[[VAL_183]], %[[VAL_184]] : index
-! CHECK: %[[VAL_186:.*]] = arith.subi %[[VAL_161]], %[[VAL_32]] : index
-! CHECK: %[[VAL_187:.*]] = arith.divsi %[[VAL_186]], %[[VAL_43]] : index
-! CHECK: %[[VAL_188:.*]] = arith.constant 1 : index
-! CHECK: %[[VAL_189:.*]] = arith.addi %[[VAL_187]], %[[VAL_188]] : index
-! CHECK: %[[VAL_190:.*]] = arith.constant 1 : i32
-! CHECK: %[[VAL_191:.*]] = fir.coordinate_of %[[VAL_8]], %[[VAL_190]] : (!fir.ref<tuple<i64, !fir.heap<!fir.array<?xi8>>, !fir.heap<!fir.array<?xi64>>>>, i32) -> !fir.ref<!fir.heap<!fir.array<?xi8>>>
-! CHECK: %[[VAL_192:.*]] = fir.load %[[VAL_191]] : !fir.ref<!fir.heap<!fir.array<?xi8>>>
-! CHECK: %[[VAL_193:.*]] = fir.convert %[[VAL_192]] : (!fir.heap<!fir.array<?xi8>>) -> !fir.ref<!fir.array<?x?xtuple<i64, !fir.heap<!fir.array<?xi8>>, !fir.heap<!fir.array<?xi64>>>>>
-! CHECK: %[[VAL_194:.*]] = fir.shape %[[VAL_172]], %[[VAL_181]] : (i64, i64) -> !fir.shape<2>
-! CHECK: %[[VAL_195:.*]] = fir.array_coor %[[VAL_193]](%[[VAL_194]]) %[[VAL_185]], %[[VAL_189]] : (!fir.ref<!fir.array<?x?xtuple<i64, !fir.heap<!fir.array<?xi8>>, !fir.heap<!fir.array<?xi64>>>>>, !fir.shape<2>, index, index) -> !fir.ref<tuple<i64, !fir.heap<!fir.array<?xi8>>, !fir.heap<!fir.array<?xi64>>>>
-! CHECK: %[[VAL_196:.*]] = arith.constant 1 : i32
-! CHECK: %[[VAL_197:.*]] = fir.coordinate_of %[[VAL_195]], %[[VAL_196]] : (!fir.ref<tuple<i64, !fir.heap<!fir.array<?xi8>>, !fir.heap<!fir.array<?xi64>>>>, i32) -> !fir.ref<!fir.heap<!fir.array<?xi8>>>
-! CHECK: %[[VAL_198:.*]] = fir.load %[[VAL_197]] : !fir.ref<!fir.heap<!fir.array<?xi8>>>
-! CHECK: %[[VAL_199:.*]] = fir.convert %[[VAL_198]] : (!fir.heap<!fir.array<?xi8>>) -> !fir.ref<!fir.array<?xi8>>
-! CHECK: %[[VAL_200:.*]] = arith.constant 2 : i32
-! CHECK: %[[VAL_201:.*]] = fir.coordinate_of %[[VAL_195]], %[[VAL_200]] : (!fir.ref<tuple<i64, !fir.heap<!fir.array<?xi8>>, !fir.heap<!fir.array<?xi64>>>>, i32) -> !fir.ref<!fir.heap<!fir.array<?xi64>>>
-! CHECK: %[[VAL_202:.*]] = fir.load %[[VAL_201]] : !fir.ref<!fir.heap<!fir.array<?xi64>>>
-! CHECK: %[[VAL_203:.*]] = arith.constant 0 : i32
-! CHECK: %[[VAL_204:.*]] = fir.coordinate_of %[[VAL_202]], %[[VAL_203]] : (!fir.heap<!fir.array<?xi64>>, i32) -> !fir.ref<i64>
-! CHECK: %[[VAL_205:.*]] = fir.load %[[VAL_204]] : !fir.ref<i64>
-! CHECK: %[[VAL_206:.*]] = fir.convert %[[VAL_205]] : (i64) -> index
-! CHECK: %[[VAL_207:.*]] = fir.shape %[[VAL_206]] : (index) -> !fir.shape<1>
-! CHECK: %[[VAL_208:.*]] = arith.constant 1 : index
-! CHECK: %[[VAL_209:.*]] = fir.load %[[VAL_5]] : !fir.ref<i32>
-! CHECK: %[[VAL_210:.*]] = fir.convert %[[VAL_209]] : (i32) -> i64
-! CHECK: %[[VAL_211:.*]] = fir.convert %[[VAL_210]] : (i64) -> index
-! CHECK: %[[VAL_212:.*]] = arith.subi %[[VAL_211]], %[[VAL_208]] : index
-! CHECK: %[[VAL_213:.*]] = fir.load %[[VAL_4]] : !fir.ref<i32>
-! CHECK: %[[VAL_214:.*]] = fir.convert %[[VAL_213]] : (i32) -> i64
-! CHECK: %[[VAL_215:.*]] = fir.convert %[[VAL_214]] : (i64) -> index
-! CHECK: %[[VAL_216:.*]] = arith.subi %[[VAL_215]], %[[VAL_208]] : index
-! CHECK: %[[VAL_217:.*]] = fir.field_index data, !fir.type<_QFtest_nested_forall_whereTt{data:!fir.array<100xf32>}>
-! CHECK: %[[VAL_218:.*]] = arith.constant 1 : index
-! CHECK: %[[VAL_219:.*]] = fir.load %[[VAL_4]] : !fir.ref<i32>
-! CHECK: %[[VAL_220:.*]] = fir.convert %[[VAL_219]] : (i32) -> i64
-! CHECK: %[[VAL_221:.*]] = fir.convert %[[VAL_220]] : (i64) -> index
-! CHECK: %[[VAL_222:.*]] = arith.subi %[[VAL_221]], %[[VAL_218]] : index
-! CHECK: %[[VAL_223:.*]] = fir.load %[[VAL_5]] : !fir.ref<i32>
-! CHECK: %[[VAL_224:.*]] = fir.convert %[[VAL_223]] : (i32) -> i64
-! CHECK: %[[VAL_225:.*]] = fir.convert %[[VAL_224]] : (i64) -> index
-! CHECK: %[[VAL_226:.*]] = arith.subi %[[VAL_225]], %[[VAL_218]] : index
-! CHECK: %[[VAL_227:.*]] = fir.field_index data, !fir.type<_QFtest_nested_forall_whereTt{data:!fir.array<100xf32>}>
-! CHECK: %[[VAL_228:.*]] = arith.constant 3.140000e+00 : f32
-! CHECK: %[[VAL_229:.*]] = arith.constant 1 : index
-! CHECK: %[[VAL_230:.*]] = arith.constant 0 : index
-! CHECK: %[[VAL_231:.*]] = arith.subi %[[VAL_206]], %[[VAL_229]] : index
-! CHECK: %[[VAL_232:.*]] = fir.do_loop %[[VAL_233:.*]] = %[[VAL_230]] to %[[VAL_231]] step %[[VAL_229]] unordered iter_args(%[[VAL_234:.*]] = %[[VAL_162]]) -> (!fir.array<?x?x!fir.type<_QFtest_nested_forall_whereTt{data:!fir.array<100xf32>}>>) {
-! CHECK: %[[VAL_235:.*]] = arith.constant 1 : index
-! CHECK: %[[VAL_236:.*]] = arith.addi %[[VAL_233]], %[[VAL_235]] : index
-! CHECK: %[[VAL_237:.*]] = fir.array_coor %[[VAL_199]](%[[VAL_207]]) %[[VAL_236]] : (!fir.ref<!fir.array<?xi8>>, !fir.shape<1>, index) -> !fir.ref<i8>
-! CHECK: %[[VAL_238:.*]] = fir.load %[[VAL_237]] : !fir.ref<i8>
-! CHECK: %[[VAL_239:.*]] = fir.convert %[[VAL_238]] : (i8) -> i1
-! CHECK: %[[VAL_240:.*]] = fir.if %[[VAL_239]] -> (!fir.array<?x?x!fir.type<_QFtest_nested_forall_whereTt{data:!fir.array<100xf32>}>>) {
-! CHECK: %[[VAL_241:.*]] = fir.array_fetch %[[VAL_45]], %[[VAL_222]], %[[VAL_226]], %[[VAL_227]], %[[VAL_233]] : (!fir.array<?x?x!fir.type<_QFtest_nested_forall_whereTt{data:!fir.array<100xf32>}>>, index, index, !fir.field, index) -> f32
-! CHECK: %[[VAL_242:.*]] = arith.divf %[[VAL_241]], %[[VAL_228]] {{.*}}: f32
-! CHECK: %[[VAL_243:.*]] = fir.array_update %[[VAL_234]], %[[VAL_242]], %[[VAL_212]], %[[VAL_216]], %[[VAL_217]], %[[VAL_233]] : (!fir.array<?x?x!fir.type<_QFtest_nested_forall_whereTt{data:!fir.array<100xf32>}>>, f32, index, index, !fir.field, index) -> !fir.array<?x?x!fir.type<_QFtest_nested_forall_whereTt{data:!fir.array<100xf32>}>>
-! CHECK: fir.result %[[VAL_243]] : !fir.array<?x?x!fir.type<_QFtest_nested_forall_whereTt{data:!fir.array<100xf32>}>>
-! CHECK: } else {
-! CHECK: fir.result %[[VAL_234]] : !fir.array<?x?x!fir.type<_QFtest_nested_forall_whereTt{data:!fir.array<100xf32>}>>
-! CHECK: }
-! CHECK: fir.result %[[VAL_244:.*]] : !fir.array<?x?x!fir.type<_QFtest_nested_forall_whereTt{data:!fir.array<100xf32>}>>
-! CHECK: }
-! CHECK: fir.result %[[VAL_245:.*]] : !fir.array<?x?x!fir.type<_QFtest_nested_forall_whereTt{data:!fir.array<100xf32>}>>
-! CHECK: }
-! CHECK: fir.result %[[VAL_246:.*]] : !fir.array<?x?x!fir.type<_QFtest_nested_forall_whereTt{data:!fir.array<100xf32>}>>
+! CHECK-LABEL: func.func @_QPtest_nested_forall_where(
+! CHECK: hlfir.forall
+! CHECK: (%[[arg2:.*]]: i32) {
+! CHECK: %[[i:.*]] = hlfir.forall_index "i" %[[arg2]] : (i32) -> !fir.ref<i32>
+! CHECK: hlfir.forall
+! CHECK: (%[[arg3:.*]]: i32) {
+! CHECK: %[[j:.*]] = hlfir.forall_index "j" %[[arg3]] : (i32) -> !fir.ref<i32>
+! CHECK: hlfir.where {
+! CHECK: %[[mask:.*]] = hlfir.elemental {{.*}} {
+! CHECK: arith.cmpf ogt, {{.*}}
+! CHECK: }
+! CHECK: hlfir.yield %[[mask]]
+! CHECK: } do {
+! CHECK: hlfir.region_assign {
+! CHECK: %[[res:.*]] = hlfir.elemental {{.*}} {
+! CHECK: arith.divf {{.*}}
! CHECK: }
-! CHECK: fir.array_merge_store %[[VAL_44]], %[[VAL_247:.*]] to %[[VAL_0]] : !fir.array<?x?x!fir.type<_QFtest_nested_forall_whereTt{data:!fir.array<100xf32>}>>, !fir.array<?x?x!fir.type<_QFtest_nested_forall_whereTt{data:!fir.array<100xf32>}>>, !fir.box<!fir.array<?x?x!fir.type<_QFtest_nested_forall_whereTt{data:!fir.array<100xf32>}>>>
-! CHECK: %[[VAL_248:.*]] = fir.array_load %[[VAL_0]] : (!fir.box<!fir.array<?x?x!fir.type<_QFtest_nested_forall_whereTt{data:!fir.array<100xf32>}>>>) -> !fir.array<?x?x!fir.type<_QFtest_nested_forall_whereTt{data:!fir.array<100xf32>}>>
-! CHECK: %[[VAL_249:.*]] = fir.array_load %[[VAL_1]] : (!fir.box<!fir.array<?x?x!fir.type<_QFtest_nested_forall_whereTt{data:!fir.array<100xf32>}>>>) -> !fir.array<?x?x!fir.type<_QFtest_nested_forall_whereTt{data:!fir.array<100xf32>}>>
-! CHECK: %[[VAL_250:.*]] = fir.do_loop %[[VAL_251:.*]] = %[[VAL_19]] to %[[VAL_29]] step %[[VAL_30]] unordered iter_args(%[[VAL_252:.*]] = %[[VAL_248]]) -> (!fir.array<?x?x!fir.type<_QFtest_nested_forall_whereTt{data:!fir.array<100xf32>}>>) {
-! CHECK: %[[VAL_253:.*]] = fir.convert %[[VAL_251]] : (index) -> i32
-! CHECK: fir.store %[[VAL_253]] to %[[VAL_3]] : !fir.ref<i32>
-! CHECK: %[[VAL_254:.*]] = fir.do_loop %[[VAL_255:.*]] = %[[VAL_32]] to %[[VAL_42]] step %[[VAL_43]] unordered iter_args(%[[VAL_256:.*]] = %[[VAL_252]]) -> (!fir.array<?x?x!fir.type<_QFtest_nested_forall_whereTt{data:!fir.array<100xf32>}>>) {
-! CHECK: %[[VAL_257:.*]] = fir.convert %[[VAL_255]] : (index) -> i32
-! CHECK: fir.store %[[VAL_257]] to %[[VAL_2]] : !fir.ref<i32>
-! CHECK: %[[VAL_258:.*]] = arith.constant 0 : i64
-! CHECK: %[[VAL_259:.*]] = fir.convert %[[VAL_19]] : (index) -> i64
-! CHECK: %[[VAL_260:.*]] = fir.convert %[[VAL_29]] : (index) -> i64
-! CHECK: %[[VAL_261:.*]] = fir.convert %[[VAL_30]] : (index) -> i64
-! CHECK: %[[VAL_262:.*]] = arith.subi %[[VAL_260]], %[[VAL_259]] : i64
-! CHECK: %[[VAL_263:.*]] = arith.addi %[[VAL_262]], %[[VAL_261]] : i64
-! CHECK: %[[VAL_264:.*]] = arith.divsi %[[VAL_263]], %[[VAL_261]] : i64
-! CHECK: %[[VAL_265:.*]] = arith.cmpi sgt, %[[VAL_264]], %[[VAL_258]] : i64
-! CHECK: %[[VAL_266:.*]] = arith.select %[[VAL_265]], %[[VAL_264]], %[[VAL_258]] : i64
-! CHECK: %[[VAL_267:.*]] = arith.constant 0 : i64
-! CHECK: %[[VAL_268:.*]] = fir.convert %[[VAL_32]] : (index) -> i64
-! CHECK: %[[VAL_269:.*]] = fir.convert %[[VAL_42]] : (index) -> i64
-! CHECK: %[[VAL_270:.*]] = fir.convert %[[VAL_43]] : (index) -> i64
-! CHECK: %[[VAL_271:.*]] = arith.subi %[[VAL_269]], %[[VAL_268]] : i64
-! CHECK: %[[VAL_272:.*]] = arith.addi %[[VAL_271]], %[[VAL_270]] : i64
-! CHECK: %[[VAL_273:.*]] = arith.divsi %[[VAL_272]], %[[VAL_270]] : i64
-! CHECK: %[[VAL_274:.*]] = arith.cmpi sgt, %[[VAL_273]], %[[VAL_267]] : i64
-! CHECK: %[[VAL_275:.*]] = arith.select %[[VAL_274]], %[[VAL_273]], %[[VAL_267]] : i64
-! CHECK: %[[VAL_276:.*]] = arith.subi %[[VAL_251]], %[[VAL_19]] : index
-! CHECK: %[[VAL_277:.*]] = arith.divsi %[[VAL_276]], %[[VAL_30]] : index
-! CHECK: %[[VAL_278:.*]] = arith.constant 1 : index
-! CHECK: %[[VAL_279:.*]] = arith.addi %[[VAL_277]], %[[VAL_278]] : index
-! CHECK: %[[VAL_280:.*]] = arith.subi %[[VAL_255]], %[[VAL_32]] : index
-! CHECK: %[[VAL_281:.*]] = arith.divsi %[[VAL_280]], %[[VAL_43]] : index
-! CHECK: %[[VAL_282:.*]] = arith.constant 1 : index
-! CHECK: %[[VAL_283:.*]] = arith.addi %[[VAL_281]], %[[VAL_282]] : index
-! CHECK: %[[VAL_284:.*]] = arith.constant 1 : i32
-! CHECK: %[[VAL_285:.*]] = fir.coordinate_of %[[VAL_8]], %[[VAL_284]] : (!fir.ref<tuple<i64, !fir.heap<!fir.array<?xi8>>, !fir.heap<!fir.array<?xi64>>>>, i32) -> !fir.ref<!fir.heap<!fir.array<?xi8>>>
-! CHECK: %[[VAL_286:.*]] = fir.load %[[VAL_285]] : !fir.ref<!fir.heap<!fir.array<?xi8>>>
-! CHECK: %[[VAL_287:.*]] = fir.convert %[[VAL_286]] : (!fir.heap<!fir.array<?xi8>>) -> !fir.ref<!fir.array<?x?xtuple<i64, !fir.heap<!fir.array<?xi8>>, !fir.heap<!fir.array<?xi64>>>>>
-! CHECK: %[[VAL_288:.*]] = fir.shape %[[VAL_266]], %[[VAL_275]] : (i64, i64) -> !fir.shape<2>
-! CHECK: %[[VAL_289:.*]] = fir.array_coor %[[VAL_287]](%[[VAL_288]]) %[[VAL_279]], %[[VAL_283]] : (!fir.ref<!fir.array<?x?xtuple<i64, !fir.heap<!fir.array<?xi8>>, !fir.heap<!fir.array<?xi64>>>>>, !fir.shape<2>, index, index) -> !fir.ref<tuple<i64, !fir.heap<!fir.array<?xi8>>, !fir.heap<!fir.array<?xi64>>>>
-! CHECK: %[[VAL_290:.*]] = arith.constant 1 : i32
-! CHECK: %[[VAL_291:.*]] = fir.coordinate_of %[[VAL_289]], %[[VAL_290]] : (!fir.ref<tuple<i64, !fir.heap<!fir.array<?xi8>>, !fir.heap<!fir.array<?xi64>>>>, i32) -> !fir.ref<!fir.heap<!fir.array<?xi8>>>
-! CHECK: %[[VAL_292:.*]] = fir.load %[[VAL_291]] : !fir.ref<!fir.heap<!fir.array<?xi8>>>
-! CHECK: %[[VAL_293:.*]] = fir.convert %[[VAL_292]] : (!fir.heap<!fir.array<?xi8>>) -> !fir.ref<!fir.array<?xi8>>
-! CHECK: %[[VAL_294:.*]] = arith.constant 2 : i32
-! CHECK: %[[VAL_295:.*]] = fir.coordinate_of %[[VAL_289]], %[[VAL_294]] : (!fir.ref<tuple<i64, !fir.heap<!fir.array<?xi8>>, !fir.heap<!fir.array<?xi64>>>>, i32) -> !fir.ref<!fir.heap<!fir.array<?xi64>>>
-! CHECK: %[[VAL_296:.*]] = fir.load %[[VAL_295]] : !fir.ref<!fir.heap<!fir.array<?xi64>>>
-! CHECK: %[[VAL_297:.*]] = arith.constant 0 : i32
-! CHECK: %[[VAL_298:.*]] = fir.coordinate_of %[[VAL_296]], %[[VAL_297]] : (!fir.heap<!fir.array<?xi64>>, i32) -> !fir.ref<i64>
-! CHECK: %[[VAL_299:.*]] = fir.load %[[VAL_298]] : !fir.ref<i64>
-! CHECK: %[[VAL_300:.*]] = fir.convert %[[VAL_299]] : (i64) -> index
-! CHECK: %[[VAL_301:.*]] = fir.shape %[[VAL_300]] : (index) -> !fir.shape<1>
-! CHECK: %[[VAL_302:.*]] = arith.constant 1 : index
-! CHECK: %[[VAL_303:.*]] = fir.load %[[VAL_3]] : !fir.ref<i32>
-! CHECK: %[[VAL_304:.*]] = fir.convert %[[VAL_303]] : (i32) -> i64
-! CHECK: %[[VAL_305:.*]] = fir.convert %[[VAL_304]] : (i64) -> index
-! CHECK: %[[VAL_306:.*]] = arith.subi %[[VAL_305]], %[[VAL_302]] : index
-! CHECK: %[[VAL_307:.*]] = fir.load %[[VAL_2]] : !fir.ref<i32>
-! CHECK: %[[VAL_308:.*]] = fir.convert %[[VAL_307]] : (i32) -> i64
-! CHECK: %[[VAL_309:.*]] = fir.convert %[[VAL_308]] : (i64) -> index
-! CHECK: %[[VAL_310:.*]] = arith.subi %[[VAL_309]], %[[VAL_302]] : index
-! CHECK: %[[VAL_311:.*]] = fir.field_index data, !fir.type<_QFtest_nested_forall_whereTt{data:!fir.array<100xf32>}>
-! CHECK: %[[VAL_312:.*]] = arith.constant 1 : index
-! CHECK: %[[VAL_313:.*]] = fir.load %[[VAL_2]] : !fir.ref<i32>
-! CHECK: %[[VAL_314:.*]] = fir.convert %[[VAL_313]] : (i32) -> i64
-! CHECK: %[[VAL_315:.*]] = fir.convert %[[VAL_314]] : (i64) -> index
-! CHECK: %[[VAL_316:.*]] = arith.subi %[[VAL_315]], %[[VAL_312]] : index
-! CHECK: %[[VAL_317:.*]] = fir.load %[[VAL_3]] : !fir.ref<i32>
-! CHECK: %[[VAL_318:.*]] = fir.convert %[[VAL_317]] : (i32) -> i64
-! CHECK: %[[VAL_319:.*]] = fir.convert %[[VAL_318]] : (i64) -> index
-! CHECK: %[[VAL_320:.*]] = arith.subi %[[VAL_319]], %[[VAL_312]] : index
-! CHECK: %[[VAL_321:.*]] = fir.field_index data, !fir.type<_QFtest_nested_forall_whereTt{data:!fir.array<100xf32>}>
-! CHECK: %[[VAL_322:.*]] = arith.constant 1 : index
-! CHECK: %[[VAL_323:.*]] = arith.constant 0 : index
-! CHECK: %[[VAL_324:.*]] = arith.subi %[[VAL_300]], %[[VAL_322]] : index
-! CHECK: %[[VAL_325:.*]] = fir.do_loop %[[VAL_326:.*]] = %[[VAL_323]] to %[[VAL_324]] step %[[VAL_322]] unordered iter_args(%[[VAL_327:.*]] = %[[VAL_256]]) -> (!fir.array<?x?x!fir.type<_QFtest_nested_forall_whereTt{data:!fir.array<100xf32>}>>) {
-! CHECK: %[[VAL_328:.*]] = arith.constant 1 : index
-! CHECK: %[[VAL_329:.*]] = arith.addi %[[VAL_326]], %[[VAL_328]] : index
-! CHECK: %[[VAL_330:.*]] = fir.array_coor %[[VAL_293]](%[[VAL_301]]) %[[VAL_329]] : (!fir.ref<!fir.array<?xi8>>, !fir.shape<1>, index) -> !fir.ref<i8>
-! CHECK: %[[VAL_331:.*]] = fir.load %[[VAL_330]] : !fir.ref<i8>
-! CHECK: %[[VAL_332:.*]] = fir.convert %[[VAL_331]] : (i8) -> i1
-! CHECK: %[[VAL_333:.*]] = fir.if %[[VAL_332]] -> (!fir.array<?x?x!fir.type<_QFtest_nested_forall_whereTt{data:!fir.array<100xf32>}>>) {
-! CHECK: fir.result %[[VAL_327]] : !fir.array<?x?x!fir.type<_QFtest_nested_forall_whereTt{data:!fir.array<100xf32>}>>
-! CHECK: } else {
-! CHECK: %[[VAL_334:.*]] = fir.array_fetch %[[VAL_249]], %[[VAL_316]], %[[VAL_320]], %[[VAL_321]], %[[VAL_326]] : (!fir.array<?x?x!fir.type<_QFtest_nested_forall_whereTt{data:!fir.array<100xf32>}>>, index, index, !fir.field, index) -> f32
-! CHECK: %[[VAL_335:.*]] = arith.negf %[[VAL_334]] {{.*}}: f32
-! CHECK: %[[VAL_336:.*]] = fir.array_update %[[VAL_327]], %[[VAL_335]], %[[VAL_306]], %[[VAL_310]], %[[VAL_311]], %[[VAL_326]] : (!fir.array<?x?x!fir.type<_QFtest_nested_forall_whereTt{data:!fir.array<100xf32>}>>, f32, index, index, !fir.field, index) -> !fir.array<?x?x!fir.type<_QFtest_nested_forall_whereTt{data:!fir.array<100xf32>}>>
-! CHECK: fir.result %[[VAL_336]] : !fir.array<?x?x!fir.type<_QFtest_nested_forall_whereTt{data:!fir.array<100xf32>}>>
-! CHECK: }
-! CHECK: fir.result %[[VAL_337:.*]] : !fir.array<?x?x!fir.type<_QFtest_nested_forall_whereTt{data:!fir.array<100xf32>}>>
-! CHECK: }
-! CHECK: fir.result %[[VAL_338:.*]] : !fir.array<?x?x!fir.type<_QFtest_nested_forall_whereTt{data:!fir.array<100xf32>}>>
-! CHECK: }
-! CHECK: fir.result %[[VAL_339:.*]] : !fir.array<?x?x!fir.type<_QFtest_nested_forall_whereTt{data:!fir.array<100xf32>}>>
+! CHECK: hlfir.yield %[[res]]
+! CHECK: } to {
+! CHECK: }
+! CHECK: hlfir.elsewhere do {
+! CHECK: hlfir.region_assign {
+! CHECK: %[[res:.*]] = hlfir.elemental {{.*}} {
+! CHECK: arith.negf {{.*}}
! CHECK: }
-! CHECK: fir.array_merge_store %[[VAL_248]], %[[VAL_340:.*]] to %[[VAL_0]] : !fir.array<?x?x!fir.type<_QFtest_nested_forall_whereTt{data:!fir.array<100xf32>}>>, !fir.array<?x?x!fir.type<_QFtest_nested_forall_whereTt{data:!fir.array<100xf32>}>>, !fir.box<!fir.array<?x?x!fir.type<_QFtest_nested_forall_whereTt{data:!fir.array<100xf32>}>>>
-! CHECK: %[[VAL_341:.*]] = fir.convert %[[VAL_8]] : (!fir.ref<tuple<i64, !fir.heap<!fir.array<?xi8>>, !fir.heap<!fir.array<?xi64>>>>) -> !fir.llvm_ptr<i8>
-! CHECK: fir.call @_FortranARaggedArrayDeallocate(%[[VAL_341]]) {{.*}}: (!fir.llvm_ptr<i8>) -> ()
-! CHECK: return
+! CHECK: hlfir.yield %[[res]]
+! CHECK: } to {
! CHECK: }
+! CHECK: }
+! CHECK: }
+! CHECK: }
diff --git a/flang/test/Lower/forall/test9.f90 b/flang/test/Lower/forall/test9.f90
index 88107cb6f6037..082b9c913b605 100644
--- a/flang/test/Lower/forall/test9.f90
+++ b/flang/test/Lower/forall/test9.f90
@@ -1,6 +1,6 @@
! Test forall lowering
-! RUN: bbc -emit-fir -hlfir=false %s -o - | FileCheck %s
+! RUN: %flang_fc1 -emit-hlfir %s -o - | FileCheck %s
!*** This FORALL construct does present a potential loop-carried dependence if
!*** implemented naively (and incorrectly). The final value of a(3) must be the
@@ -15,62 +15,26 @@ subroutine test9(a,b,n)
END FORALL loopy
end subroutine test9
-! CHECK-LABEL: func @_QPtest9(
-! CHECK-SAME: %[[VAL_0:.*]]: !fir.ref<!fir.array<?xf32>> {fir.bindc_name = "a"},
-! CHECK-SAME: %[[VAL_1:.*]]: !fir.ref<!fir.array<?xf32>> {fir.bindc_name = "b"},
-! CHECK-SAME: %[[VAL_2:.*]]: !fir.ref<i32> {fir.bindc_name = "n"}) {
-! CHECK: %[[VAL_3:.*]] = fir.alloca i32 {adapt.valuebyref, bindc_name = "i"}
-! CHECK: %[[VAL_4:.*]] = fir.load %[[VAL_2]] : !fir.ref<i32>
-! CHECK: %[[VAL_5:.*]] = fir.convert %[[VAL_4]] : (i32) -> i64
-! CHECK: %[[VAL_6:.*]] = fir.convert %[[VAL_5]] : (i64) -> index
-! CHECK: %[[VAL_7:.*]] = arith.constant 0 : index
-! CHECK: %[[VAL_8:.*]] = arith.cmpi sgt, %[[VAL_6]], %[[VAL_7]] : index
-! CHECK: %[[VAL_9:.*]] = arith.select %[[VAL_8]], %[[VAL_6]], %[[VAL_7]] : index
-! CHECK: %[[VAL_10:.*]] = fir.load %[[VAL_2]] : !fir.ref<i32>
-! CHECK: %[[VAL_11:.*]] = fir.convert %[[VAL_10]] : (i32) -> i64
-! CHECK: %[[VAL_12:.*]] = fir.convert %[[VAL_11]] : (i64) -> index
-! CHECK: %[[VAL_13:.*]] = arith.constant 0 : index
-! CHECK: %[[VAL_14:.*]] = arith.cmpi sgt, %[[VAL_12]], %[[VAL_13]] : index
-! CHECK: %[[VAL_15:.*]] = arith.select %[[VAL_14]], %[[VAL_12]], %[[VAL_13]] : index
-! CHECK: %[[VAL_16:.*]] = arith.constant 1 : i32
-! CHECK: %[[VAL_17:.*]] = fir.convert %[[VAL_16]] : (i32) -> index
-! CHECK: %[[VAL_18:.*]] = fir.load %[[VAL_2]] : !fir.ref<i32>
-! CHECK: %[[VAL_19:.*]] = arith.constant 1 : i32
-! CHECK: %[[VAL_20:.*]] = arith.subi %[[VAL_18]], %[[VAL_19]] : i32
-! CHECK: %[[VAL_21:.*]] = fir.convert %[[VAL_20]] : (i32) -> index
-! CHECK: %[[VAL_22:.*]] = arith.constant 1 : index
-! CHECK: %[[VAL_23:.*]] = fir.shape %[[VAL_9]] : (index) -> !fir.shape<1>
-! CHECK: %[[VAL_24:.*]] = fir.array_load %[[VAL_0]](%[[VAL_23]]) : (!fir.ref<!fir.array<?xf32>>, !fir.shape<1>) -> !fir.array<?xf32>
-! CHECK: %[[VAL_25:.*]] = fir.shape %[[VAL_9]] : (index) -> !fir.shape<1>
-! CHECK: %[[VAL_26:.*]] = fir.array_load %[[VAL_0]](%[[VAL_25]]) : (!fir.ref<!fir.array<?xf32>>, !fir.shape<1>) -> !fir.array<?xf32>
-! CHECK: %[[VAL_27:.*]] = fir.shape %[[VAL_15]] : (index) -> !fir.shape<1>
-! CHECK: %[[VAL_28:.*]] = fir.array_load %[[VAL_1]](%[[VAL_27]]) : (!fir.ref<!fir.array<?xf32>>, !fir.shape<1>) -> !fir.array<?xf32>
-! CHECK: %[[VAL_29:.*]] = fir.do_loop %[[VAL_30:.*]] = %[[VAL_17]] to %[[VAL_21]] step %[[VAL_22]] unordered iter_args(%[[VAL_31:.*]] = %[[VAL_24]]) -> (!fir.array<?xf32>) {
-! CHECK: %[[VAL_32:.*]] = fir.convert %[[VAL_30]] : (index) -> i32
-! CHECK: fir.store %[[VAL_32]] to %[[VAL_3]] : !fir.ref<i32>
-! CHECK: %[[VAL_33:.*]] = arith.constant 1 : index
-! CHECK: %[[VAL_34:.*]] = fir.load %[[VAL_3]] : !fir.ref<i32>
-! CHECK: %[[VAL_35:.*]] = fir.convert %[[VAL_34]] : (i32) -> i64
-! CHECK: %[[VAL_36:.*]] = fir.convert %[[VAL_35]] : (i64) -> index
-! CHECK: %[[VAL_37:.*]] = arith.subi %[[VAL_36]], %[[VAL_33]] : index
-! CHECK: %[[VAL_38:.*]] = fir.array_fetch %[[VAL_26]], %[[VAL_37]] : (!fir.array<?xf32>, index) -> f32
-! CHECK: %[[VAL_39:.*]] = arith.constant 1 : index
-! CHECK: %[[VAL_40:.*]] = fir.load %[[VAL_3]] : !fir.ref<i32>
-! CHECK: %[[VAL_41:.*]] = fir.convert %[[VAL_40]] : (i32) -> i64
-! CHECK: %[[VAL_42:.*]] = fir.convert %[[VAL_41]] : (i64) -> index
-! CHECK: %[[VAL_43:.*]] = arith.subi %[[VAL_42]], %[[VAL_39]] : index
-! CHECK: %[[VAL_44:.*]] = fir.array_fetch %[[VAL_28]], %[[VAL_43]] : (!fir.array<?xf32>, index) -> f32
-! CHECK: %[[VAL_45:.*]] = arith.addf %[[VAL_38]], %[[VAL_44]] {{.*}}: f32
-! CHECK: %[[VAL_46:.*]] = arith.constant 1 : index
-! CHECK: %[[VAL_47:.*]] = fir.load %[[VAL_3]] : !fir.ref<i32>
-! CHECK: %[[VAL_48:.*]] = arith.constant 1 : i32
-! CHECK: %[[VAL_49:.*]] = arith.addi %[[VAL_47]], %[[VAL_48]] : i32
-! CHECK: %[[VAL_50:.*]] = fir.convert %[[VAL_49]] : (i32) -> i64
-! CHECK: %[[VAL_51:.*]] = fir.convert %[[VAL_50]] : (i64) -> index
-! CHECK: %[[VAL_52:.*]] = arith.subi %[[VAL_51]], %[[VAL_46]] : index
-! CHECK: %[[VAL_53:.*]] = fir.array_update %[[VAL_31]], %[[VAL_45]], %[[VAL_52]] : (!fir.array<?xf32>, f32, index) -> !fir.array<?xf32>
-! CHECK: fir.result %[[VAL_53]] : !fir.array<?xf32>
-! CHECK: }
-! CHECK: fir.array_merge_store %[[VAL_24]], %[[VAL_54:.*]] to %[[VAL_0]] : !fir.array<?xf32>, !fir.array<?xf32>, !fir.ref<!fir.array<?xf32>>
-! CHECK: return
-! CHECK: }
+! CHECK-LABEL: func.func @_QPtest9(
+! CHECK: hlfir.forall
+! CHECK: (%[[arg3:.*]]: i32) {
+! CHECK: %[[i:.*]] = hlfir.forall_index "i" %[[arg3]] : (i32) -> !fir.ref<i32>
+! CHECK: hlfir.region_assign {
+! CHECK: %[[i_val:.*]] = fir.load %[[i]]
+! CHECK: %[[i_idx:.*]] = fir.convert %[[i_val]] : (i32) -> i64
+! CHECK: %[[a_i_ref:.*]] = hlfir.designate {{.*}} (%[[i_idx]])
+! CHECK: %[[a_i:.*]] = fir.load %[[a_i_ref]]
+! CHECK: %[[i_val2:.*]] = fir.load %[[i]]
+! CHECK: %[[i_idx2:.*]] = fir.convert %[[i_val2]] : (i32) -> i64
+! CHECK: %[[b_i_ref:.*]] = hlfir.designate {{.*}} (%[[i_idx2]])
+! CHECK: %[[b_i:.*]] = fir.load %[[b_i_ref]]
+! CHECK: %[[res:.*]] = arith.addf %[[a_i]], %[[b_i]]
+! CHECK: hlfir.yield %[[res]]
+! CHECK: } to {
+! CHECK: %[[i_val3:.*]] = fir.load %[[i]]
+! CHECK: %[[i_plus_1:.*]] = arith.addi %[[i_val3]], {{.*}}
+! CHECK: %[[i_plus_1_idx:.*]] = fir.convert %[[i_plus_1]] : (i32) -> i64
+! CHECK: %[[a_i_plus_1_ref:.*]] = hlfir.designate {{.*}} (%[[i_plus_1_idx]])
+! CHECK: hlfir.yield %[[a_i_plus_1_ref]]
+! CHECK: }
+! CHECK: }
diff --git a/flang/test/Lower/host-associated-functions.f90 b/flang/test/Lower/host-associated-functions.f90
index 65045845f526d..ac16393d403ea 100644
--- a/flang/test/Lower/host-associated-functions.f90
+++ b/flang/test/Lower/host-associated-functions.f90
@@ -1,50 +1,42 @@
-! RUN: bbc -emit-fir -hlfir=false %s -o - | FileCheck %s
-
! Test calling functions whose result interface is evaluated on the call site
! and where the calls are located in an internal procedure while the
! interface is defined in the host procedure.
+! RUN: %flang_fc1 -emit-hlfir %s -o - | FileCheck %s
-! CHECK-LABEL: func @_QPcapture_char_func_dummy(
+! CHECK-LABEL: func.func @_QPcapture_char_func_dummy(
! CHECK-SAME: %[[VAL_0:.*]]: tuple<!fir.boxproc<() -> ()>, i64> {fir.char_proc},
-! CHECK-SAME: %[[VAL_1:.*]]: !fir.ref<i32> {fir.bindc_name = "n"}) {
+! CHECK-SAME: %[[VAL_1_arg:.*]]: !fir.ref<i32> {fir.bindc_name = "n"}) {
subroutine capture_char_func_dummy(char_func_dummy, n)
character(n),external :: char_func_dummy
+ ! CHECK: %[[VAL_1:.*]]:2 = hlfir.declare %[[VAL_1_arg]] {{.*}}uniq_name = "_QFcapture_char_func_dummyEn"
! CHECK: %[[VAL_2:.*]] = fir.alloca tuple<tuple<!fir.boxproc<() -> ()>, i64>, !fir.ref<i32>>
! CHECK: %[[VAL_3:.*]] = arith.constant 0 : i32
! CHECK: %[[VAL_4:.*]] = fir.coordinate_of %[[VAL_2]], %[[VAL_3]] : (!fir.ref<tuple<tuple<!fir.boxproc<() -> ()>, i64>, !fir.ref<i32>>>, i32) -> !fir.ref<tuple<!fir.boxproc<() -> ()>, i64>>
! CHECK: fir.store %[[VAL_0]] to %[[VAL_4]] : !fir.ref<tuple<!fir.boxproc<() -> ()>, i64>>
! CHECK: %[[VAL_5:.*]] = arith.constant 1 : i32
! CHECK: %[[VAL_6:.*]] = fir.coordinate_of %[[VAL_2]], %[[VAL_5]] : (!fir.ref<tuple<tuple<!fir.boxproc<() -> ()>, i64>, !fir.ref<i32>>>, i32) -> !fir.llvm_ptr<!fir.ref<i32>>
- ! CHECK: fir.store %[[VAL_1]] to %[[VAL_6]] : !fir.llvm_ptr<!fir.ref<i32>>
+ ! CHECK: fir.store %[[VAL_1]]#0 to %[[VAL_6]] : !fir.llvm_ptr<!fir.ref<i32>>
! CHECK: fir.call @_QFcapture_char_func_dummyPinternal(%[[VAL_2]]) {{.*}}: (!fir.ref<tuple<tuple<!fir.boxproc<() -> ()>, i64>, !fir.ref<i32>>>) -> ()
call internal()
contains
- ! CHECK-LABEL: func private @_QFcapture_char_func_dummyPinternal(
- ! CHECK-SAME: %[[VAL_0:.*]]: !fir.ref<tuple<tuple<!fir.boxproc<() -> ()>, i64>, !fir.ref<i32>>> {fir.host_assoc}) attributes {fir.host_symbol = {{.*}}, llvm.linkage = #llvm.linkage<internal>} {
+ ! CHECK-LABEL: func.func private @_QFcapture_char_func_dummyPinternal(
+ ! CHECK-SAME: %[[VAL_0:.*]]: !fir.ref<tuple<tuple<!fir.boxproc<() -> ()>, i64>, !fir.ref<i32>>> {fir.host_assoc})
subroutine internal()
! CHECK: %[[VAL_1:.*]] = arith.constant 0 : i32
! CHECK: %[[VAL_2:.*]] = fir.coordinate_of %[[VAL_0]], %[[VAL_1]] : (!fir.ref<tuple<tuple<!fir.boxproc<() -> ()>, i64>, !fir.ref<i32>>>, i32) -> !fir.ref<tuple<!fir.boxproc<() -> ()>, i64>>
! CHECK: %[[VAL_3:.*]] = fir.load %[[VAL_2]] : !fir.ref<tuple<!fir.boxproc<() -> ()>, i64>>
! CHECK: %[[VAL_4:.*]] = arith.constant 1 : i32
! CHECK: %[[VAL_5:.*]] = fir.coordinate_of %[[VAL_0]], %[[VAL_4]] : (!fir.ref<tuple<tuple<!fir.boxproc<() -> ()>, i64>, !fir.ref<i32>>>, i32) -> !fir.llvm_ptr<!fir.ref<i32>>
- ! CHECK: %[[VAL_6:.*]] = fir.load %[[VAL_5]] : !fir.llvm_ptr<!fir.ref<i32>>
+ ! CHECK: %[[VAL_6_ref:.*]] = fir.load %[[VAL_5]] : !fir.llvm_ptr<!fir.ref<i32>>
+ ! CHECK: %[[VAL_6:.*]]:2 = hlfir.declare %[[VAL_6_ref]] {{.*}}uniq_name = "_QFcapture_char_func_dummyEn"
! CHECK: %[[VAL_12:.*]] = fir.extract_value %[[VAL_3]], [0 : index] : (tuple<!fir.boxproc<() -> ()>, i64>) -> !fir.boxproc<() -> ()>
! CHECK: %[[VAL_13:.*]] = fir.box_addr %[[VAL_12]] : (!fir.boxproc<() -> ()>) -> (() -> ())
- ! CHECK: %[[VAL_14:.*]] = fir.load %[[VAL_6]] : !fir.ref<i32>
- ! CHECK: %[[VAL_15:.*]] = fir.convert %[[VAL_14]] : (i32) -> i64
- ! CHECK: %[[VAL_16:.*]] = fir.convert %[[VAL_15]] : (i64) -> index
- ! CHECK: %[[C0:.*]] = arith.constant 0 : index
- ! CHECK: %[[CMPI:.*]] = arith.cmpi sgt, %[[VAL_16]], %[[C0]] : index
- ! CHECK: %[[SELECT:.*]] = arith.select %[[CMPI]], %[[VAL_16]], %[[C0]] : index
- ! CHECK: %[[VAL_17:.*]] = llvm.intr.stacksave : !llvm.ptr
- ! CHECK: %[[VAL_18:.*]] = fir.alloca !fir.char<1,?>(%[[SELECT]] : index) {bindc_name = ".result"}
- ! CHECK: %[[VAL_19:.*]] = fir.convert %[[VAL_13]] : (() -> ()) -> ((!fir.ref<!fir.char<1,?>>, index) -> !fir.boxchar<1>)
- ! CHECK: %[[VAL_20:.*]] = fir.call %[[VAL_19]](%[[VAL_18]], %[[SELECT]]) {{.*}}: (!fir.ref<!fir.char<1,?>>, index) -> !fir.boxchar<1>
+ ! CHECK: %[[VAL_14:.*]] = fir.load %[[VAL_6]]#0 : !fir.ref<i32>
print *, char_func_dummy()
end subroutine
end subroutine
-! CHECK-LABEL: func @_QPcapture_char_func_assumed_dummy(
+! CHECK-LABEL: func.func @_QPcapture_char_func_assumed_dummy(
! CHECK-SAME: %[[VAL_0:.*]]: tuple<!fir.boxproc<() -> ()>, i64> {fir.char_proc}) {
subroutine capture_char_func_assumed_dummy(char_func_dummy)
character(*),external :: char_func_dummy
@@ -55,44 +47,43 @@ subroutine capture_char_func_assumed_dummy(char_func_dummy)
! CHECK: fir.call @_QFcapture_char_func_assumed_dummyPinternal(%[[VAL_1]]) {{.*}}: (!fir.ref<tuple<tuple<!fir.boxproc<() -> ()>, i64>>>) -> ()
call internal()
contains
-! CHECK-LABEL: func private @_QFcapture_char_func_assumed_dummyPinternal(
-! CHECK-SAME: %[[VAL_0:.*]]: !fir.ref<tuple<tuple<!fir.boxproc<() -> ()>, i64>>> {fir.host_assoc}) attributes {fir.host_symbol = {{.*}}, llvm.linkage = #llvm.linkage<internal>} {
+! CHECK-LABEL: func.func private @_QFcapture_char_func_assumed_dummyPinternal(
+! CHECK-SAME: %[[VAL_0:.*]]: !fir.ref<tuple<tuple<!fir.boxproc<() -> ()>, i64>>> {fir.host_assoc})
subroutine internal()
! CHECK: %[[VAL_1:.*]] = arith.constant 0 : i32
! CHECK: %[[VAL_2:.*]] = fir.coordinate_of %[[VAL_0]], %[[VAL_1]] : (!fir.ref<tuple<tuple<!fir.boxproc<() -> ()>, i64>>>, i32) -> !fir.ref<tuple<!fir.boxproc<() -> ()>, i64>>
! CHECK: %[[VAL_3:.*]] = fir.load %[[VAL_2]] : !fir.ref<tuple<!fir.boxproc<() -> ()>, i64>>
! CHECK: %[[VAL_9:.*]] = fir.extract_value %[[VAL_3]], [0 : index] : (tuple<!fir.boxproc<() -> ()>, i64>) -> !fir.boxproc<() -> ()>
! CHECK: %[[VAL_10:.*]] = fir.box_addr %[[VAL_9]] : (!fir.boxproc<() -> ()>) -> (() -> ())
-! CHECK: %[[VAL_11:.*]] = fir.extract_value %[[VAL_3]], [1 : index] : (tuple<!fir.boxproc<() -> ()>, i64>) -> i64
-! CHECK: %[[VAL_12:.*]] = llvm.intr.stacksave : !llvm.ptr
-! CHECK: %[[VAL_13:.*]] = fir.alloca !fir.char<1,?>(%[[VAL_11]] : i64) {bindc_name = ".result"}
-! CHECK: %[[VAL_14:.*]] = fir.convert %[[VAL_10]] : (() -> ()) -> ((!fir.ref<!fir.char<1,?>>, index) -> !fir.boxchar<1>)
-! CHECK: %[[VAL_15:.*]] = fir.convert %[[VAL_11]] : (i64) -> index
-! CHECK: %[[VAL_16:.*]] = fir.call %[[VAL_14]](%[[VAL_13]], %[[VAL_15]]) {{.*}}: (!fir.ref<!fir.char<1,?>>, index) -> !fir.boxchar<1>
print *, char_func_dummy()
end subroutine
end subroutine
-! CHECK-LABEL: func @_QPcapture_char_func(
-! CHECK-SAME: %[[VAL_0:.*]]: !fir.ref<i32> {fir.bindc_name = "n"}) {
+! CHECK-LABEL: func.func @_QPcapture_char_func(
+! CHECK-SAME: %[[VAL_0_arg:.*]]: !fir.ref<i32> {fir.bindc_name = "n"}) {
subroutine capture_char_func(n)
character(n), external :: char_func
+! CHECK: %[[VAL_0:.*]]:2 = hlfir.declare %[[VAL_0_arg]] {{.*}}uniq_name = "_QFcapture_char_funcEn"
! CHECK: %[[VAL_1:.*]] = fir.alloca tuple<!fir.ref<i32>>
! CHECK: %[[VAL_2:.*]] = arith.constant 0 : i32
! CHECK: %[[VAL_3:.*]] = fir.coordinate_of %[[VAL_1]], %[[VAL_2]] : (!fir.ref<tuple<!fir.ref<i32>>>, i32) -> !fir.llvm_ptr<!fir.ref<i32>>
-! CHECK: fir.store %[[VAL_0]] to %[[VAL_3]] : !fir.llvm_ptr<!fir.ref<i32>>
+! CHECK: fir.store %[[VAL_0]]#0 to %[[VAL_3]] : !fir.llvm_ptr<!fir.ref<i32>>
! CHECK: fir.call @_QFcapture_char_funcPinternal(%[[VAL_1]]) {{.*}}: (!fir.ref<tuple<!fir.ref<i32>>>) -> ()
call internal()
contains
-! CHECK-LABEL: func private @_QFcapture_char_funcPinternal(
+! CHECK-LABEL: func.func private @_QFcapture_char_funcPinternal(
! CHECK-SAME: %[[VAL_0:.*]]: !fir.ref<tuple<!fir.ref<i32>>> {fir.host_assoc})
subroutine internal()
+ ! CHECK: %[[VAL_1:.*]] = arith.constant 0 : i32
+ ! CHECK: %[[VAL_2:.*]] = fir.coordinate_of %[[VAL_0]], %[[VAL_1]] : (!fir.ref<tuple<!fir.ref<i32>>>, i32) -> !fir.llvm_ptr<!fir.ref<i32>>
+ ! CHECK: %[[VAL_3_ref:.*]] = fir.load %[[VAL_2]] : !fir.llvm_ptr<!fir.ref<i32>>
+ ! CHECK: %[[VAL_3:.*]]:2 = hlfir.declare %[[VAL_3_ref]] {{.*}}uniq_name = "_QFcapture_char_funcEn"
print *, char_func()
end subroutine
end subroutine
-! CHECK-LABEL: func @_QPcapture_array_func(
-! CHECK-SAME: %[[VAL_0:.*]]: !fir.ref<i32> {fir.bindc_name = "n"}) {
+! CHECK-LABEL: func.func @_QPcapture_array_func(
+! CHECK-SAME: %[[VAL_0_arg:.*]]: !fir.ref<i32> {fir.bindc_name = "n"}) {
subroutine capture_array_func(n)
integer :: n
interface
@@ -101,31 +92,22 @@ function array_func()
integer :: array_func(n)
end function
end interface
+! CHECK: %[[VAL_0:.*]]:2 = hlfir.declare %[[VAL_0_arg]] {{.*}}uniq_name = "_QFcapture_array_funcEn"
! CHECK: %[[VAL_1:.*]] = fir.alloca tuple<!fir.ref<i32>>
! CHECK: %[[VAL_2:.*]] = arith.constant 0 : i32
! CHECK: %[[VAL_3:.*]] = fir.coordinate_of %[[VAL_1]], %[[VAL_2]] : (!fir.ref<tuple<!fir.ref<i32>>>, i32) -> !fir.llvm_ptr<!fir.ref<i32>>
-! CHECK: fir.store %[[VAL_0]] to %[[VAL_3]] : !fir.llvm_ptr<!fir.ref<i32>>
+! CHECK: fir.store %[[VAL_0]]#0 to %[[VAL_3]] : !fir.llvm_ptr<!fir.ref<i32>>
! CHECK: fir.call @_QFcapture_array_funcPinternal(%[[VAL_1]]) {{.*}}: (!fir.ref<tuple<!fir.ref<i32>>>) -> ()
call internal()
contains
subroutine internal()
-! CHECK-LABEL: func private @_QFcapture_array_funcPinternal(
-! CHECK-SAME: %[[VAL_0:.*]]: !fir.ref<tuple<!fir.ref<i32>>> {fir.host_assoc}) attributes {fir.host_symbol = {{.*}}, llvm.linkage = #llvm.linkage<internal>} {
+! CHECK-LABEL: func.func private @_QFcapture_array_funcPinternal(
+! CHECK-SAME: %[[VAL_0:.*]]: !fir.ref<tuple<!fir.ref<i32>>> {fir.host_assoc})
! CHECK: %[[VAL_1:.*]] = arith.constant 0 : i32
! CHECK: %[[VAL_2:.*]] = fir.coordinate_of %[[VAL_0]], %[[VAL_1]] : (!fir.ref<tuple<!fir.ref<i32>>>, i32) -> !fir.llvm_ptr<!fir.ref<i32>>
-! CHECK: %[[VAL_3:.*]] = fir.load %[[VAL_2]] : !fir.llvm_ptr<!fir.ref<i32>>
-! CHECK: %[[VAL_9:.*]] = fir.load %[[VAL_3]] : !fir.ref<i32>
-! CHECK: %[[VAL_10:.*]] = fir.convert %[[VAL_9]] : (i32) -> i64
-! CHECK: %[[VAL_11:.*]] = arith.constant 1 : i64
-! CHECK: %[[VAL_12:.*]] = arith.subi %[[VAL_10]], %[[VAL_11]] : i64
-! CHECK: %[[VAL_13:.*]] = arith.constant 1 : i64
-! CHECK: %[[VAL_14:.*]] = arith.addi %[[VAL_12]], %[[VAL_13]] : i64
-! CHECK: %[[VAL_15:.*]] = fir.convert %[[VAL_14]] : (i64) -> index
-! CHECK: %[[C0:.*]] = arith.constant 0 : index
-! CHECK: %[[CMPI:.*]] = arith.cmpi sgt, %[[VAL_15]], %[[C0]] : index
-! CHECK: %[[SELECT:.*]] = arith.select %[[CMPI]], %[[VAL_15]], %[[C0]] : index
-! CHECK: %[[VAL_16:.*]] = llvm.intr.stacksave : !llvm.ptr
-! CHECK: %[[VAL_17:.*]] = fir.alloca !fir.array<?xi32>, %[[SELECT]] {bindc_name = ".result"}
+! CHECK: %[[VAL_3_ref:.*]] = fir.load %[[VAL_2]] : !fir.llvm_ptr<!fir.ref<i32>>
+! CHECK: %[[VAL_3:.*]]:2 = hlfir.declare %[[VAL_3_ref]] {{.*}}uniq_name = "_QFcapture_array_funcEn"
+! CHECK: %[[VAL_9:.*]] = fir.load %[[VAL_3]]#0 : !fir.ref<i32>
print *, array_func()
end subroutine
end subroutine
@@ -139,14 +121,14 @@ function return_char(n)
end function
end module
-! CHECK-LABEL: func @_QPuse_module() {
+! CHECK-LABEL: func.func @_QPuse_module() {
subroutine use_module()
! verify there is no capture triggers by the interface.
use define_char_func
-! CHECK: fir.call @_QFuse_modulePinternal() {{.*}}: () -> ()
+! CHECK: fir.call @_QFuse_modulePinternal()
call internal()
contains
-! CHECK-LABEL: func private @_QFuse_modulePinternal() {{.*}} {
+! CHECK-LABEL: func.func private @_QFuse_modulePinternal()
subroutine internal()
print *, return_char(42)
end subroutine
diff --git a/flang/test/Lower/host-associated.f90 b/flang/test/Lower/host-associated.f90
index d1f3b3566fe8e..8f84eb4e35011 100644
--- a/flang/test/Lower/host-associated.f90
+++ b/flang/test/Lower/host-associated.f90
@@ -1,5 +1,5 @@
! Test internal procedure host association lowering.
-! RUN: bbc -hlfir=false -fwrapv %s -o - | FileCheck %s
+! RUN: %flang_fc1 -emit-hlfir %s -o - | FileCheck %s
! -----------------------------------------------------------------------------
! Test non character intrinsic scalars
@@ -7,24 +7,24 @@
!!! Test scalar (with implicit none)
-! CHECK-LABEL: func @_QPtest1(
+! CHECK-LABEL: func.func @_QPtest1() {
subroutine test1
implicit none
integer i
- ! CHECK-DAG: %[[i:.*]] = fir.alloca i32 {{.*}}uniq_name = "_QFtest1Ei"
- ! CHECK-DAG: %[[tup:.*]] = fir.alloca tuple<!fir.ref<i32>>
- ! CHECK: %[[addr:.*]] = fir.coordinate_of %[[tup]], %c0
- ! CHECK: fir.store %[[i]] to %[[addr]] : !fir.llvm_ptr<!fir.ref<i32>>
- ! CHECK: fir.call @_QFtest1Ptest1_internal(%[[tup]]) {{.*}}: (!fir.ref<tuple<!fir.ref<i32>>>) -> ()
+ ! CHECK: %[[i_alloca:.*]] = fir.alloca i32 {{.*}}uniq_name = "_QFtest1Ei"
+ ! CHECK: %[[i:.*]]:2 = hlfir.declare %[[i_alloca]] {{.*}}uniq_name = "_QFtest1Ei"
+ ! CHECK: %[[tup:.*]] = fir.alloca tuple<!fir.ref<i32>>
+ ! CHECK: fir.store %[[i]]#0 to %{{.*}} : !fir.llvm_ptr<!fir.ref<i32>>
+ ! CHECK: fir.call @_QFtest1Ptest1_internal(%[[tup]])
call test1_internal
print *, i
contains
- ! CHECK-LABEL: func private @_QFtest1Ptest1_internal(
- ! CHECK-SAME: %[[arg:[^:]*]]: !fir.ref<tuple<!fir.ref<i32>>> {fir.host_assoc}) attributes {fir.host_symbol = {{.*}}, llvm.linkage = #llvm.linkage<internal>} {
- ! CHECK: %[[iaddr:.*]] = fir.coordinate_of %[[arg]], %c0
- ! CHECK: %[[i:.*]] = fir.load %[[iaddr]] : !fir.llvm_ptr<!fir.ref<i32>>
- ! CHECK: %[[val:.*]] = fir.call @_QPifoo() {{.*}}: () -> i32
- ! CHECK: fir.store %[[val]] to %[[i]] : !fir.ref<i32>
+ ! CHECK-LABEL: func.func private @_QFtest1Ptest1_internal(
+ ! CHECK-SAME: %[[arg:.*]]: !fir.ref<tuple<!fir.ref<i32>>> {fir.host_assoc})
+ ! CHECK: %[[i_ref:.*]] = fir.load %{{.*}} : !fir.llvm_ptr<!fir.ref<i32>>
+ ! CHECK: %[[i:.*]]:2 = hlfir.declare %[[i_ref]] {{.*}}uniq_name = "_QFtest1Ei"
+ ! CHECK: %[[val:.*]] = fir.call @_QPifoo()
+ ! CHECK: hlfir.assign %[[val]] to %[[i]]#0 : i32, !fir.ref<i32>
subroutine test1_internal
integer, external :: ifoo
i = ifoo()
@@ -33,44 +33,33 @@ end subroutine test1
!!! Test scalar
-! CHECK-LABEL: func @_QPtest2() {
+! CHECK-LABEL: func.func @_QPtest2() {
subroutine test2
a = 1.0
b = 2.0
- ! CHECK: %[[tup:.*]] = fir.alloca tuple<!fir.ref<f32>, !fir.ref<f32>>
- ! CHECK: %[[a0:.*]] = fir.coordinate_of %[[tup]], %c0
- ! CHECK: fir.store %{{.*}} to %[[a0]] : !fir.llvm_ptr<!fir.ref<f32>>
- ! CHECK: %[[b0:.*]] = fir.coordinate_of %[[tup]], %c1
- ! CHECK: fir.store %{{.*}} to %[[b0]] : !fir.llvm_ptr<!fir.ref<f32>>
- ! CHECK: fir.call @_QFtest2Ptest2_internal(%[[tup]]) {{.*}}: (!fir.ref<tuple<!fir.ref<f32>, !fir.ref<f32>>>) -> ()
+ ! CHECK: hlfir.declare %{{.*}}uniq_name = "_QFtest2Ea"
+ ! CHECK: hlfir.declare %{{.*}}uniq_name = "_QFtest2Eb"
+ ! CHECK: fir.alloca tuple<!fir.ref<f32>, !fir.ref<f32>>
+ ! CHECK: fir.call @_QFtest2Ptest2_internal
call test2_internal
print *, a, b
contains
- ! CHECK-LABEL: func private @_QFtest2Ptest2_internal(
- ! CHECK-SAME: %[[arg:[^:]*]]: !fir.ref<tuple<!fir.ref<f32>, !fir.ref<f32>>> {fir.host_assoc}) attributes {fir.host_symbol = {{.*}}, llvm.linkage = #llvm.linkage<internal>} {
+ ! CHECK-LABEL: func.func private @_QFtest2Ptest2_internal(
+ ! CHECK-SAME: %[[arg:.*]]: !fir.ref<tuple<!fir.ref<f32>, !fir.ref<f32>>> {fir.host_assoc})
subroutine test2_internal
- ! CHECK: %[[a:.*]] = fir.coordinate_of %[[arg]], %c0
- ! CHECK: %[[aa:.*]] = fir.load %[[a]] : !fir.llvm_ptr<!fir.ref<f32>>
- ! CHECK: %[[b:.*]] = fir.coordinate_of %[[arg]], %c1
- ! CHECK: %{{.*}} = fir.load %[[b]] : !fir.llvm_ptr<!fir.ref<f32>>
- ! CHECK: fir.alloca
- ! CHECK: fir.load %[[aa]] : !fir.ref<f32>
+ ! CHECK: hlfir.declare %{{.*}}uniq_name = "_QFtest2Ea"
+ ! CHECK: hlfir.declare %{{.*}}uniq_name = "_QFtest2Eb"
c = a
a = b
b = c
call test2_inner
end subroutine test2_internal
- ! CHECK-LABEL: func private @_QFtest2Ptest2_inner(
- ! CHECK-SAME: %[[arg:[^:]*]]: !fir.ref<tuple<!fir.ref<f32>, !fir.ref<f32>>> {fir.host_assoc}) attributes {fir.host_symbol = {{.*}}, llvm.linkage = #llvm.linkage<internal>} {
+ ! CHECK-LABEL: func.func private @_QFtest2Ptest2_inner(
+ ! CHECK-SAME: %[[arg:.*]]: !fir.ref<tuple<!fir.ref<f32>, !fir.ref<f32>>> {fir.host_assoc})
subroutine test2_inner
- ! CHECK: %[[a:.*]] = fir.coordinate_of %[[arg]], %c0
- ! CHECK: %[[aa:.*]] = fir.load %[[a]] : !fir.llvm_ptr<!fir.ref<f32>>
- ! CHECK: %[[b:.*]] = fir.coordinate_of %[[arg]], %c1
- ! CHECK: %[[bb:.*]] = fir.load %[[b]] : !fir.llvm_ptr<!fir.ref<f32>>
- ! CHECK-DAG: %[[bd:.*]] = fir.load %[[bb]] : !fir.ref<f32>
- ! CHECK-DAG: %[[ad:.*]] = fir.load %[[aa]] : !fir.ref<f32>
- ! CHECK: %{{.*}} = arith.cmpf ogt, %[[ad]], %[[bd]] {{.*}} : f32
+ ! CHECK: hlfir.declare %{{.*}}uniq_name = "_QFtest2Ea"
+ ! CHECK: hlfir.declare %{{.*}}uniq_name = "_QFtest2Eb"
if (a > b) then
b = b + 2.0
end if
@@ -78,29 +67,24 @@ end subroutine test2_inner
end subroutine test2
! -----------------------------------------------------------------------------
-! Test non character scalars
+! Test character scalars
! -----------------------------------------------------------------------------
-! CHECK-LABEL: func @_QPtest6(
-! CHECK-SAME: %[[c:.*]]: !fir.boxchar<1>
+! CHECK-LABEL: func.func @_QPtest6(
subroutine test6(c)
character(*) :: c
- ! CHECK: %[[cunbox:.*]]:2 = fir.unboxchar %arg0 : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1,?>>, index)
- ! CHECK: %[[tup:.*]] = fir.alloca tuple<!fir.boxchar<1>>
- ! CHECK: %[[coor:.*]] = fir.coordinate_of %[[tup]], %c0{{.*}} : (!fir.ref<tuple<!fir.boxchar<1>>>, i32) -> !fir.ref<!fir.boxchar<1>>
- ! CHECK: %[[emboxchar:.*]] = fir.emboxchar %[[cunbox]]#0, %[[cunbox]]#1 : (!fir.ref<!fir.char<1,?>>, index) -> !fir.boxchar<1>
- ! CHECK: fir.store %[[emboxchar]] to %[[coor]] : !fir.ref<!fir.boxchar<1>>
- ! CHECK: fir.call @_QFtest6Ptest6_inner(%[[tup]]) {{.*}}: (!fir.ref<tuple<!fir.boxchar<1>>>) -> ()
+ ! CHECK: hlfir.declare %{{.*}}uniq_name = "_QFtest6Ec"
+ ! CHECK: fir.alloca tuple<!fir.boxchar<1>>
+ ! CHECK: fir.call @_QFtest6Ptest6_inner
call test6_inner
print *, c
contains
- ! CHECK-LABEL: func private @_QFtest6Ptest6_inner(
- ! CHECK-SAME: %[[tup:.*]]: !fir.ref<tuple<!fir.boxchar<1>>> {fir.host_assoc}) attributes {fir.host_symbol = {{.*}}, llvm.linkage = #llvm.linkage<internal>} {
+ ! CHECK-LABEL: func.func private @_QFtest6Ptest6_inner(
+ ! CHECK-SAME: %[[tup:.*]]: !fir.ref<tuple<!fir.boxchar<1>>> {fir.host_assoc})
subroutine test6_inner
- ! CHECK: %[[coor:.*]] = fir.coordinate_of %[[tup]], %c0{{.*}} : (!fir.ref<tuple<!fir.boxchar<1>>>, i32) -> !fir.ref<!fir.boxchar<1>>
- ! CHECK: %[[load:.*]] = fir.load %[[coor]] : !fir.ref<!fir.boxchar<1>>
- ! CHECK: fir.unboxchar %[[load]] : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1,?>>, index)
+ ! CHECK: %[[load:.*]] = fir.load %{{.*}} : !fir.ref<!fir.boxchar<1>>
+ ! CHECK: hlfir.declare %{{.*}}uniq_name = "_QFtest6Ec"
c = "Hi there"
end subroutine test6_inner
end subroutine test6
@@ -109,95 +93,42 @@ end subroutine test6
! Test non allocatable and pointer arrays
! -----------------------------------------------------------------------------
-! CHECK-LABEL: func @_QPtest3(
-! CHECK-SAME: %[[p:[^:]+]]: !fir.box<!fir.array<?xf32>>{{.*}}, %[[q:.*]]: !fir.box<!fir.array<?xf32>>{{.*}}, %[[i:.*]]: !fir.ref<i64>
+! CHECK-LABEL: func.func @_QPtest3(
subroutine test3(p,q,i)
integer(8) :: i
real :: p(i:)
real :: q(:)
- ! CHECK: %[[iload:.*]] = fir.load %[[i]] : !fir.ref<i64>
- ! CHECK: %[[icast:.*]] = fir.convert %[[iload]] : (i64) -> index
- ! CHECK: %[[tup:.*]] = fir.alloca tuple<!fir.box<!fir.array<?xf32>>, !fir.box<!fir.array<?xf32>>>
- ! CHECK: %[[ptup:.*]] = fir.coordinate_of %[[tup]], %c0{{.*}} : (!fir.ref<tuple<!fir.box<!fir.array<?xf32>>, !fir.box<!fir.array<?xf32>>>>, i32) -> !fir.ref<!fir.box<!fir.array<?xf32>>>
- ! CHECK: %[[pshift:.*]] = fir.shift %[[icast]] : (index) -> !fir.shift<1>
- ! CHECK: %[[pbox:.*]] = fir.rebox %[[p]](%[[pshift]]) : (!fir.box<!fir.array<?xf32>>, !fir.shift<1>) -> !fir.box<!fir.array<?xf32>>
- ! CHECK: fir.store %[[pbox]] to %[[ptup]] : !fir.ref<!fir.box<!fir.array<?xf32>>>
- ! CHECK: %[[qtup:.*]] = fir.coordinate_of %[[tup]], %c1{{.*}} : (!fir.ref<tuple<!fir.box<!fir.array<?xf32>>, !fir.box<!fir.array<?xf32>>>>, i32) -> !fir.ref<!fir.box<!fir.array<?xf32>>>
- ! CHECK: %[[qbox:.*]] = fir.rebox %[[q]] : (!fir.box<!fir.array<?xf32>>) -> !fir.box<!fir.array<?xf32>>
- ! CHECK: fir.store %[[qbox]] to %[[qtup]] : !fir.ref<!fir.box<!fir.array<?xf32>>>
-
- i = i + 1
- q = -42.0
-
- ! CHECK: fir.call @_QFtest3Ptest3_inner(%[[tup]]) {{.*}}: (!fir.ref<tuple<!fir.box<!fir.array<?xf32>>, !fir.box<!fir.array<?xf32>>>>) -> ()
+ ! CHECK-DAG: hlfir.declare %{{.*}}uniq_name = "_QFtest3Ei"
+ ! CHECK-DAG: hlfir.declare %{{.*}}uniq_name = "_QFtest3Ep"
+ ! CHECK-DAG: hlfir.declare %{{.*}}uniq_name = "_QFtest3Eq"
+ ! CHECK: fir.alloca tuple<!fir.box<!fir.array<?xf32>>, !fir.box<!fir.array<?xf32>>>
+ ! CHECK: fir.call @_QFtest3Ptest3_inner
call test3_inner
-
- if (p(2) .ne. -42.0) then
- print *, "failed"
- end if
-
contains
- ! CHECK-LABEL: func private @_QFtest3Ptest3_inner(
- ! CHECK-SAME: %[[tup:.*]]: !fir.ref<tuple<!fir.box<!fir.array<?xf32>>, !fir.box<!fir.array<?xf32>>>> {fir.host_assoc}) attributes {fir.host_symbol = {{.*}}, llvm.linkage = #llvm.linkage<internal>} {
+ ! CHECK-LABEL: func.func private @_QFtest3Ptest3_inner(
+ ! CHECK-SAME: %[[tup:.*]]: !fir.ref<tuple<!fir.box<!fir.array<?xf32>>, !fir.box<!fir.array<?xf32>>>> {fir.host_assoc})
subroutine test3_inner
- ! CHECK: %[[pcoor:.*]] = fir.coordinate_of %[[tup]], %c0{{.*}} : (!fir.ref<tuple<!fir.box<!fir.array<?xf32>>, !fir.box<!fir.array<?xf32>>>>, i32) -> !fir.ref<!fir.box<!fir.array<?xf32>>>
- ! CHECK: %[[p:.*]] = fir.load %[[pcoor]] : !fir.ref<!fir.box<!fir.array<?xf32>>>
- ! CHECK: %[[pbounds:.]]:3 = fir.box_dims %[[p]], %c0{{.*}} : (!fir.box<!fir.array<?xf32>>, index) -> (index, index, index)
- ! CHECK: %[[qcoor:.*]] = fir.coordinate_of %[[tup]], %c1{{.*}} : (!fir.ref<tuple<!fir.box<!fir.array<?xf32>>, !fir.box<!fir.array<?xf32>>>>, i32) -> !fir.ref<!fir.box<!fir.array<?xf32>>>
- ! CHECK: %[[q:.*]] = fir.load %[[qcoor]] : !fir.ref<!fir.box<!fir.array<?xf32>>>
- ! CHECK: %[[qbounds:.]]:3 = fir.box_dims %[[q]], %c0{{.*}} : (!fir.box<!fir.array<?xf32>>, index) -> (index, index, index)
-
-
- ! CHECK: %[[qlb:.*]] = fir.convert %[[qbounds]]#0 : (index) -> i64
- ! CHECK: %[[qoffset:.*]] = arith.subi %c1{{.*}}, %[[qlb]] : i64
- ! CHECK: %[[qelt:.*]] = fir.coordinate_of %[[q]], %[[qoffset]] : (!fir.box<!fir.array<?xf32>>, i64) -> !fir.ref<f32>
- ! CHECK: %[[qload:.*]] = fir.load %[[qelt]] : !fir.ref<f32>
- ! CHECK: %[[plb:.*]] = fir.convert %[[pbounds]]#0 : (index) -> i64
- ! CHECK: %[[poffset:.*]] = arith.subi %c2{{.*}}, %[[plb]] : i64
- ! CHECK: %[[pelt:.*]] = fir.coordinate_of %[[p]], %[[poffset]] : (!fir.box<!fir.array<?xf32>>, i64) -> !fir.ref<f32>
- ! CHECK: fir.store %[[qload]] to %[[pelt]] : !fir.ref<f32>
+ ! CHECK: hlfir.declare %{{.*}}uniq_name = "_QFtest3Ep"
+ ! CHECK: hlfir.declare %{{.*}}uniq_name = "_QFtest3Eq"
p(2) = q(1)
end subroutine test3_inner
end subroutine test3
-! CHECK-LABEL: func @_QPtest3a(
-! CHECK-SAME: %[[p:.*]]: !fir.ref<!fir.array<10xf32>>{{.*}}) {
+! CHECK-LABEL: func.func @_QPtest3a(
subroutine test3a(p)
real :: p(10)
real :: q(10)
- ! CHECK: %[[q:.*]] = fir.alloca !fir.array<10xf32> {bindc_name = "q", uniq_name = "_QFtest3aEq"}
- ! CHECK: %[[tup:.*]] = fir.alloca tuple<!fir.box<!fir.array<10xf32>>, !fir.box<!fir.array<10xf32>>>
- ! CHECK: %[[ptup:.*]] = fir.coordinate_of %[[tup]], %c0{{.*}} : (!fir.ref<tuple<!fir.box<!fir.array<10xf32>>, !fir.box<!fir.array<10xf32>>>>, i32) -> !fir.ref<!fir.box<!fir.array<10xf32>>>
- ! CHECK: %[[shape:.*]] = fir.shape %c10{{.*}} : (index) -> !fir.shape<1>
- ! CHECK: %[[pbox:.*]] = fir.embox %[[p]](%[[shape]]) : (!fir.ref<!fir.array<10xf32>>, !fir.shape<1>) -> !fir.box<!fir.array<10xf32>>
- ! CHECK: fir.store %[[pbox]] to %[[ptup]] : !fir.ref<!fir.box<!fir.array<10xf32>>>
- ! CHECK: %[[qtup:.*]] = fir.coordinate_of %[[tup]], %c1{{.*}} : (!fir.ref<tuple<!fir.box<!fir.array<10xf32>>, !fir.box<!fir.array<10xf32>>>>, i32) -> !fir.ref<!fir.box<!fir.array<10xf32>>>
- ! CHECK: %[[qbox:.*]] = fir.embox %[[q]](%[[shape]]) : (!fir.ref<!fir.array<10xf32>>, !fir.shape<1>) -> !fir.box<!fir.array<10xf32>>
- ! CHECK: fir.store %[[qbox]] to %[[qtup]] : !fir.ref<!fir.box<!fir.array<10xf32>>>
-
- q = -42.0
- ! CHECK: fir.call @_QFtest3aPtest3a_inner(%[[tup]]) {{.*}}: (!fir.ref<tuple<!fir.box<!fir.array<10xf32>>, !fir.box<!fir.array<10xf32>>>>) -> ()
+ ! CHECK-DAG: hlfir.declare %{{.*}}uniq_name = "_QFtest3aEp"
+ ! CHECK-DAG: hlfir.declare %{{.*}}uniq_name = "_QFtest3aEq"
+ ! CHECK: fir.alloca tuple<!fir.box<!fir.array<10xf32>>, !fir.box<!fir.array<10xf32>>>
+ ! CHECK: fir.call @_QFtest3aPtest3a_inner
call test3a_inner
-
- if (p(1) .ne. -42.0) then
- print *, "failed"
- end if
-
contains
- ! CHECK: func private @_QFtest3aPtest3a_inner(
- ! CHECK-SAME: %[[tup:.*]]: !fir.ref<tuple<!fir.box<!fir.array<10xf32>>, !fir.box<!fir.array<10xf32>>>> {fir.host_assoc}) attributes {fir.host_symbol = {{.*}}, llvm.linkage = #llvm.linkage<internal>} {
+ ! CHECK-LABEL: func.func private @_QFtest3aPtest3a_inner(
+ ! CHECK-SAME: %[[tup:.*]]: !fir.ref<tuple<!fir.box<!fir.array<10xf32>>, !fir.box<!fir.array<10xf32>>>> {fir.host_assoc})
subroutine test3a_inner
- ! CHECK: %[[pcoor:.*]] = fir.coordinate_of %[[tup]], %c0{{.*}} : (!fir.ref<tuple<!fir.box<!fir.array<10xf32>>, !fir.box<!fir.array<10xf32>>>>, i32) -> !fir.ref<!fir.box<!fir.array<10xf32>>>
- ! CHECK: %[[p:.*]] = fir.load %[[pcoor]] : !fir.ref<!fir.box<!fir.array<10xf32>>>
- ! CHECK: %[[paddr:.*]] = fir.box_addr %[[p]] : (!fir.box<!fir.array<10xf32>>) -> !fir.ref<!fir.array<10xf32>>
- ! CHECK: %[[qcoor:.*]] = fir.coordinate_of %[[tup]], %c1{{.*}} : (!fir.ref<tuple<!fir.box<!fir.array<10xf32>>, !fir.box<!fir.array<10xf32>>>>, i32) -> !fir.ref<!fir.box<!fir.array<10xf32>>>
- ! CHECK: %[[q:.*]] = fir.load %[[qcoor]] : !fir.ref<!fir.box<!fir.array<10xf32>>>
- ! CHECK: %[[qaddr:.*]] = fir.box_addr %[[q]] : (!fir.box<!fir.array<10xf32>>) -> !fir.ref<!fir.array<10xf32>>
-
- ! CHECK: %[[qelt:.*]] = fir.coordinate_of %[[qaddr]], %c0{{.*}} : (!fir.ref<!fir.array<10xf32>>, i64) -> !fir.ref<f32>
- ! CHECK: %[[qload:.*]] = fir.load %[[qelt]] : !fir.ref<f32>
- ! CHECK: %[[pelt:.*]] = fir.coordinate_of %[[paddr]], %c0{{.*}} : (!fir.ref<!fir.array<10xf32>>, i64) -> !fir.ref<f32>
- ! CHECK: fir.store %[[qload]] to %[[pelt]] : !fir.ref<f32>
+ ! CHECK: hlfir.declare %{{.*}}uniq_name = "_QFtest3aEp"
+ ! CHECK: hlfir.declare %{{.*}}uniq_name = "_QFtest3aEq"
p(1) = q(1)
end subroutine test3a_inner
end subroutine test3a
@@ -206,39 +137,23 @@ end subroutine test3a
! Test allocatable and pointer scalars
! -----------------------------------------------------------------------------
-! CHECK-LABEL: func @_QPtest4() {
+! CHECK-LABEL: func.func @_QPtest4() {
subroutine test4
real, pointer :: p
real, allocatable, target :: ally
- ! CHECK: %[[ally:.*]] = fir.alloca !fir.box<!fir.heap<f32>> {bindc_name = "ally", fir.target, uniq_name = "_QFtest4Eally"}
- ! CHECK: %[[p:.*]] = fir.alloca !fir.box<!fir.ptr<f32>> {bindc_name = "p", uniq_name = "_QFtest4Ep"}
- ! CHECK: %[[tup:.*]] = fir.alloca tuple<!fir.ref<!fir.box<!fir.ptr<f32>>>, !fir.ref<!fir.box<!fir.heap<f32>>>>
- ! CHECK: %[[ptup:.*]] = fir.coordinate_of %[[tup]], %c0{{.*}} : (!fir.ref<tuple<!fir.ref<!fir.box<!fir.ptr<f32>>>, !fir.ref<!fir.box<!fir.heap<f32>>>>>, i32) -> !fir.llvm_ptr<!fir.ref<!fir.box<!fir.ptr<f32>>>>
- ! CHECK: fir.store %[[p]] to %[[ptup]] : !fir.llvm_ptr<!fir.ref<!fir.box<!fir.ptr<f32>>>>
- ! CHECK: %[[atup:.*]] = fir.coordinate_of %[[tup]], %c1{{.*}} : (!fir.ref<tuple<!fir.ref<!fir.box<!fir.ptr<f32>>>, !fir.ref<!fir.box<!fir.heap<f32>>>>>, i32) -> !fir.llvm_ptr<!fir.ref<!fir.box<!fir.heap<f32>>>>
- ! CHECK: fir.store %[[ally]] to %[[atup]] : !fir.llvm_ptr<!fir.ref<!fir.box<!fir.heap<f32>>>>
- ! CHECK: fir.call @_QFtest4Ptest4_inner(%[[tup]]) {{.*}}: (!fir.ref<tuple<!fir.ref<!fir.box<!fir.ptr<f32>>>, !fir.ref<!fir.box<!fir.heap<f32>>>>>) -> ()
-
+ ! CHECK-DAG: hlfir.declare %{{.*}}uniq_name = "_QFtest4Eally"
+ ! CHECK-DAG: hlfir.declare %{{.*}}uniq_name = "_QFtest4Ep"
+ ! CHECK: fir.alloca tuple<!fir.ref<!fir.box<!fir.ptr<f32>>>, !fir.ref<!fir.box<!fir.heap<f32>>>>
+ ! CHECK: fir.call @_QFtest4Ptest4_inner
allocate(ally)
ally = -42.0
call test4_inner
-
- if (p .ne. -42.0) then
- print *, "failed"
- end if
-
contains
- ! CHECK-LABEL: func private @_QFtest4Ptest4_inner(
- ! CHECK-SAME:%[[tup:.*]]: !fir.ref<tuple<!fir.ref<!fir.box<!fir.ptr<f32>>>, !fir.ref<!fir.box<!fir.heap<f32>>>>> {fir.host_assoc}) attributes {fir.host_symbol = {{.*}}, llvm.linkage = #llvm.linkage<internal>} {
+ ! CHECK-LABEL: func.func private @_QFtest4Ptest4_inner(
+ ! CHECK-SAME:%[[tup:.*]]: !fir.ref<tuple<!fir.ref<!fir.box<!fir.ptr<f32>>>, !fir.ref<!fir.box<!fir.heap<f32>>>>> {fir.host_assoc})
subroutine test4_inner
- ! CHECK: %[[ptup:.*]] = fir.coordinate_of %[[tup]], %c0{{.*}} : (!fir.ref<tuple<!fir.ref<!fir.box<!fir.ptr<f32>>>, !fir.ref<!fir.box<!fir.heap<f32>>>>>, i32) -> !fir.llvm_ptr<!fir.ref<!fir.box<!fir.ptr<f32>>>>
- ! CHECK: %[[p:.*]] = fir.load %[[ptup]] : !fir.llvm_ptr<!fir.ref<!fir.box<!fir.ptr<f32>>>>
- ! CHECK: %[[atup:.*]] = fir.coordinate_of %[[tup]], %c1{{.*}} : (!fir.ref<tuple<!fir.ref<!fir.box<!fir.ptr<f32>>>, !fir.ref<!fir.box<!fir.heap<f32>>>>>, i32) -> !fir.llvm_ptr<!fir.ref<!fir.box<!fir.heap<f32>>>>
- ! CHECK: %[[a:.*]] = fir.load %[[atup]] : !fir.llvm_ptr<!fir.ref<!fir.box<!fir.heap<f32>>>>
- ! CHECK: %[[abox:.*]] = fir.load %[[a]] : !fir.ref<!fir.box<!fir.heap<f32>>>
- ! CHECK: %[[addr:.*]] = fir.box_addr %[[abox]] : (!fir.box<!fir.heap<f32>>) -> !fir.heap<f32>
- ! CHECK: %[[ptr:.*]] = fir.embox %[[addr]] : (!fir.heap<f32>) -> !fir.box<!fir.ptr<f32>>
- ! CHECK: fir.store %[[ptr]] to %[[p]] : !fir.ref<!fir.box<!fir.ptr<f32>>>
+ ! CHECK: hlfir.declare %{{.*}}uniq_name = "_QFtest4Ep"
+ ! CHECK: hlfir.declare %{{.*}}uniq_name = "_QFtest4Eally"
p => ally
end subroutine test4_inner
end subroutine test4
@@ -247,43 +162,23 @@ end subroutine test4
! Test allocatable and pointer arrays
! -----------------------------------------------------------------------------
-! CHECK-LABEL: func @_QPtest5() {
+! CHECK-LABEL: func.func @_QPtest5() {
subroutine test5
real, pointer :: p(:)
real, allocatable, target :: ally(:)
-
- ! CHECK: %[[ally:.*]] = fir.alloca !fir.box<!fir.heap<!fir.array<?xf32>>> {bindc_name = "ally", fir.target
- ! CHECK: %[[p:.*]] = fir.alloca !fir.box<!fir.ptr<!fir.array<?xf32>>> {bindc_name = "p"
- ! CHECK: %[[tup:.*]] = fir.alloca tuple<!fir.ref<!fir.box<!fir.ptr<!fir.array<?xf32>>>>, !fir.ref<!fir.box<!fir.heap<!fir.array<?xf32>>>>>
- ! CHECK: %[[ptup:.*]] = fir.coordinate_of %[[tup]], %c0{{.*}} : (!fir.ref<tuple<!fir.ref<!fir.box<!fir.ptr<!fir.array<?xf32>>>>, !fir.ref<!fir.box<!fir.heap<!fir.array<?xf32>>>>>>, i32) -> !fir.llvm_ptr<!fir.ref<!fir.box<!fir.ptr<!fir.array<?xf32>>>>>
- ! CHECK: fir.store %[[p]] to %[[ptup]] : !fir.llvm_ptr<!fir.ref<!fir.box<!fir.ptr<!fir.array<?xf32>>>>>
- ! CHECK: %[[atup:.*]] = fir.coordinate_of %[[tup]], %c1{{.*}} : (!fir.ref<tuple<!fir.ref<!fir.box<!fir.ptr<!fir.array<?xf32>>>>, !fir.ref<!fir.box<!fir.heap<!fir.array<?xf32>>>>>>, i32) -> !fir.llvm_ptr<!fir.ref<!fir.box<!fir.heap<!fir.array<?xf32>>>>>
- ! CHECK: fir.store %[[ally]] to %[[atup]] : !fir.llvm_ptr<!fir.ref<!fir.box<!fir.heap<!fir.array<?xf32>>>>>
- ! CHECK: fir.call @_QFtest5Ptest5_inner(%[[tup]]) {{.*}}: (!fir.ref<tuple<!fir.ref<!fir.box<!fir.ptr<!fir.array<?xf32>>>>, !fir.ref<!fir.box<!fir.heap<!fir.array<?xf32>>>>>>) -> ()
-
+ ! CHECK-DAG: hlfir.declare %{{.*}}uniq_name = "_QFtest5Eally"
+ ! CHECK-DAG: hlfir.declare %{{.*}}uniq_name = "_QFtest5Ep"
+ ! CHECK: fir.alloca tuple<!fir.ref<!fir.box<!fir.ptr<!fir.array<?xf32>>>>, !fir.ref<!fir.box<!fir.heap<!fir.array<?xf32>>>>>
+ ! CHECK: fir.call @_QFtest5Ptest5_inner
allocate(ally(10))
ally = -42.0
call test5_inner
-
- if (p(1) .ne. -42.0) then
- print *, "failed"
- end if
-
contains
- ! CHECK-LABEL: func private @_QFtest5Ptest5_inner(
- ! CHECK-SAME:%[[tup:.*]]: !fir.ref<tuple<!fir.ref<!fir.box<!fir.ptr<!fir.array<?xf32>>>>, !fir.ref<!fir.box<!fir.heap<!fir.array<?xf32>>>>>> {fir.host_assoc}) attributes {fir.host_symbol = {{.*}}, llvm.linkage = #llvm.linkage<internal>} {
+ ! CHECK-LABEL: func.func private @_QFtest5Ptest5_inner(
+ ! CHECK-SAME:%[[tup:.*]]: !fir.ref<tuple<!fir.ref<!fir.box<!fir.ptr<!fir.array<?xf32>>>>, !fir.ref<!fir.box<!fir.heap<!fir.array<?xf32>>>>>> {fir.host_assoc})
subroutine test5_inner
- ! CHECK: %[[ptup:.*]] = fir.coordinate_of %[[tup]], %c0{{.*}} : (!fir.ref<tuple<!fir.ref<!fir.box<!fir.ptr<!fir.array<?xf32>>>>, !fir.ref<!fir.box<!fir.heap<!fir.array<?xf32>>>>>>, i32) -> !fir.llvm_ptr<!fir.ref<!fir.box<!fir.ptr<!fir.array<?xf32>>>>>
- ! CHECK: %[[p:.*]] = fir.load %[[ptup]] : !fir.llvm_ptr<!fir.ref<!fir.box<!fir.ptr<!fir.array<?xf32>>>>>
- ! CHECK: %[[atup:.*]] = fir.coordinate_of %[[tup]], %c1{{.*}} : (!fir.ref<tuple<!fir.ref<!fir.box<!fir.ptr<!fir.array<?xf32>>>>, !fir.ref<!fir.box<!fir.heap<!fir.array<?xf32>>>>>>, i32) -> !fir.llvm_ptr<!fir.ref<!fir.box<!fir.heap<!fir.array<?xf32>>>>>
- ! CHECK: %[[a:.*]] = fir.load %[[atup]] : !fir.llvm_ptr<!fir.ref<!fir.box<!fir.heap<!fir.array<?xf32>>>>>
- ! CHECK: %[[abox:.*]] = fir.load %[[a]] : !fir.ref<!fir.box<!fir.heap<!fir.array<?xf32>>>>
- ! CHECK-DAG: %[[adims:.*]]:3 = fir.box_dims %[[abox]], %c0{{.*}} : (!fir.box<!fir.heap<!fir.array<?xf32>>>, index) -> (index, index, index)
- ! CHECK-DAG: %[[addr:.*]] = fir.box_addr %[[abox]] : (!fir.box<!fir.heap<!fir.array<?xf32>>>) -> !fir.heap<!fir.array<?xf32>>
- ! CHECK-DAG: %[[ashape:.*]] = fir.shape_shift %[[adims]]#0, %[[adims]]#1 : (index, index) -> !fir.shapeshift<1>
-
- ! CHECK: %[[ptr:.*]] = fir.embox %[[addr]](%[[ashape]]) : (!fir.heap<!fir.array<?xf32>>, !fir.shapeshift<1>) -> !fir.box<!fir.ptr<!fir.array<?xf32>>>
- ! CHECK: fir.store %[[ptr]] to %[[p]] : !fir.ref<!fir.box<!fir.ptr<!fir.array<?xf32>>>>
+ ! CHECK: hlfir.declare %{{.*}}uniq_name = "_QFtest5Ep"
+ ! CHECK: hlfir.declare %{{.*}}uniq_name = "_QFtest5Eally"
p => ally
end subroutine test5_inner
end subroutine test5
@@ -293,76 +188,42 @@ end subroutine test5
! Test elemental internal procedure
! -----------------------------------------------------------------------------
-! CHECK-LABEL: func @_QPtest7(
-! CHECK-SAME: %[[j:.*]]: !fir.ref<i32>{{.*}}, %[[k:.*]]: !fir.box<!fir.array<?xi32>>
+! CHECK-LABEL: func.func @_QPtest7(
subroutine test7(j, k)
implicit none
integer :: j
integer :: k(:)
- ! CHECK: %[[tup:.*]] = fir.alloca tuple<!fir.ref<i32>>
- ! CHECK: %[[jtup:.*]] = fir.coordinate_of %[[tup]], %c0{{.*}} : (!fir.ref<tuple<!fir.ref<i32>>>, i32) -> !fir.llvm_ptr<!fir.ref<i32>>
- ! CHECK: fir.store %[[j]] to %[[jtup]] : !fir.llvm_ptr<!fir.ref<i32>>
-
- ! CHECK: %[[kelem:.*]] = fir.array_coor %[[k]] %{{.*}} : (!fir.box<!fir.array<?xi32>>, index) -> !fir.ref<i32>
- ! CHECK: fir.call @_QFtest7Ptest7_inner(%[[kelem]], %[[tup]]) {{.*}}: (!fir.ref<i32>, !fir.ref<tuple<!fir.ref<i32>>>) -> i32
+ ! CHECK-DAG: hlfir.declare %{{.*}}uniq_name = "_QFtest7Ej"
+ ! CHECK-DAG: hlfir.declare %{{.*}}uniq_name = "_QFtest7Ek"
+ ! CHECK: fir.alloca tuple<!fir.ref<i32>>
+ ! CHECK: fir.call @_QFtest7Ptest7_inner
k = test7_inner(k)
contains
-
-! CHECK-LABEL: func private @_QFtest7Ptest7_inner(
-! CHECK-SAME: %[[i:.*]]: !fir.ref<i32>{{.*}}, %[[tup:.*]]: !fir.ref<tuple<!fir.ref<i32>>> {fir.host_assoc}) -> i32 attributes {fir.host_symbol = {{.*}}, fir.proc_attrs = #fir.proc_attrs<elemental, pure>, llvm.linkage = #llvm.linkage<internal>} {
+! CHECK-LABEL: func.func private @_QFtest7Ptest7_inner(
+! CHECK-SAME: %{{.*}}, %[[tup:.*]]: !fir.ref<tuple<!fir.ref<i32>>> {fir.host_assoc})
elemental integer function test7_inner(i)
implicit none
integer, intent(in) :: i
- ! CHECK: %[[jtup:.*]] = fir.coordinate_of %[[tup]], %c0{{.*}} : (!fir.ref<tuple<!fir.ref<i32>>>, i32) -> !fir.llvm_ptr<!fir.ref<i32>>
- ! CHECK: %[[jptr:.*]] = fir.load %[[jtup]] : !fir.llvm_ptr<!fir.ref<i32>>
- ! CHECK-DAG: %[[iload:.*]] = fir.load %[[i]] : !fir.ref<i32>
- ! CHECK-DAG: %[[jload:.*]] = fir.load %[[jptr]] : !fir.ref<i32>
- ! CHECK: addi %[[iload]], %[[jload]] : i32
+ ! CHECK: hlfir.declare %{{.*}}uniq_name = "_QFtest7Ej"
test7_inner = i + j
end function
end subroutine
subroutine issue990()
- ! Test that host symbols used in statement functions inside an internal
- ! procedure are correctly captured from the host.
implicit none
integer :: captured
call bar()
contains
-! CHECK-LABEL: func private @_QFissue990Pbar(
-! CHECK-SAME: %[[tup:.*]]: !fir.ref<tuple<!fir.ref<i32>>> {fir.host_assoc}) attributes {fir.host_symbol = {{.*}}, llvm.linkage = #llvm.linkage<internal>} {
+! CHECK-LABEL: func.func private @_QFissue990Pbar(
+! CHECK-SAME: %[[tup:.*]]: !fir.ref<tuple<!fir.ref<i32>>> {fir.host_assoc})
subroutine bar()
integer :: stmt_func, i
stmt_func(i) = i + captured
- ! CHECK: %[[tupAddr:.*]] = fir.coordinate_of %[[tup]], %c0{{.*}} : (!fir.ref<tuple<!fir.ref<i32>>>, i32) -> !fir.llvm_ptr<!fir.ref<i32>>
- ! CHECK: %[[addr:.*]] = fir.load %[[tupAddr]] : !fir.llvm_ptr<!fir.ref<i32>>
- ! CHECK: %[[value:.*]] = fir.load %[[addr]] : !fir.ref<i32>
- ! CHECK: arith.addi %{{.*}}, %[[value]] : i32
+ ! CHECK: hlfir.declare %{{.*}}uniq_name = "_QFissue990Ecaptured"
print *, stmt_func(10)
end subroutine
end subroutine
-subroutine issue990b()
- ! Test when an internal procedure uses a statement function from its host
- ! which uses host variables that are otherwise not used by the internal
- ! procedure.
- implicit none
- integer :: captured, captured_stmt_func, i
- captured_stmt_func(i) = i + captured
- call bar()
-contains
-! CHECK-LABEL: func private @_QFissue990bPbar(
-! CHECK-SAME: %[[tup:.*]]: !fir.ref<tuple<!fir.ref<i32>>> {fir.host_assoc}) attributes {fir.host_symbol = {{.*}}, llvm.linkage = #llvm.linkage<internal>} {
-subroutine bar()
- ! CHECK: %[[tupAddr:.*]] = fir.coordinate_of %[[tup]], %c0{{.*}} : (!fir.ref<tuple<!fir.ref<i32>>>, i32) -> !fir.llvm_ptr<!fir.ref<i32>>
- ! CHECK: %[[addr:.*]] = fir.load %[[tupAddr]] : !fir.llvm_ptr<!fir.ref<i32>>
- ! CHECK: %[[value:.*]] = fir.load %[[addr]] : !fir.ref<i32>
- ! CHECK: arith.addi %{{.*}}, %[[value]] : i32
- print *, captured_stmt_func(10)
-end subroutine
-end subroutine
-
-! Test capture of dummy procedure functions.
subroutine test8(dummy_proc)
implicit none
interface
@@ -372,298 +233,78 @@ real function dummy_proc(x)
end interface
call bar()
contains
-! CHECK-LABEL: func private @_QFtest8Pbar(
-! CHECK-SAME: %[[tup:.*]]: !fir.ref<tuple<!fir.boxproc<() -> ()>>> {fir.host_assoc}) attributes {fir.host_symbol = {{.*}}, llvm.linkage = #llvm.linkage<internal>} {
+! CHECK-LABEL: func.func private @_QFtest8Pbar(
+! CHECK-SAME: %[[tup:.*]]: !fir.ref<tuple<!fir.boxproc<() -> ()>>> {fir.host_assoc})
subroutine bar()
- ! CHECK: %[[tupAddr:.*]] = fir.coordinate_of %[[tup]], %c0{{.*}} : (!fir.ref<tuple<!fir.boxproc<() -> ()>>>, i32) -> !fir.ref<!fir.boxproc<() -> ()>>
- ! CHECK: %[[dummyProc:.*]] = fir.load %[[tupAddr]] : !fir.ref<!fir.boxproc<() -> ()>>
- ! CHECK: %[[dummyProcCast:.*]] = fir.box_addr %[[dummyProc]] : (!fir.boxproc<() -> ()>) -> ((!fir.ref<f32>) -> f32)
- ! CHECK: fir.call %[[dummyProcCast]](%{{.*}}) {{.*}}: (!fir.ref<f32>) -> f32
+ ! CHECK: fir.load %{{.*}} : !fir.ref<!fir.boxproc<() -> ()>>
print *, dummy_proc(42.)
end subroutine
end subroutine
-! Test capture of dummy subroutines.
-subroutine test9(dummy_proc)
- implicit none
- interface
- subroutine dummy_proc()
- end subroutine
- end interface
- call bar()
-contains
-! CHECK-LABEL: func private @_QFtest9Pbar(
-! CHECK-SAME: %[[tup:.*]]: !fir.ref<tuple<!fir.boxproc<() -> ()>>> {fir.host_assoc}) attributes {fir.host_symbol = {{.*}}, llvm.linkage = #llvm.linkage<internal>} {
-subroutine bar()
- ! CHECK: %[[tupAddr:.*]] = fir.coordinate_of %[[tup]], %c0{{.*}} : (!fir.ref<tuple<!fir.boxproc<() -> ()>>>, i32) -> !fir.ref<!fir.boxproc<() -> ()>>
- ! CHECK: %[[dummyProc:.*]] = fir.load %[[tupAddr]] : !fir.ref<!fir.boxproc<() -> ()>>
- ! CHECK: %[[pa:.*]] = fir.box_addr %[[dummyProc]]
- ! CHECK: fir.call %[[pa]]() {{.*}}: () -> ()
- call dummy_proc()
-end subroutine
-end subroutine
-
-! Test capture of namelist
-! CHECK-LABEL: func @_QPtest10(
-! CHECK-SAME: %[[i:.*]]: !fir.ref<!fir.box<!fir.ptr<!fir.array<?xi32>>>>{{.*}}) {
+! CHECK-LABEL: func.func @_QPtest10(
subroutine test10(i)
implicit none
integer, pointer :: i(:)
namelist /a_namelist/ i
- ! CHECK: %[[tupAddr:.*]] = fir.coordinate_of %[[tup:.*]], %c0{{.*}} : (!fir.ref<tuple<!fir.ref<!fir.box<!fir.ptr<!fir.array<?xi32>>>>>>, i32) -> !fir.llvm_ptr<!fir.ref<!fir.box<!fir.ptr<!fir.array<?xi32>>>>>
- ! CHECK: fir.store %[[i]] to %[[tupAddr]] : !fir.llvm_ptr<!fir.ref<!fir.box<!fir.ptr<!fir.array<?xi32>>>>>
- ! CHECK: fir.call @_QFtest10Pbar(%[[tup]]) {{.*}}: (!fir.ref<tuple<!fir.ref<!fir.box<!fir.ptr<!fir.array<?xi32>>>>>>) -> ()
+ ! CHECK: hlfir.declare %{{.*}}uniq_name = "_QFtest10Ei"
+ ! CHECK: fir.alloca tuple<!fir.ref<!fir.box<!fir.ptr<!fir.array<?xi32>>>>>
+ ! CHECK: fir.call @_QFtest10Pbar
call bar()
contains
-! CHECK-LABEL: func private @_QFtest10Pbar(
-! CHECK-SAME: %[[tup:.*]]: !fir.ref<tuple<!fir.ref<!fir.box<!fir.ptr<!fir.array<?xi32>>>>>> {fir.host_assoc}) attributes {fir.host_symbol = {{.*}}, llvm.linkage = #llvm.linkage<internal>} {
+! CHECK-LABEL: func.func private @_QFtest10Pbar(
+! CHECK-SAME: %[[tup:.*]]: !fir.ref<tuple<!fir.ref<!fir.box<!fir.ptr<!fir.array<?xi32>>>>>> {fir.host_assoc})
subroutine bar()
- ! CHECK: %[[tupAddr:.*]] = fir.coordinate_of %[[tup]], %c0{{.*}} : (!fir.ref<tuple<!fir.ref<!fir.box<!fir.ptr<!fir.array<?xi32>>>>>>, i32) -> !fir.llvm_ptr<!fir.ref<!fir.box<!fir.ptr<!fir.array<?xi32>>>>>
- ! CHECK: fir.load %[[tupAddr]] : !fir.llvm_ptr<!fir.ref<!fir.box<!fir.ptr<!fir.array<?xi32>>>>>
+ ! CHECK: hlfir.declare %{{.*}}uniq_name = "_QFtest10Ei"
read (88, NML = a_namelist)
end subroutine
end subroutine
-! Test passing an internal procedure as a dummy argument.
-
-! CHECK-LABEL: func @_QPtest_proc_dummy() {
-! CHECK: %[[VAL_4:.*]] = fir.alloca i32 {bindc_name = "i", uniq_name = "_QFtest_proc_dummyEi"}
-! CHECK: %[[VAL_5:.*]] = fir.alloca tuple<!fir.ref<i32>>
-! CHECK: %[[VAL_7:.*]] = fir.address_of(@_QFtest_proc_dummyPtest_proc_dummy_a) : (!fir.ref<i32>, !fir.ref<tuple<!fir.ref<i32>>>) -> ()
-! CHECK: %[[VAL_8:.*]] = fir.emboxproc %[[VAL_7]], %[[VAL_5]] : ((!fir.ref<i32>, !fir.ref<tuple<!fir.ref<i32>>>) -> (), !fir.ref<tuple<!fir.ref<i32>>>) -> !fir.boxproc<() -> ()>
-! CHECK: fir.call @_QPtest_proc_dummy_other(%[[VAL_8]]) {{.*}}: (!fir.boxproc<() -> ()>) -> ()
-
-! CHECK-LABEL: func private @_QFtest_proc_dummyPtest_proc_dummy_a(
-! CHECK-SAME: %[[VAL_0:.*]]: !fir.ref<i32> {fir.bindc_name = "j"},
-! CHECK-SAME: %[[VAL_1:.*]]: !fir.ref<tuple<!fir.ref<i32>>> {fir.host_assoc}) attributes {fir.host_symbol = {{.*}}, llvm.linkage = #llvm.linkage<internal>} {
-! CHECK: %[[VAL_2:.*]] = arith.constant 0 : i32
-! CHECK: %[[VAL_3:.*]] = fir.coordinate_of %[[VAL_1]], %[[VAL_2]] : (!fir.ref<tuple<!fir.ref<i32>>>, i32) -> !fir.llvm_ptr<!fir.ref<i32>>
-! CHECK: %[[VAL_4:.*]] = fir.load %[[VAL_3]] : !fir.llvm_ptr<!fir.ref<i32>>
-! CHECK: %[[VAL_5:.*]] = fir.load %[[VAL_4]] : !fir.ref<i32>
-! CHECK: %[[VAL_6:.*]] = fir.load %[[VAL_0]] : !fir.ref<i32>
-! CHECK: %[[VAL_7:.*]] = arith.addi %[[VAL_5]], %[[VAL_6]] : i32
-! CHECK: fir.store %[[VAL_7]] to %[[VAL_4]] : !fir.ref<i32>
-! CHECK: return
-! CHECK: }
-
-! CHECK-LABEL: func @_QPtest_proc_dummy_other(
-! CHECK-SAME: %[[VAL_0:.*]]: !fir.boxproc<() -> ()>) {
-! CHECK: %[[VAL_1:.*]] = arith.constant 4 : i32
-! CHECK: %[[VAL_2:.*]] = fir.alloca i32 {adapt.valuebyref}
-! CHECK: fir.store %[[VAL_1]] to %[[VAL_2]] : !fir.ref<i32>
-! CHECK: %[[VAL_3:.*]] = fir.box_addr %[[VAL_0]] : (!fir.boxproc<() -> ()>) -> ((!fir.ref<i32>) -> ())
-! CHECK: fir.call %[[VAL_3]](%[[VAL_2]]) {{.*}}: (!fir.ref<i32>) -> ()
-! CHECK: return
-! CHECK: }
-
+! CHECK-LABEL: func.func @_QPtest_proc_dummy() {
subroutine test_proc_dummy
integer i
i = 1
+ ! CHECK: hlfir.declare %{{.*}}uniq_name = "_QFtest_proc_dummyEi"
+ ! CHECK: fir.alloca tuple<!fir.ref<i32>>
+ ! CHECK: fir.emboxproc
call test_proc_dummy_other(test_proc_dummy_a)
print *, i
contains
+ ! CHECK-LABEL: func.func private @_QFtest_proc_dummyPtest_proc_dummy_a(
+ ! CHECK-SAME: %{{.*}}, %[[tup:.*]]: !fir.ref<tuple<!fir.ref<i32>>> {fir.host_assoc})
subroutine test_proc_dummy_a(j)
+ ! CHECK: hlfir.declare %{{.*}}uniq_name = "_QFtest_proc_dummyEi"
i = i + j
end subroutine test_proc_dummy_a
end subroutine test_proc_dummy
-subroutine test_proc_dummy_other(proc)
- call proc(4)
-end subroutine test_proc_dummy_other
-
-! CHECK-LABEL: func.func @_QPtest_proc_dummy_char() {
-! CHECK: %[[VAL_0:.*]] = arith.constant 0 : index
-! CHECK: %[[VAL_1:.*]] = arith.constant 40 : index
-! CHECK: %[[VAL_2:.*]] = arith.constant 10 : i64
-! CHECK: %[[VAL_4:.*]] = arith.constant 6 : i32
-! CHECK: %[[VAL_5:.*]] = arith.constant 32 : i8
-! CHECK: %[[VAL_6:.*]] = arith.constant 1 : index
-! CHECK: %[[VAL_7:.*]] = arith.constant 9 : index
-! CHECK: %[[VAL_8:.*]] = arith.constant 0 : i32
-! CHECK: %[[VAL_9:.*]] = arith.constant 10 : index
-! CHECK: %[[VAL_10:.*]] = fir.alloca !fir.char<1,40> {bindc_name = ".result"}
-! CHECK: %[[VAL_11:.*]] = fir.alloca !fir.char<1,10> {bindc_name = "message", uniq_name = "_QFtest_proc_dummy_charEmessage"}
-! CHECK: %[[VAL_12:.*]] = fir.alloca tuple<!fir.boxchar<1>>
-! CHECK: %[[VAL_13:.*]] = fir.coordinate_of %[[VAL_12]], %[[VAL_8]] : (!fir.ref<tuple<!fir.boxchar<1>>>, i32) -> !fir.ref<!fir.boxchar<1>>
-! CHECK: %[[VAL_14:.*]] = fir.emboxchar %[[VAL_11]], %[[VAL_9]] : (!fir.ref<!fir.char<1,10>>, index) -> !fir.boxchar<1>
-! CHECK: fir.store %[[VAL_14]] to %[[VAL_13]] : !fir.ref<!fir.boxchar<1>>
-! CHECK: %[[VAL_15:.*]] = fir.address_of(@{{.*}}) : !fir.ref<!fir.char<1,{{.+}}>>
-! CHECK: %[[VAL_16:.*]] = fir.convert %[[VAL_7]] : (index) -> i64
-! CHECK: %[[VAL_17:.*]] = fir.convert %[[VAL_11]] : (!fir.ref<!fir.char<1,10>>) -> !llvm.ptr
-! CHECK: %[[VAL_18:.*]] = fir.convert %[[VAL_15]] : (!fir.ref<!fir.char<1,9>>) -> !llvm.ptr
-! CHECK: "llvm.intr.memmove"(%[[VAL_17]], %[[VAL_18]], %[[VAL_16]]) <{isVolatile = false}> : (!llvm.ptr, !llvm.ptr, i64) -> ()
-! CHECK: %[[VAL_19:.*]] = fir.undefined !fir.char<1>
-! CHECK: %[[VAL_20:.*]] = fir.insert_value %[[VAL_19]], %[[VAL_5]], [0 : index] : (!fir.char<1>, i8) -> !fir.char<1>
-! CHECK: cf.br ^bb1(%[[VAL_7]], %[[VAL_6]] : index, index)
-! CHECK: ^bb1(%[[VAL_21:.*]]: index, %[[VAL_22:.*]]: index):
-! CHECK: %[[VAL_23:.*]] = arith.cmpi sgt, %[[VAL_22]], %[[VAL_0]] : index
-! CHECK: cf.cond_br %[[VAL_23]], ^bb2, ^bb3
-! CHECK: ^bb2:
-! CHECK: %[[VAL_24:.*]] = fir.convert %[[VAL_11]] : (!fir.ref<!fir.char<1,10>>) -> !fir.ref<!fir.array<10x!fir.char<1>>>
-! CHECK: %[[VAL_25:.*]] = fir.coordinate_of %[[VAL_24]], %[[VAL_21]] : (!fir.ref<!fir.array<10x!fir.char<1>>>, index) -> !fir.ref<!fir.char<1>>
-! CHECK: fir.store %[[VAL_20]] to %[[VAL_25]] : !fir.ref<!fir.char<1>>
-! CHECK: %[[VAL_26:.*]] = arith.addi %[[VAL_21]], %[[VAL_6]] : index
-! CHECK: %[[VAL_27:.*]] = arith.subi %[[VAL_22]], %[[VAL_6]] : index
-! CHECK: cf.br ^bb1(%[[VAL_26]], %[[VAL_27]] : index, index)
-! CHECK: ^bb3:
-! CHECK: %[[VAL_28:.*]] = fir.address_of(@{{.*}}) : !fir.ref<!fir.char<1,{{.+}}>>
-! CHECK: %[[VAL_29:.*]] = fir.convert %[[VAL_28]] : (!fir.ref<!fir.char<1,{{.+}}>>) -> !fir.ref<i8>
-! CHECK: %[[VAL_30:.*]] = fir.call @_FortranAioBeginExternalListOutput
-! CHECK: %[[VAL_31:.*]] = fir.address_of(@_QFtest_proc_dummy_charPgen_message) : (!fir.ref<!fir.char<1,10>>, index, !fir.ref<tuple<!fir.boxchar<1>>>) -> !fir.boxchar<1>
-! CHECK: %[[VAL_32:.*]] = fir.emboxproc %[[VAL_31]], %[[VAL_12]] : ((!fir.ref<!fir.char<1,10>>, index, !fir.ref<tuple<!fir.boxchar<1>>>) -> !fir.boxchar<1>, !fir.ref<tuple<!fir.boxchar<1>>>) -> !fir.boxproc<() -> ()>
-! CHECK: %[[VAL_33:.*]] = fir.undefined tuple<!fir.boxproc<() -> ()>, i64>
-! CHECK: %[[VAL_34:.*]] = fir.insert_value %[[VAL_33]], %[[VAL_32]], [0 : index] : (tuple<!fir.boxproc<() -> ()>, i64>, !fir.boxproc<() -> ()>) -> tuple<!fir.boxproc<() -> ()>, i64>
-! CHECK: %[[VAL_35:.*]] = fir.insert_value %[[VAL_34]], %[[VAL_2]], [1 : index] : (tuple<!fir.boxproc<() -> ()>, i64>, i64) -> tuple<!fir.boxproc<() -> ()>, i64>
-! CHECK: %[[VAL_36:.*]] = llvm.intr.stacksave : !llvm.ptr
-! CHECK: %[[VAL_37:.*]] = fir.call @_QPget_message(%[[VAL_10]], %[[VAL_1]], %[[VAL_35]])
-! CHECK: %[[VAL_38:.*]] = fir.convert %[[VAL_10]] : (!fir.ref<!fir.char<1,40>>) -> !fir.ref<i8>
-! CHECK: %[[VAL_39:.*]] = fir.convert %[[VAL_1]] : (index) -> i64
-! CHECK: %[[VAL_40:.*]] = fir.call @_FortranAioOutputAscii
-! CHECK: llvm.intr.stackrestore %[[VAL_36]] : !llvm.ptr
-! CHECK: %[[VAL_41:.*]] = fir.call @_FortranAioEndIoStatement
-! CHECK: return
-! CHECK: }
-
-! CHECK-LABEL: func.func private @_QFtest_proc_dummy_charPgen_message(
-! CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<!fir.char<1,10>>,
-! CHECK-SAME: %[[VAL_1:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: index,
-! CHECK-SAME: %[[VAL_2:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<tuple<!fir.boxchar<1>>> {fir.host_assoc}) -> !fir.boxchar<1> attributes {{.*}} {
-! CHECK: %[[VAL_3:.*]] = arith.constant 0 : index
-! CHECK: %[[VAL_4:.*]] = arith.constant 32 : i8
-! CHECK: %[[VAL_5:.*]] = arith.constant 1 : index
-! CHECK: %[[VAL_6:.*]] = arith.constant 10 : index
-! CHECK: %[[VAL_7:.*]] = arith.constant 0 : i32
-! CHECK: %[[VAL_8:.*]] = fir.coordinate_of %[[VAL_2]], %[[VAL_7]] : (!fir.ref<tuple<!fir.boxchar<1>>>, i32) -> !fir.ref<!fir.boxchar<1>>
-! CHECK: %[[VAL_9:.*]] = fir.load %[[VAL_8]] : !fir.ref<!fir.boxchar<1>>
-! CHECK: %[[VAL_10:.*]]:2 = fir.unboxchar %[[VAL_9]] : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1,?>>, index)
-! CHECK: %[[VAL_11:.*]] = arith.cmpi sgt, %[[VAL_10]]#1, %[[VAL_6]] : index
-! CHECK: %[[VAL_12:.*]] = arith.select %[[VAL_11]], %[[VAL_6]], %[[VAL_10]]#1 : index
-! CHECK: %[[VAL_13:.*]] = fir.convert %[[VAL_12]] : (index) -> i64
-! CHECK: %[[VAL_14:.*]] = fir.convert %[[VAL_0]] : (!fir.ref<!fir.char<1,10>>) -> !llvm.ptr
-! CHECK: %[[VAL_15:.*]] = fir.convert %[[VAL_10]]#0 : (!fir.ref<!fir.char<1,?>>) -> !llvm.ptr
-! CHECK: "llvm.intr.memmove"(%[[VAL_14]], %[[VAL_15]], %[[VAL_13]]) <{isVolatile = false}> : (!llvm.ptr, !llvm.ptr, i64) -> ()
-! CHECK: %[[VAL_16:.*]] = fir.undefined !fir.char<1>
-! CHECK: %[[VAL_17:.*]] = fir.insert_value %[[VAL_16]], %[[VAL_4]], [0 : index] : (!fir.char<1>, i8) -> !fir.char<1>
-! CHECK: %[[VAL_18:.*]] = arith.subi %[[VAL_6]], %[[VAL_12]] : index
-! CHECK: cf.br ^bb1(%[[VAL_12]], %[[VAL_18]] : index, index)
-! CHECK: ^bb1(%[[VAL_19:.*]]: index, %[[VAL_20:.*]]: index):
-! CHECK: %[[VAL_21:.*]] = arith.cmpi sgt, %[[VAL_20]], %[[VAL_3]] : index
-! CHECK: cf.cond_br %[[VAL_21]], ^bb2, ^bb3
-! CHECK: ^bb2:
-! CHECK: %[[VAL_22:.*]] = fir.convert %[[VAL_0]] : (!fir.ref<!fir.char<1,10>>) -> !fir.ref<!fir.array<10x!fir.char<1>>>
-! CHECK: %[[VAL_23:.*]] = fir.coordinate_of %[[VAL_22]], %[[VAL_19]] : (!fir.ref<!fir.array<10x!fir.char<1>>>, index) -> !fir.ref<!fir.char<1>>
-! CHECK: fir.store %[[VAL_17]] to %[[VAL_23]] : !fir.ref<!fir.char<1>>
-! CHECK: %[[VAL_24:.*]] = arith.addi %[[VAL_19]], %[[VAL_5]] : index
-! CHECK: %[[VAL_25:.*]] = arith.subi %[[VAL_20]], %[[VAL_5]] : index
-! CHECK: cf.br ^bb1(%[[VAL_24]], %[[VAL_25]] : index, index)
-! CHECK: ^bb3:
-! CHECK: %[[VAL_26:.*]] = fir.emboxchar %[[VAL_0]], %[[VAL_6]] : (!fir.ref<!fir.char<1,10>>, index) -> !fir.boxchar<1>
-! CHECK: return %[[VAL_26]] : !fir.boxchar<1>
-! CHECK: }
-
-! CHECK-LABEL: func.func @_QPget_message(
-! CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<!fir.char<1,40>>,
-! CHECK-SAME: %[[VAL_1:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: index,
-! CHECK-SAME: %[[VAL_2:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: tuple<!fir.boxproc<() -> ()>, i64> {fir.char_proc}) -> !fir.boxchar<1> {
-! CHECK: %[[VAL_3:.*]] = arith.constant 0 : index
-! CHECK: %[[VAL_4:.*]] = arith.constant 32 : i8
-! CHECK: %[[VAL_5:.*]] = arith.constant 1 : index
-! CHECK: %[[VAL_6:.*]] = arith.constant 12 : index
-! CHECK: %[[VAL_7:.*]] = arith.constant 40 : index
-! CHECK: %[[VAL_8:.*]] = fir.address_of(@{{.*}}) : !fir.ref<!fir.char<1,12>>
-! CHECK: %[[VAL_9:.*]] = fir.extract_value %[[VAL_2]], [0 : index] : (tuple<!fir.boxproc<() -> ()>, i64>) -> !fir.boxproc<() -> ()>
-! CHECK: %[[VAL_10:.*]] = fir.box_addr %[[VAL_9]] : (!fir.boxproc<() -> ()>) -> (() -> ())
-! CHECK: %[[VAL_11:.*]] = fir.extract_value %[[VAL_2]], [1 : index] : (tuple<!fir.boxproc<() -> ()>, i64>) -> i64
-! CHECK: %[[VAL_12:.*]] = llvm.intr.stacksave : !llvm.ptr
-! CHECK: %[[VAL_13:.*]] = fir.alloca !fir.char<1,?>(%[[VAL_11]] : i64) {bindc_name = ".result"}
-! CHECK: %[[VAL_14:.*]] = fir.convert %[[VAL_10]] : (() -> ()) -> ((!fir.ref<!fir.char<1,?>>, index) -> !fir.boxchar<1>)
-! CHECK: %[[VAL_15:.*]] = fir.convert %[[VAL_11]] : (i64) -> index
-! CHECK: %[[VAL_16:.*]] = fir.call %[[VAL_14]](%[[VAL_13]], %[[VAL_15]]) fastmath<contract> : (!fir.ref<!fir.char<1,?>>, index) -> !fir.boxchar<1>
-! CHECK: %[[VAL_17:.*]] = arith.addi %[[VAL_15]], %[[VAL_6]] : index
-! CHECK: %[[VAL_18:.*]] = fir.alloca !fir.char<1,?>(%[[VAL_17]] : index) {bindc_name = ".chrtmp"}
-! CHECK: %[[VAL_19:.*]] = fir.convert %[[VAL_6]] : (index) -> i64
-! CHECK: %[[VAL_20:.*]] = fir.convert %[[VAL_18]] : (!fir.ref<!fir.char<1,?>>) -> !llvm.ptr
-! CHECK: %[[VAL_21:.*]] = fir.convert %[[VAL_8]] : (!fir.ref<!fir.char<1,12>>) -> !llvm.ptr
-! CHECK: "llvm.intr.memmove"(%[[VAL_20]], %[[VAL_21]], %[[VAL_19]]) <{isVolatile = false}> : (!llvm.ptr, !llvm.ptr, i64) -> ()
-! CHECK: cf.br ^bb1(%[[VAL_6]], %[[VAL_15]] : index, index)
-! CHECK: ^bb1(%[[VAL_22:.*]]: index, %[[VAL_23:.*]]: index):
-! CHECK: %[[VAL_24:.*]] = arith.cmpi sgt, %[[VAL_23]], %[[VAL_3]] : index
-! CHECK: cf.cond_br %[[VAL_24]], ^bb2, ^bb3
-! CHECK: ^bb2:
-! CHECK: %[[VAL_25:.*]] = arith.subi %[[VAL_22]], %[[VAL_6]] : index
-! CHECK: %[[VAL_26:.*]] = fir.convert %[[VAL_13]] : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<!fir.array<?x!fir.char<1>>>
-! CHECK: %[[VAL_27:.*]] = fir.coordinate_of %[[VAL_26]], %[[VAL_25]] : (!fir.ref<!fir.array<?x!fir.char<1>>>, index) -> !fir.ref<!fir.char<1>>
-! CHECK: %[[VAL_28:.*]] = fir.load %[[VAL_27]] : !fir.ref<!fir.char<1>>
-! CHECK: %[[VAL_29:.*]] = fir.convert %[[VAL_18]] : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<!fir.array<?x!fir.char<1>>>
-! CHECK: %[[VAL_30:.*]] = fir.coordinate_of %[[VAL_29]], %[[VAL_22]] : (!fir.ref<!fir.array<?x!fir.char<1>>>, index) -> !fir.ref<!fir.char<1>>
-! CHECK: fir.store %[[VAL_28]] to %[[VAL_30]] : !fir.ref<!fir.char<1>>
-! CHECK: %[[VAL_31:.*]] = arith.addi %[[VAL_22]], %[[VAL_5]] : index
-! CHECK: %[[VAL_32:.*]] = arith.subi %[[VAL_23]], %[[VAL_5]] : index
-! CHECK: cf.br ^bb1(%[[VAL_31]], %[[VAL_32]] : index, index)
-! CHECK: ^bb3:
-! CHECK: %[[VAL_33:.*]] = arith.cmpi sgt, %[[VAL_17]], %[[VAL_7]] : index
-! CHECK: %[[VAL_34:.*]] = arith.select %[[VAL_33]], %[[VAL_7]], %[[VAL_17]] : index
-! CHECK: %[[VAL_35:.*]] = fir.convert %[[VAL_34]] : (index) -> i64
-! CHECK: %[[VAL_36:.*]] = fir.convert %[[VAL_0]] : (!fir.ref<!fir.char<1,40>>) -> !llvm.ptr
-! CHECK: "llvm.intr.memmove"(%[[VAL_36]], %[[VAL_20]], %[[VAL_35]]) <{isVolatile = false}> : (!llvm.ptr, !llvm.ptr, i64) -> ()
-! CHECK: %[[VAL_37:.*]] = fir.undefined !fir.char<1>
-! CHECK: %[[VAL_38:.*]] = fir.insert_value %[[VAL_37]], %[[VAL_4]], [0 : index] : (!fir.char<1>, i8) -> !fir.char<1>
-! CHECK: %[[VAL_39:.*]] = arith.subi %[[VAL_7]], %[[VAL_34]] : index
-! CHECK: cf.br ^bb4(%[[VAL_34]], %[[VAL_39]] : index, index)
-! CHECK: ^bb4(%[[VAL_40:.*]]: index, %[[VAL_41:.*]]: index):
-! CHECK: %[[VAL_42:.*]] = arith.cmpi sgt, %[[VAL_41]], %[[VAL_3]] : index
-! CHECK: cf.cond_br %[[VAL_42]], ^bb5, ^bb6
-! CHECK: ^bb5:
-! CHECK: %[[VAL_43:.*]] = fir.convert %[[VAL_0]] : (!fir.ref<!fir.char<1,40>>) -> !fir.ref<!fir.array<40x!fir.char<1>>>
-! CHECK: %[[VAL_44:.*]] = fir.coordinate_of %[[VAL_43]], %[[VAL_40]] : (!fir.ref<!fir.array<40x!fir.char<1>>>, index) -> !fir.ref<!fir.char<1>>
-! CHECK: fir.store %[[VAL_38]] to %[[VAL_44]] : !fir.ref<!fir.char<1>>
-! CHECK: %[[VAL_45:.*]] = arith.addi %[[VAL_40]], %[[VAL_5]] : index
-! CHECK: %[[VAL_46:.*]] = arith.subi %[[VAL_41]], %[[VAL_5]] : index
-! CHECK: cf.br ^bb4(%[[VAL_45]], %[[VAL_46]] : index, index)
-! CHECK: ^bb6:
-! CHECK: llvm.intr.stackrestore %[[VAL_12]] : !llvm.ptr
-! CHECK: %[[VAL_47:.*]] = fir.emboxchar %[[VAL_0]], %[[VAL_7]] : (!fir.ref<!fir.char<1,40>>, index) -> !fir.boxchar<1>
-! CHECK: return %[[VAL_47]] : !fir.boxchar<1>
-! CHECK: }
-
subroutine test_proc_dummy_char
character(40) get_message
external get_message
character(10) message
message = "Hi there!"
+ ! CHECK: hlfir.declare %{{.*}}uniq_name = "_QFtest_proc_dummy_charEmessage"
+ ! CHECK: fir.alloca tuple<!fir.boxchar<1>>
+ ! CHECK: fir.emboxproc
print *, get_message(gen_message)
contains
+ ! CHECK-LABEL: func.func private @_QFtest_proc_dummy_charPgen_message(
+ ! CHECK-SAME: %{{.*}}, %{{.*}}, %[[tup:.*]]: !fir.ref<tuple<!fir.boxchar<1>>> {fir.host_assoc})
function gen_message
+ ! CHECK: hlfir.declare %{{.*}}uniq_name = "_QFtest_proc_dummy_charEmessage"
character(10) :: gen_message
gen_message = message
end function gen_message
end subroutine test_proc_dummy_char
-function get_message(a)
- character(40) :: get_message
- character(*) :: a
- get_message = "message is: " // a()
-end function get_message
-
-! CHECK-LABEL: func @_QPtest_11a() {
-! CHECK: %[[a:.*]] = fir.address_of(@_QPtest_11b) : () -> ()
-! CHECK: %[[b:.*]] = fir.emboxproc %[[a]] : (() -> ()) -> !fir.boxproc<() -> ()>
-! CHECK: fir.call @_QPtest_11c(%[[b]], %{{.*}}) {{.*}}: (!fir.boxproc<() -> ()>, !fir.ref<i32>) -> ()
-! CHECK: func private @_QPtest_11c(!fir.boxproc<() -> ()>, !fir.ref<i32>)
-
-subroutine test_11a
- external test_11b
- call test_11c(test_11b, 3)
-end subroutine test_11a
-
-subroutine test_PDT_with_init_do_not_crash_host_symbol_analysis()
+! CHECK-LABEL: func.func @_QPtest_pdt_with_init_do_not_crash_host_symbol_analysis() {
+subroutine test_pdt_with_init_do_not_crash_host_symbol_analysis()
integer :: i
call sub()
contains
+ ! CHECK-LABEL: func.func private @_QFtest_pdt_with_init_do_not_crash_host_symbol_analysisPsub(
+ ! CHECK-SAME: %[[tup:.*]]: !fir.ref<tuple<!fir.ref<i32>>> {fir.host_assoc})
subroutine sub()
- ! PDT definition symbols maps to un-analyzed expression,
- ! check this does not crash the visit of the internal procedure
- ! parse-tree to get the list of captured host variables.
+ ! CHECK: hlfir.declare %{{.*}}uniq_name = "_QFtest_pdt_with_init_do_not_crash_host_symbol_analysisEi"
type type1 (k)
integer, KIND :: k
integer :: x = k
More information about the flang-commits
mailing list