[flang-commits] [flang] [flang][NFC] Converted five tests from old lowering to new lowering (part 36) (PR #187628)
Eugene Epshteyn via flang-commits
flang-commits at lists.llvm.org
Thu Mar 19 20:56:22 PDT 2026
https://github.com/eugeneepshteyn created https://github.com/llvm/llvm-project/pull/187628
Tests converted from test/Lower/Intrinsics: maxloc.f90, maxval.f90, merge.f90, merge_bits.f90, minloc.f90
>From c524deb59f077190d4557bc048546a7c48bbbfc8 Mon Sep 17 00:00:00 2001
From: Eugene Epshteyn <eepshteyn at nvidia.com>
Date: Thu, 19 Mar 2026 23:54:43 -0400
Subject: [PATCH] [flang][NFC] Converted five tests from old lowering to new
lowering (part 36)
Tests converted from test/Lower/Intrinsics: maxloc.f90, maxval.f90, merge.f90, merge_bits.f90, minloc.f90
---
flang/test/Lower/Intrinsics/maxloc.f90 | 93 +++++++------------
flang/test/Lower/Intrinsics/maxval.f90 | 69 +++++++-------
flang/test/Lower/Intrinsics/merge.f90 | 102 +++++++++++++--------
flang/test/Lower/Intrinsics/merge_bits.f90 | 69 +++++++++-----
flang/test/Lower/Intrinsics/minloc.f90 | 93 +++++++------------
5 files changed, 210 insertions(+), 216 deletions(-)
diff --git a/flang/test/Lower/Intrinsics/maxloc.f90 b/flang/test/Lower/Intrinsics/maxloc.f90
index 13dbe984043b6..20cd4721635cc 100644
--- a/flang/test/Lower/Intrinsics/maxloc.f90
+++ b/flang/test/Lower/Intrinsics/maxloc.f90
@@ -1,89 +1,66 @@
-! RUN: bbc -emit-fir -hlfir=false %s -o - | FileCheck %s
+! RUN: %flang_fc1 -emit-hlfir %s -o - | FileCheck %s
! CHECK-LABEL: func @_QPmaxloc_test(
-! CHECK-SAME: %[[arg0:.*]]: !fir.box<!fir.array<?xi32>>{{.*}}, %[[arg1:.*]]: !fir.box<!fir.array<?xi32>>{{.*}}) {
+! CHECK-SAME: %[[ARG0:.*]]: !fir.box<!fir.array<?xi32>>{{.*}}, %[[ARG1:.*]]: !fir.box<!fir.array<?xi32>>{{.*}}) {
subroutine maxloc_test(arr,res)
integer :: arr(:)
integer :: res(:)
- ! CHECK-DAG: %[[c4:.*]] = arith.constant 4 : index
- ! CHECK-DAG: %[[a0:.*]] = fir.alloca !fir.box<!fir.heap<!fir.array<?xi32>>>
- ! CHECK-DAG: %[[a1:.*]] = fir.absent !fir.box<i1>
- ! CHECK-DAG: %[[a6:.*]] = fir.convert %[[a0]] : (!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>) -> !fir.ref<!fir.box<none>>
- ! CHECK-DAG: %[[a7:.*]] = fir.convert %[[arg0]] : (!fir.box<!fir.array<?xi32>>) -> !fir.box<none>
- ! CHECK-DAG: %[[a8:.*]] = fir.convert %[[c4]] : (index) -> i32
- ! CHECK-DAG: %[[a10:.*]] = fir.convert %[[a1]] : (!fir.box<i1>) -> !fir.box<none>
+ ! CHECK-DAG: %[[ARR:.*]]:2 = hlfir.declare %[[ARG0]] dummy_scope %{{.*}} arg 1 {uniq_name = "_QFmaxloc_testEarr"}
+ ! CHECK-DAG: %[[RES:.*]]:2 = hlfir.declare %[[ARG1]] dummy_scope %{{.*}} arg 2 {uniq_name = "_QFmaxloc_testEres"}
res = maxloc(arr)
- ! CHECK: fir.call @_FortranAMaxlocInteger4(%[[a6]], %[[a7]], %[[a8]], %{{.*}}, %{{.*}}, %[[a10]], %false) {{.*}}: (!fir.ref<!fir.box<none>>, !fir.box<none>, i32, !fir.ref<i8>, i32, !fir.box<none>, i1) -> ()
- ! CHECK-DAG: %[[a12:.*]] = fir.load %[[a0]] : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>
- ! CHECK-DAG: %[[a14:.*]] = fir.box_addr %[[a12]] : (!fir.box<!fir.heap<!fir.array<?xi32>>>) -> !fir.heap<!fir.array<?xi32>>
- ! CHECK-DAG: fir.freemem %[[a14]]
+ ! CHECK: %[[MAXLOC:.*]] = hlfir.maxloc %[[ARR]]#0 {fastmath = #arith.fastmath<contract>} : (!fir.box<!fir.array<?xi32>>) -> !hlfir.expr<1xi32>
+ ! CHECK: hlfir.assign %[[MAXLOC]] to %[[RES]]#0 : !hlfir.expr<1xi32>, !fir.box<!fir.array<?xi32>>
+ ! CHECK: hlfir.destroy %[[MAXLOC]] : !hlfir.expr<1xi32>
end subroutine
! CHECK-LABEL: func @_QPmaxloc_test2(
- ! CHECK-SAME: %[[arg0:.*]]: !fir.box<!fir.array<?xi32>>{{.*}}, %[[arg1:.*]]: !fir.box<!fir.array<?xi32>>{{.*}}, %[[arg2:.*]]: !fir.ref<i32>{{.*}}) {
+ ! CHECK-SAME: %[[ARG0:.*]]: !fir.box<!fir.array<?xi32>>{{.*}}, %[[ARG1:.*]]: !fir.box<!fir.array<?xi32>>{{.*}}, %[[ARG2:.*]]: !fir.ref<i32>{{.*}}) {
subroutine maxloc_test2(arr,res,d)
integer :: arr(:)
integer :: res(:)
integer :: d
- ! CHECK-DAG: %[[c4:.*]] = arith.constant 4 : index
- ! CHECK-DAG: %[[a0:.*]] = fir.alloca !fir.box<!fir.heap<i32>>
- ! CHECK-DAG: %[[a1:.*]] = fir.load %arg2 : !fir.ref<i32>
- ! CHECK-DAG: %[[a2:.*]] = fir.absent !fir.box<i1>
- ! CHECK-DAG: %[[a6:.*]] = fir.convert %[[a0]] : (!fir.ref<!fir.box<!fir.heap<i32>>>) -> !fir.ref<!fir.box<none>>
- ! CHECK-DAG: %[[a7:.*]] = fir.convert %arg0 : (!fir.box<!fir.array<?xi32>>) -> !fir.box<none>
- ! CHECK-DAG: %[[a8:.*]] = fir.convert %[[c4]] : (index) -> i32
- ! CHECK-DAG: %[[a10:.*]] = fir.convert %[[a2]] : (!fir.box<i1>) -> !fir.box<none>
+ ! CHECK-DAG: %[[ARR:.*]]:2 = hlfir.declare %[[ARG0]] dummy_scope %{{.*}} arg 1 {uniq_name = "_QFmaxloc_test2Earr"}
+ ! CHECK-DAG: %[[D:.*]]:2 = hlfir.declare %[[ARG2]] dummy_scope %{{.*}} arg 3 {uniq_name = "_QFmaxloc_test2Ed"}
+ ! CHECK-DAG: %[[RES:.*]]:2 = hlfir.declare %[[ARG1]] dummy_scope %{{.*}} arg 2 {uniq_name = "_QFmaxloc_test2Eres"}
res = maxloc(arr, dim=d)
- ! CHECK: fir.call @_FortranAMaxlocDim(%[[a6]], %[[a7]], %[[a8]], %[[a1]], %{{.*}}, %{{.*}}, %[[a10]], %false) {{.*}}: (!fir.ref<!fir.box<none>>, !fir.box<none>, i32, i32, !fir.ref<i8>, i32, !fir.box<none>, i1) -> ()
- ! CHECK: %[[a12:.*]] = fir.load %0 : !fir.ref<!fir.box<!fir.heap<i32>>>
- ! CHECK: %[[a13:.*]] = fir.box_addr %[[a12]] : (!fir.box<!fir.heap<i32>>) -> !fir.heap<i32>
- ! CHECK: fir.freemem %[[a13]]
+ ! CHECK: %[[D_VAL:.*]] = fir.load %[[D]]#0 : !fir.ref<i32>
+ ! CHECK: %[[MAXLOC:.*]] = hlfir.maxloc %[[ARR]]#0 dim %[[D_VAL]] {fastmath = #arith.fastmath<contract>} : (!fir.box<!fir.array<?xi32>>, i32) -> i32
+ ! CHECK: hlfir.assign %[[MAXLOC]] to %[[RES]]#0 : i32, !fir.box<!fir.array<?xi32>>
end subroutine
! CHECK-LABEL: func @_QPtest_maxloc_optional_scalar_mask(
- ! CHECK-SAME: %[[VAL_0:[^:]+]]: !fir.ref<!fir.logical<4>>
- ! CHECK-SAME: %[[VAL_1:.*]]: !fir.ref<!fir.logical<4>>
+ ! CHECK-SAME: %[[VAL_0:[^:]+]]: !fir.ref<!fir.logical<4>> {fir.bindc_name = "mask", fir.optional}
+ ! CHECK-SAME: %[[VAL_1:.*]]: !fir.ref<!fir.logical<4>> {fir.bindc_name = "back", fir.optional}
subroutine test_maxloc_optional_scalar_mask(mask, back, array)
integer :: array(:)
logical, optional :: mask
logical, optional :: back
print *, maxloc(array, mask=mask, back=back)
- ! CHECK: %[[VAL_9:.*]] = fir.is_present %[[VAL_0]] : (!fir.ref<!fir.logical<4>>) -> i1
- ! CHECK: %[[VAL_10:.*]] = fir.embox %[[VAL_0]] : (!fir.ref<!fir.logical<4>>) -> !fir.box<!fir.logical<4>>
- ! CHECK: %[[VAL_11:.*]] = fir.absent !fir.box<!fir.logical<4>>
- ! CHECK: %[[VAL_12:.*]] = arith.select %[[VAL_9]], %[[VAL_10]], %[[VAL_11]] : !fir.box<!fir.logical<4>>
- ! CHECK: %[[VAL_13:.*]] = fir.is_present %[[VAL_1]] : (!fir.ref<!fir.logical<4>>) -> i1
- ! CHECK: %[[VAL_14:.*]] = fir.if %[[VAL_13]] -> (!fir.logical<4>) {
- ! CHECK: %[[VAL_15:.*]] = fir.load %[[VAL_1]] : !fir.ref<!fir.logical<4>>
- ! CHECK: fir.result %[[VAL_15]] : !fir.logical<4>
- ! CHECK: } else {
- ! CHECK: %[[VAL_16:.*]] = arith.constant false
- ! CHECK: %[[VAL_17:.*]] = fir.convert %[[VAL_16]] : (i1) -> !fir.logical<4>
- ! CHECK: fir.result %[[VAL_17]] : !fir.logical<4>
- ! CHECK: }
- ! CHECK: %[[VAL_29:.*]] = fir.convert %[[VAL_12]] : (!fir.box<!fir.logical<4>>) -> !fir.box<none>
- ! CHECK: %[[VAL_30:.*]] = fir.convert %[[VAL_14]] : (!fir.logical<4>) -> i1
- ! CHECK: fir.call @_FortranAMaxlocInteger4(%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, %[[VAL_29]], %[[VAL_30]]) {{.*}}: (!fir.ref<!fir.box<none>>, !fir.box<none>, i32, !fir.ref<i8>, i32, !fir.box<none>, i1) -> ()
+ ! CHECK-DAG: %[[MASK:.*]]:2 = hlfir.declare %[[VAL_0]] dummy_scope %{{.*}} arg 1 {fortran_attrs = #fir.var_attrs<optional>,
+ ! CHECK-DAG: %[[BACK:.*]]:2 = hlfir.declare %[[VAL_1]] dummy_scope %{{.*}} arg 2 {fortran_attrs = #fir.var_attrs<optional>,
+ ! CHECK: %[[IS_PRESENT_MASK:.*]] = fir.is_present %[[MASK]]#0 : (!fir.ref<!fir.logical<4>>) -> i1
+ ! CHECK: %[[IS_PRESENT_BACK:.*]] = fir.is_present %[[BACK]]#0 : (!fir.ref<!fir.logical<4>>) -> i1
+ ! CHECK: %[[EMBOX:.*]] = fir.embox %[[MASK]]#0 : (!fir.ref<!fir.logical<4>>) -> !fir.box<!fir.logical<4>>
+ ! CHECK: %[[ABSENT:.*]] = fir.absent !fir.box<!fir.logical<4>>
+ ! CHECK: %[[MASK_SEL:.*]] = arith.select %[[IS_PRESENT_MASK]], %[[EMBOX]], %[[ABSENT]] : !fir.box<!fir.logical<4>>
+ ! CHECK: %[[BACK_VAL:.*]] = fir.if %[[IS_PRESENT_BACK]] -> (!fir.logical<4>)
+ ! CHECK: hlfir.maxloc %{{.*}} mask %[[MASK_SEL]] back %[[BACK_VAL]] {fastmath = #arith.fastmath<contract>} : (!fir.box<!fir.array<?xi32>>, !fir.box<!fir.logical<4>>, !fir.logical<4>) -> !hlfir.expr<1xi32>
end subroutine
! CHECK-LABEL: func @_QPtest_maxloc_optional_array_mask(
- ! CHECK-SAME: %[[VAL_0:.*]]: !fir.box<!fir.array<?x!fir.logical<4>>>
- ! CHECK-SAME: %[[VAL_1:.*]]: !fir.ref<!fir.logical<4>>
+ ! CHECK-SAME: %[[VAL_0:.*]]: !fir.box<!fir.array<?x!fir.logical<4>>> {fir.bindc_name = "mask", fir.optional}
+ ! CHECK-SAME: %[[VAL_1:.*]]: !fir.ref<!fir.logical<4>> {fir.bindc_name = "back", fir.optional}
subroutine test_maxloc_optional_array_mask(mask, back, array)
integer :: array(:)
logical, optional :: mask(:)
logical, optional :: back
print *, maxloc(array, mask=mask, back=back)
- ! CHECK: %[[VAL_9:.*]] = fir.is_present %[[VAL_1]] : (!fir.ref<!fir.logical<4>>) -> i1
- ! CHECK: %[[VAL_10:.*]] = fir.if %[[VAL_9]] -> (!fir.logical<4>) {
- ! CHECK: %[[VAL_11:.*]] = fir.load %[[VAL_1]] : !fir.ref<!fir.logical<4>>
- ! CHECK: fir.result %[[VAL_11]] : !fir.logical<4>
- ! CHECK: } else {
- ! CHECK: %[[VAL_12:.*]] = arith.constant false
- ! CHECK: %[[VAL_13:.*]] = fir.convert %[[VAL_12]] : (i1) -> !fir.logical<4>
- ! CHECK: fir.result %[[VAL_13]] : !fir.logical<4>
- ! CHECK: }
- ! CHECK: %[[VAL_25:.*]] = fir.convert %[[VAL_0]] : (!fir.box<!fir.array<?x!fir.logical<4>>>) -> !fir.box<none>
- ! CHECK: %[[VAL_26:.*]] = fir.convert %[[VAL_10]] : (!fir.logical<4>) -> i1
- ! CHECK: fir.call @_FortranAMaxlocInteger4(%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, %[[VAL_25]], %[[VAL_26]]) {{.*}}: (!fir.ref<!fir.box<none>>, !fir.box<none>, i32, !fir.ref<i8>, i32, !fir.box<none>, i1) -> ()
+ ! CHECK-DAG: %[[MASK:.*]]:2 = hlfir.declare %[[VAL_0]] dummy_scope %{{.*}} arg 1 {fortran_attrs = #fir.var_attrs<optional>,
+ ! CHECK-DAG: %[[BACK:.*]]:2 = hlfir.declare %[[VAL_1]] dummy_scope %{{.*}} arg 2 {fortran_attrs = #fir.var_attrs<optional>,
+ ! CHECK: %[[IS_PRESENT_MASK:.*]] = fir.is_present %[[MASK]]#0 : (!fir.box<!fir.array<?x!fir.logical<4>>>) -> i1
+ ! CHECK: %[[IS_PRESENT_BACK:.*]] = fir.is_present %[[BACK]]#0 : (!fir.ref<!fir.logical<4>>) -> i1
+ ! CHECK: %[[ABSENT:.*]] = fir.absent !fir.box<!fir.array<?x!fir.logical<4>>>
+ ! CHECK: %[[MASK_SEL:.*]] = arith.select %[[IS_PRESENT_MASK]], %[[MASK]]#1, %[[ABSENT]] : !fir.box<!fir.array<?x!fir.logical<4>>>
+ ! CHECK: %[[BACK_VAL:.*]] = fir.if %[[IS_PRESENT_BACK]] -> (!fir.logical<4>)
+ ! CHECK: hlfir.maxloc %{{.*}} mask %[[MASK_SEL]] back %[[BACK_VAL]] {fastmath = #arith.fastmath<contract>} : (!fir.box<!fir.array<?xi32>>, !fir.box<!fir.array<?x!fir.logical<4>>>, !fir.logical<4>) -> !hlfir.expr<1xi32>
end subroutine
diff --git a/flang/test/Lower/Intrinsics/maxval.f90 b/flang/test/Lower/Intrinsics/maxval.f90
index 92c868bd1fd01..498f5407d1cbd 100644
--- a/flang/test/Lower/Intrinsics/maxval.f90
+++ b/flang/test/Lower/Intrinsics/maxval.f90
@@ -1,69 +1,66 @@
-! RUN: bbc -emit-fir -hlfir=false %s -o - | FileCheck %s
+! RUN: %flang_fc1 -emit-hlfir %s -o - | FileCheck %s
! CHECK-LABEL: func @_QPmaxval_test(
-! CHECK-SAME: %[[arg0:.*]]: !fir.box<!fir.array<?xi32>>{{.*}}) -> i32
+! CHECK-SAME: %[[ARG0:.*]]: !fir.box<!fir.array<?xi32>>{{.*}}) -> i32 {
integer function maxval_test(a)
integer :: a(:)
-! CHECK-DAG: %[[c0:.*]] = arith.constant 0 : index
-! CHECK-DAG: %[[a2:.*]] = fir.absent !fir.box<i1>
-! CHECK-DAG: %[[a4:.*]] = fir.convert %[[arg0]] : (!fir.box<!fir.array<?xi32>>) -> !fir.box<none>
-! CHECK: %[[a6:.*]] = fir.convert %[[c0]] : (index) -> i32
-! CHECK: %[[a7:.*]] = fir.convert %[[a2]] : (!fir.box<i1>) -> !fir.box<none>
+! CHECK-DAG: %[[A:.*]]:2 = hlfir.declare %[[ARG0]] dummy_scope %{{.*}} arg 1 {uniq_name = "_QFmaxval_testEa"}
+! CHECK-DAG: %[[RES_ALLOCA:.*]] = fir.alloca i32
+! CHECK-DAG: %[[RES:.*]]:2 = hlfir.declare %[[RES_ALLOCA]] {uniq_name = "_QFmaxval_testEmaxval_test"}
maxval_test = maxval(a)
-! CHECK: %{{.*}} = fir.call @_FortranAMaxvalInteger4(%[[a4]], %{{.*}}, %{{.*}}, %[[a6]], %[[a7]]) {{.*}}: (!fir.box<none>, !fir.ref<i8>, i32, i32, !fir.box<none>) -> i32
+! CHECK: %[[MAXVAL:.*]] = hlfir.maxval %[[A]]#0 {fastmath = #arith.fastmath<contract>} : (!fir.box<!fir.array<?xi32>>) -> i32
+! CHECK: hlfir.assign %[[MAXVAL]] to %[[RES]]#0 : i32, !fir.ref<i32>
end function
! CHECK-LABEL: func @_QPmaxval_test2(
-! CHECK-SAME: %[[arg0:.*]]: !fir.ref<!fir.char<1>>, %[[arg1:.*]]: index, %[[arg2:.*]]: !fir.box<!fir.array<?x!fir.char<1>>> {fir.bindc_name = "a"}) -> !fir.boxchar<1> {
+! CHECK-SAME: %[[ARG0:.*]]: !fir.ref<!fir.char<1>>, %[[ARG1:.*]]: index, %[[ARG2:.*]]: !fir.box<!fir.array<?x!fir.char<1>>> {fir.bindc_name = "a"}) -> !fir.boxchar<1> {
character function maxval_test2(a)
character :: a(:)
-! CHECK-DAG: %[[a0:.*]] = fir.alloca !fir.box<!fir.heap<!fir.char<1,?>>>
-! CHECK: %[[a1:.*]] = fir.absent !fir.box<i1>
-! CHECK-DAG: %[[a5:.*]] = fir.convert %[[a0]] : (!fir.ref<!fir.box<!fir.heap<!fir.char<1,?>>>>) -> !fir.ref<!fir.box<none>>
-! CHECK: %[[a6:.*]] = fir.convert %[[arg2]] : (!fir.box<!fir.array<?x!fir.char<1>>>) -> !fir.box<none>
-! CHECK-DAG: %[[a8:.*]] = fir.convert %[[a1]] : (!fir.box<i1>) -> !fir.box<none>
+! CHECK-DAG: %[[A:.*]]:2 = hlfir.declare %[[ARG2]] typeparams %{{.*}} dummy_scope %{{.*}} arg 1 {uniq_name = "_QFmaxval_test2Ea"}
+! CHECK-DAG: %[[RES:.*]]:2 = hlfir.declare %[[ARG0]] typeparams %{{.*}} {uniq_name = "_QFmaxval_test2Emaxval_test2"}
maxval_test2 = maxval(a)
-! CHECK: fir.call @_FortranAMaxvalCharacter(%[[a5]], %[[a6]], %{{.*}}, %{{.*}}, %[[a8]]) {{.*}}: (!fir.ref<!fir.box<none>>, !fir.box<none>, !fir.ref<i8>, i32, !fir.box<none>) -> ()
+! CHECK: %[[MAXVAL:.*]] = hlfir.maxval %[[A]]#0 {fastmath = #arith.fastmath<contract>} : (!fir.box<!fir.array<?x!fir.char<1>>>) -> !hlfir.expr<!fir.char<1>>
+! CHECK: hlfir.assign %[[MAXVAL]] to %[[RES]]#0 : !hlfir.expr<!fir.char<1>>, !fir.ref<!fir.char<1>>
+! CHECK: hlfir.destroy %[[MAXVAL]] : !hlfir.expr<!fir.char<1>>
end function
! CHECK-LABEL: func @_QPmaxval_test3(
-! CHECK-SAME: %[[arg0:.*]]: !fir.box<!fir.array<?x?xi32>>{{.*}}, %[[arg1:.*]]: !fir.box<!fir.array<?xi32>>
+! CHECK-SAME: %[[ARG0:.*]]: !fir.box<!fir.array<?x?xi32>>{{.*}}, %[[ARG1:.*]]: !fir.box<!fir.array<?xi32>>{{.*}}) {
subroutine maxval_test3(a,r)
integer :: a(:,:)
integer :: r(:)
-! CHECK-DAG: %[[c2_i32:.*]] = arith.constant 2 : i32
-! CHECK-DAG: %[[a0:.*]] = fir.alloca !fir.box<!fir.heap<!fir.array<?xi32>>>
-! CHECK: %[[a1:.*]] = fir.absent !fir.box<i1>
-! CHECK-DAG: %[[a6:.*]] = fir.convert %[[a0]] : (!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>) -> !fir.ref<!fir.box<none>>
-! CHECK: %[[a7:.*]] = fir.convert %[[arg0]] : (!fir.box<!fir.array<?x?xi32>>) -> !fir.box<none>
-! CHECK-DAG: %[[a9:.*]] = fir.convert %[[a1]] : (!fir.box<i1>) -> !fir.box<none>
+! CHECK-DAG: %[[A:.*]]:2 = hlfir.declare %[[ARG0]] dummy_scope %{{.*}} arg 1 {uniq_name = "_QFmaxval_test3Ea"}
+! CHECK-DAG: %[[R:.*]]:2 = hlfir.declare %[[ARG1]] dummy_scope %{{.*}} arg 2 {uniq_name = "_QFmaxval_test3Er"}
+! CHECK-DAG: %[[C2:.*]] = arith.constant 2 : i32
r = maxval(a,dim=2)
-! CHECK: fir.call @_FortranAMaxvalDim(%[[a6]], %[[a7]], %[[c2_i32]], %{{.*}}, %{{.*}}, %[[a9]]) {{.*}}: (!fir.ref<!fir.box<none>>, !fir.box<none>, i32, !fir.ref<i8>, i32, !fir.box<none>) -> ()
-! CHECK: %[[a11:.*]] = fir.load %[[a0]] : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>
-! CHECK-DAG: %[[a13:.*]] = fir.box_addr %[[a11]] : (!fir.box<!fir.heap<!fir.array<?xi32>>>) -> !fir.heap<!fir.array<?xi32>>
-! CHECK-DAG: fir.freemem %[[a13]]
+! CHECK: %[[MAXVAL:.*]] = hlfir.maxval %[[A]]#0 dim %[[C2]] {fastmath = #arith.fastmath<contract>} : (!fir.box<!fir.array<?x?xi32>>, i32) -> !hlfir.expr<?xi32>
+! CHECK: hlfir.assign %[[MAXVAL]] to %[[R]]#0 : !hlfir.expr<?xi32>, !fir.box<!fir.array<?xi32>>
+! CHECK: hlfir.destroy %[[MAXVAL]] : !hlfir.expr<?xi32>
end subroutine
! CHECK-LABEL: func @_QPtest_maxval_optional_scalar_mask(
-! CHECK-SAME: %[[VAL_1:.*]]: !fir.ref<!fir.logical<4>>
+! CHECK-SAME: %[[VAL_0:[^:]+]]: !fir.ref<!fir.logical<4>> {fir.bindc_name = "mask", fir.optional}
subroutine test_maxval_optional_scalar_mask(mask, array)
integer :: array(:)
logical, optional :: mask
print *, maxval(array, mask)
-! CHECK: %[[VAL_7:.*]] = fir.is_present %[[VAL_1]] : (!fir.ref<!fir.logical<4>>) -> i1
-! CHECK: %[[VAL_8:.*]] = fir.embox %[[VAL_1]] : (!fir.ref<!fir.logical<4>>) -> !fir.box<!fir.logical<4>>
-! CHECK: %[[VAL_9:.*]] = fir.absent !fir.box<!fir.logical<4>>
-! CHECK: %[[VAL_10:.*]] = arith.select %[[VAL_7]], %[[VAL_8]], %[[VAL_9]] : !fir.box<!fir.logical<4>>
-! CHECK: %[[VAL_17:.*]] = fir.convert %[[VAL_10]] : (!fir.box<!fir.logical<4>>) -> !fir.box<none>
-! CHECK: fir.call @_FortranAMaxvalInteger4(%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, %[[VAL_17]]) {{.*}}: (!fir.box<none>, !fir.ref<i8>, i32, i32, !fir.box<none>) -> i32
+! CHECK-DAG: %[[MASK:.*]]:2 = hlfir.declare %[[VAL_0]] dummy_scope %{{.*}} arg 1 {fortran_attrs = #fir.var_attrs<optional>,
+! CHECK: %[[IS_PRESENT:.*]] = fir.is_present %[[MASK]]#0 : (!fir.ref<!fir.logical<4>>) -> i1
+! CHECK: %[[EMBOX:.*]] = fir.embox %[[MASK]]#0 : (!fir.ref<!fir.logical<4>>) -> !fir.box<!fir.logical<4>>
+! CHECK: %[[ABSENT:.*]] = fir.absent !fir.box<!fir.logical<4>>
+! CHECK: %[[MASK_SEL:.*]] = arith.select %[[IS_PRESENT]], %[[EMBOX]], %[[ABSENT]] : !fir.box<!fir.logical<4>>
+! CHECK: hlfir.maxval %{{.*}} mask %[[MASK_SEL]] {fastmath = #arith.fastmath<contract>} : (!fir.box<!fir.array<?xi32>>, !fir.box<!fir.logical<4>>) -> i32
end subroutine
! CHECK-LABEL: func @_QPtest_maxval_optional_array_mask(
-! CHECK-SAME: %[[VAL_0:.*]]: !fir.box<!fir.array<?x!fir.logical<4>>>
+! CHECK-SAME: %[[VAL_0:.*]]: !fir.box<!fir.array<?x!fir.logical<4>>> {fir.bindc_name = "mask", fir.optional}
subroutine test_maxval_optional_array_mask(mask, array)
integer :: array(:)
logical, optional :: mask(:)
print *, maxval(array, mask)
-! CHECK: %[[VAL_13:.*]] = fir.convert %[[VAL_0]] : (!fir.box<!fir.array<?x!fir.logical<4>>>) -> !fir.box<none>
-! CHECK: fir.call @_FortranAMaxvalInteger4(%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, %[[VAL_13]]) {{.*}}: (!fir.box<none>, !fir.ref<i8>, i32, i32, !fir.box<none>) -> i32
+! CHECK-DAG: %[[MASK:.*]]:2 = hlfir.declare %[[VAL_0]] dummy_scope %{{.*}} arg 1 {fortran_attrs = #fir.var_attrs<optional>,
+! CHECK: %[[IS_PRESENT:.*]] = fir.is_present %[[MASK]]#0 : (!fir.box<!fir.array<?x!fir.logical<4>>>) -> i1
+! CHECK: %[[ABSENT:.*]] = fir.absent !fir.box<!fir.array<?x!fir.logical<4>>>
+! CHECK: %[[MASK_SEL:.*]] = arith.select %[[IS_PRESENT]], %[[MASK]]#1, %[[ABSENT]] : !fir.box<!fir.array<?x!fir.logical<4>>>
+! CHECK: hlfir.maxval %{{.*}} mask %[[MASK_SEL]] {fastmath = #arith.fastmath<contract>} : (!fir.box<!fir.array<?xi32>>, !fir.box<!fir.array<?x!fir.logical<4>>>) -> i32
end subroutine
diff --git a/flang/test/Lower/Intrinsics/merge.f90 b/flang/test/Lower/Intrinsics/merge.f90
index 52417f83294b6..81287648e06b9 100644
--- a/flang/test/Lower/Intrinsics/merge.f90
+++ b/flang/test/Lower/Intrinsics/merge.f90
@@ -1,37 +1,45 @@
-! RUN: bbc -emit-fir -hlfir=false %s -o - | FileCheck %s
-! RUN: %flang_fc1 -emit-fir -flang-deprecated-no-hlfir %s -o - | FileCheck %s
+! RUN: %flang_fc1 -emit-hlfir %s -o - | FileCheck %s
! CHECK-LABEL: func @_QPmerge_test(
-! CHECK-SAME: %[[arg0:.*]]: !fir.ref<!fir.char<1>>{{.*}}, %[[arg1:.*]]: index{{.*}}, %[[arg2:[^:]+]]: !fir.boxchar<1>{{.*}}, %[[arg3:[^:]+]]: !fir.boxchar<1>{{.*}}, %[[arg4:.*]]: !fir.ref<!fir.logical<4>>{{.*}}) -> !fir.boxchar<1> {
+! CHECK-SAME: %[[ARG0:.*]]: !fir.ref<!fir.char<1>>{{.*}}, %[[ARG1:.*]]: index{{.*}}, %[[ARG2:[^:]+]]: !fir.boxchar<1>{{.*}}, %[[ARG3:[^:]+]]: !fir.boxchar<1>{{.*}}, %[[ARG4:.*]]: !fir.ref<!fir.logical<4>>{{.*}}) -> !fir.boxchar<1> {
function merge_test(o1, o2, mask)
character :: o1, o2, merge_test
logical :: mask
merge_test = merge(o1, o2, mask)
-! CHECK: %[[a0:.*]]:2 = fir.unboxchar %[[arg2]] : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1,?>>, index)
-! CHECK: %[[a0_cast:.*]] = fir.convert %[[a0]]#0 : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<!fir.char<1>>
-! CHECK: %[[a1:.*]]:2 = fir.unboxchar %[[arg3]] : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1,?>>, index)
-! CHECK: %[[a1_cast:.*]] = fir.convert %[[a1]]#0 : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<!fir.char<1>>
-! CHECK: %[[a2:.*]] = fir.load %[[arg4]] : !fir.ref<!fir.logical<4>>
-! CHECK: %[[a3:.*]] = fir.convert %[[a2]] : (!fir.logical<4>) -> i1
-! CHECK: %[[a4:.*]] = arith.select %[[a3]], %[[a0_cast]], %[[a1_cast]] : !fir.ref<!fir.char<1>>
-! CHECK: %{{.*}} = fir.load %[[a4]] : !fir.ref<!fir.char<1>>
+! CHECK-DAG: %[[MASK:.*]]:2 = hlfir.declare %[[ARG4]] dummy_scope %{{.*}} arg 3 {uniq_name = "_QFmerge_testEmask"}
+! CHECK-DAG: %[[RES:.*]]:2 = hlfir.declare %[[ARG0]] typeparams %{{.*}} {uniq_name = "_QFmerge_testEmerge_test"}
+! CHECK: %[[O1_UNBOX:.*]]:2 = fir.unboxchar %[[ARG2]] : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1,?>>, index)
+! CHECK: %[[O1_CAST:.*]] = fir.convert %[[O1_UNBOX]]#0 : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<!fir.char<1>>
+! CHECK: %[[O1:.*]]:2 = hlfir.declare %[[O1_CAST]] typeparams %{{.*}} dummy_scope %{{.*}} arg 1 {uniq_name = "_QFmerge_testEo1"}
+! CHECK: %[[O2_UNBOX:.*]]:2 = fir.unboxchar %[[ARG3]] : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1,?>>, index)
+! CHECK: %[[O2_CAST:.*]] = fir.convert %[[O2_UNBOX]]#0 : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<!fir.char<1>>
+! CHECK: %[[O2:.*]]:2 = hlfir.declare %[[O2_CAST]] typeparams %{{.*}} dummy_scope %{{.*}} arg 2 {uniq_name = "_QFmerge_testEo2"}
+! CHECK: %[[MASK_VAL:.*]] = fir.load %[[MASK]]#0 : !fir.ref<!fir.logical<4>>
+! CHECK: %[[MASK_BOOL:.*]] = fir.convert %[[MASK_VAL]] : (!fir.logical<4>) -> i1
+! CHECK: %[[SEL:.*]] = arith.select %[[MASK_BOOL]], %[[O1]]#0, %[[O2]]#0 : !fir.ref<!fir.char<1>>
+! CHECK: %[[TMP:.*]]:2 = hlfir.declare %[[SEL]] typeparams %{{.*}} {uniq_name = ".tmp.intrinsic_result"}
+! CHECK: %[[EXPR:.*]] = hlfir.as_expr %[[TMP]]#0 : (!fir.ref<!fir.char<1>>) -> !hlfir.expr<!fir.char<1>>
+! CHECK: hlfir.assign %[[EXPR]] to %[[RES]]#0 : !hlfir.expr<!fir.char<1>>, !fir.ref<!fir.char<1>>
+! CHECK: hlfir.destroy %[[EXPR]] : !hlfir.expr<!fir.char<1>>
end
! CHECK-LABEL: func @_QPmerge_test2(
-! CHECK-SAME: %[[arg0:[^:]+]]: !fir.ref<i32>{{.*}}, %[[arg1:[^:]+]]: !fir.ref<i32>{{.*}}, %[[arg2:.*]]: !fir.ref<!fir.logical<4>>{{.*}}) -> i32 {
+! CHECK-SAME: %[[ARG0:[^:]+]]: !fir.ref<i32>{{.*}}, %[[ARG1:[^:]+]]: !fir.ref<i32>{{.*}}, %[[ARG2:.*]]: !fir.ref<!fir.logical<4>>{{.*}}) -> i32 {
function merge_test2(o1, o2, mask)
integer :: o1, o2, merge_test2
logical :: mask
merge_test2 = merge(o1, o2, mask)
-! CHECK: %[[a1:.*]] = fir.load %[[arg0]] : !fir.ref<i32>
-! CHECK: %[[a2:.*]] = fir.load %[[arg1]] : !fir.ref<i32>
-! CHECK: %[[a3:.*]] = fir.load %[[arg2]] : !fir.ref<!fir.logical<4>>
-! CHECK: %[[a4:.*]] = fir.convert %[[a3]] : (!fir.logical<4>) -> i1
-! CHECK: %{{.*}} = arith.select %[[a4]], %[[a1]], %[[a2]] : i32
+! CHECK-DAG: %[[MASK:.*]]:2 = hlfir.declare %[[ARG2]] dummy_scope %{{.*}} arg 3 {uniq_name = "_QFmerge_test2Emask"}
+! CHECK-DAG: %[[O1:.*]]:2 = hlfir.declare %[[ARG0]] dummy_scope %{{.*}} arg 1 {uniq_name = "_QFmerge_test2Eo1"}
+! CHECK-DAG: %[[O2:.*]]:2 = hlfir.declare %[[ARG1]] dummy_scope %{{.*}} arg 2 {uniq_name = "_QFmerge_test2Eo2"}
+! CHECK: %[[O1_VAL:.*]] = fir.load %[[O1]]#0 : !fir.ref<i32>
+! CHECK: %[[O2_VAL:.*]] = fir.load %[[O2]]#0 : !fir.ref<i32>
+! CHECK: %[[MASK_VAL:.*]] = fir.load %[[MASK]]#0 : !fir.ref<!fir.logical<4>>
+! CHECK: %[[MASK_BOOL:.*]] = fir.convert %[[MASK_VAL]] : (!fir.logical<4>) -> i1
+! CHECK: %{{.*}} = arith.select %[[MASK_BOOL]], %[[O1_VAL]], %[[O2_VAL]] : i32
end
! CHECK-LABEL: func @_QPmerge_test3(
-! CHECK-SAME: %[[arg0:[^:]+]]: !fir.ref<!fir.array<10x!fir.type<_QFmerge_test3Tt{i:i32}>>>{{.*}}, %[[arg1:[^:]+]]: !fir.ref<!fir.type<_QFmerge_test3Tt{i:i32}>>{{.*}}, %[[arg2:[^:]+]]: !fir.ref<!fir.type<_QFmerge_test3Tt{i:i32}>>{{.*}}, %[[arg3:.*]]: !fir.ref<!fir.logical<4>>{{.*}}) {
subroutine merge_test3(result, o1, o2, mask)
type t
integer :: i
@@ -39,9 +47,16 @@ subroutine merge_test3(result, o1, o2, mask)
type(t) :: result(10), o1, o2
logical :: mask
result = merge(o1, o2, mask)
-! CHECK: %[[mask:.*]] = fir.load %[[arg3]] : !fir.ref<!fir.logical<4>>
-! CHECK: %[[mask_cast:.*]] = fir.convert %[[mask]] : (!fir.logical<4>) -> i1
-! CHECK: = arith.select %[[mask_cast]], %[[arg1]], %[[arg2]] : !fir.ref<!fir.type<_QFmerge_test3Tt{i:i32}>>
+! CHECK: %[[MASK:.*]]:2 = hlfir.declare %{{.*}} dummy_scope %{{.*}} arg 4 {uniq_name = "_QFmerge_test3Emask"}
+! CHECK: %[[O1:.*]]:2 = hlfir.declare %{{.*}} dummy_scope %{{.*}} arg 2 {uniq_name = "_QFmerge_test3Eo1"}
+! CHECK: %[[O2:.*]]:2 = hlfir.declare %{{.*}} dummy_scope %{{.*}} arg 3 {uniq_name = "_QFmerge_test3Eo2"}
+! CHECK: %[[MASK_VAL:.*]] = fir.load %[[MASK]]#0 : !fir.ref<!fir.logical<4>>
+! CHECK: %[[MASK_BOOL:.*]] = fir.convert %[[MASK_VAL]] : (!fir.logical<4>) -> i1
+! CHECK: %[[SEL:.*]] = arith.select %[[MASK_BOOL]], %[[O1]]#0, %[[O2]]#0 : !fir.ref<!fir.type<_QFmerge_test3Tt{i:i32}>>
+! CHECK: %[[TMP:.*]]:2 = hlfir.declare %[[SEL]] {uniq_name = ".tmp.intrinsic_result"}
+! CHECK: %[[EXPR:.*]] = hlfir.as_expr %[[TMP]]#0 : (!fir.ref<!fir.type<_QFmerge_test3Tt{i:i32}>>) -> !hlfir.expr<!fir.type<_QFmerge_test3Tt{i:i32}>>
+! CHECK: hlfir.assign %[[EXPR]] to %{{.*}}#0 : !hlfir.expr<!fir.type<_QFmerge_test3Tt{i:i32}>>, !fir.ref<!fir.array<10x!fir.type<_QFmerge_test3Tt{i:i32}>>>
+! CHECK: hlfir.destroy %[[EXPR]] : !hlfir.expr<!fir.type<_QFmerge_test3Tt{i:i32}>>
end
! CHECK-LABEL: func @_QPmerge_logical_var_and_expr(
@@ -50,15 +65,17 @@ subroutine merge_logical_var_and_expr(l1, l2)
! CHECK-SAME: %[[VAL_1:.*]]: !fir.ref<!fir.logical<4>> {fir.bindc_name = "l2"}) {
logical :: l1, l2
call bar(merge(l1, .true., l2))
-! CHECK: %[[VAL_2:.*]] = fir.alloca !fir.logical<4>
-! CHECK: %[[VAL_3:.*]] = fir.load %[[VAL_0]] : !fir.ref<!fir.logical<4>>
-! CHECK: %[[VAL_4:.*]] = arith.constant true
-! CHECK: %[[VAL_5:.*]] = fir.load %[[VAL_1]] : !fir.ref<!fir.logical<4>>
-! CHECK: %[[VAL_6:.*]] = fir.convert %[[VAL_5]] : (!fir.logical<4>) -> i1
-! CHECK: %[[VAL_7:.*]] = fir.convert %[[VAL_4]] : (i1) -> !fir.logical<4>
-! CHECK: %[[VAL_8:.*]] = arith.select %[[VAL_6]], %[[VAL_3]], %[[VAL_7]] : !fir.logical<4>
-! CHECK: fir.store %[[VAL_8]] to %[[VAL_2]] : !fir.ref<!fir.logical<4>>
-! CHECK: fir.call @_QPbar(%[[VAL_2]]) {{.*}}: (!fir.ref<!fir.logical<4>>) -> ()
+! CHECK-DAG: %[[L1:.*]]:2 = hlfir.declare %[[VAL_0]] dummy_scope %{{.*}} arg 1 {uniq_name = "_QFmerge_logical_var_and_exprEl1"}
+! CHECK-DAG: %[[L2:.*]]:2 = hlfir.declare %[[VAL_1]] dummy_scope %{{.*}} arg 2 {uniq_name = "_QFmerge_logical_var_and_exprEl2"}
+! CHECK: %[[TRUE:.*]] = arith.constant true
+! CHECK: %[[L1_VAL:.*]] = fir.load %[[L1]]#0 : !fir.ref<!fir.logical<4>>
+! CHECK: %[[L2_VAL:.*]] = fir.load %[[L2]]#0 : !fir.ref<!fir.logical<4>>
+! CHECK: %[[L2_BOOL:.*]] = fir.convert %[[L2_VAL]] : (!fir.logical<4>) -> i1
+! CHECK: %[[TRUE_LOG:.*]] = fir.convert %[[TRUE]] : (i1) -> !fir.logical<4>
+! CHECK: %[[SEL:.*]] = arith.select %[[L2_BOOL]], %[[L1_VAL]], %[[TRUE_LOG]] : !fir.logical<4>
+! CHECK: %[[ASSOC:.*]]:3 = hlfir.associate %[[SEL]] {adapt.valuebyref}
+! CHECK: fir.call @_QPbar(%[[ASSOC]]#0) {{.*}}: (!fir.ref<!fir.logical<4>>) -> ()
+! CHECK: hlfir.end_associate %[[ASSOC]]#1, %[[ASSOC]]#2
end subroutine
! CHECK-LABEL: func @_QPmerge_cst_and_dyn_char(
@@ -69,14 +86,19 @@ subroutine merge_cst_and_dyn_char(dyn, l)
character(*) :: dyn
logical :: l
print *, merge(cst, dyn, l)
-! CHECK: %[[VAL_2:.*]] = fir.address_of(@_QFmerge_cst_and_dyn_charEcst) : !fir.ref<!fir.char<1,4>>
-! CHECK: %[[VAL_3:.*]] = arith.constant 4 : index
-! CHECK: %[[VAL_4:.*]]:2 = fir.unboxchar %[[VAL_0]] : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1,?>>, index)
-! CHECK: %[[VAL_10:.*]] = fir.load %[[VAL_1]] : !fir.ref<!fir.logical<4>>
-! CHECK: %[[VAL_11:.*]] = fir.convert %[[VAL_10]] : (!fir.logical<4>) -> i1
-! CHECK: %[[VAL_12:.*]] = fir.convert %[[VAL_4]]#0 : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<!fir.char<1,4>>
-! CHECK: %[[VAL_13:.*]] = arith.select %[[VAL_11]], %[[VAL_2]], %[[VAL_12]] : !fir.ref<!fir.char<1,4>>
-! CHECK: %[[VAL_14:.*]] = fir.convert %[[VAL_13]] : (!fir.ref<!fir.char<1,4>>) -> !fir.ref<i8>
-! CHECK: %[[VAL_15:.*]] = fir.convert %[[VAL_3]] : (index) -> i64
-! CHECK: fir.call @_FortranAioOutputAscii(%{{.*}}, %[[VAL_14]], %[[VAL_15]]) {{.*}}: (!fir.ref<i8>, !fir.ref<i8>, i64) -> i1
+! CHECK: %[[CST:.*]]:2 = hlfir.declare %{{.*}} typeparams %{{.*}} {uniq_name = "_QFmerge_cst_and_dyn_charEcst"}
+! CHECK: %[[DYN_UNBOX:.*]]:2 = fir.unboxchar %[[VAL_0]] : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1,?>>, index)
+! CHECK: %[[DYN:.*]]:2 = hlfir.declare %[[DYN_UNBOX]]#0 typeparams %[[DYN_UNBOX]]#1 dummy_scope %{{.*}} arg 1 {uniq_name = "_QFmerge_cst_and_dyn_charEdyn"}
+! CHECK: %[[L:.*]]:2 = hlfir.declare %[[VAL_1]] dummy_scope %{{.*}} arg 2 {uniq_name = "_QFmerge_cst_and_dyn_charEl"}
+! CHECK: %[[L_VAL:.*]] = fir.load %[[L]]#0 : !fir.ref<!fir.logical<4>>
+! CHECK: %[[L_BOOL:.*]] = fir.convert %[[L_VAL]] : (!fir.logical<4>) -> i1
+! CHECK: %[[DYN_CAST:.*]] = fir.convert %[[DYN]]#1 : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<!fir.char<1,4>>
+! CHECK: %[[SEL:.*]] = arith.select %[[L_BOOL]], %[[CST]]#0, %[[DYN_CAST]] : !fir.ref<!fir.char<1,4>>
+! CHECK: %[[TMP:.*]]:2 = hlfir.declare %[[SEL]] typeparams %{{.*}} {uniq_name = ".tmp.intrinsic_result"}
+! CHECK: %[[EXPR:.*]] = hlfir.as_expr %[[TMP]]#0 : (!fir.ref<!fir.char<1,4>>) -> !hlfir.expr<!fir.char<1,4>>
+! CHECK: %[[ASSOC:.*]]:3 = hlfir.associate %[[EXPR]] typeparams %{{.*}} {adapt.valuebyref}
+! CHECK: %[[ASSOC_CAST:.*]] = fir.convert %[[ASSOC]]#0 : (!fir.ref<!fir.char<1,4>>) -> !fir.ref<i8>
+! CHECK: fir.call @_FortranAioOutputAscii(%{{.*}}, %[[ASSOC_CAST]], %{{.*}}) {{.*}}: (!fir.ref<i8>, !fir.ref<i8>, i64) -> i1
+! CHECK: hlfir.end_associate %[[ASSOC]]#1, %[[ASSOC]]#2
+! CHECK: hlfir.destroy %[[EXPR]] : !hlfir.expr<!fir.char<1,4>>
end subroutine
diff --git a/flang/test/Lower/Intrinsics/merge_bits.f90 b/flang/test/Lower/Intrinsics/merge_bits.f90
index 8cd72f5fd3228..1cf824656238b 100644
--- a/flang/test/Lower/Intrinsics/merge_bits.f90
+++ b/flang/test/Lower/Intrinsics/merge_bits.f90
@@ -1,5 +1,4 @@
-! RUN: bbc -emit-fir -hlfir=false %s -o - | FileCheck %s
-! RUN: %flang_fc1 -emit-fir -flang-deprecated-no-hlfir %s -o - | FileCheck %s
+! RUN: %flang_fc1 -emit-hlfir %s -o - | FileCheck %s
! CHECK-LABEL: merge_bits1_test
! CHECK-SAME: %[[IREF:.*]]: !fir.ref<i8>{{.*}}, %[[JREF:.*]]: !fir.ref<i8>{{.*}}, %[[MREF:.*]]: !fir.ref<i8>{{.*}}, %[[RREF:.*]]: !fir.ref<i8>{{.*}}
@@ -7,16 +6,20 @@ subroutine merge_bits1_test(i, j, m, r)
integer(1) :: i, j, m
integer(1) :: r
- ! CHECK: %[[I:.*]] = fir.load %[[IREF]] : !fir.ref<i8>
- ! CHECK: %[[J:.*]] = fir.load %[[JREF]] : !fir.ref<i8>
- ! CHECK: %[[M:.*]] = fir.load %[[MREF]] : !fir.ref<i8>
+ ! CHECK-DAG: %[[I_DECL:.*]]:2 = hlfir.declare %[[IREF]] {{.*}} {uniq_name = "_QFmerge_bits1_testEi"}
+ ! CHECK-DAG: %[[J_DECL:.*]]:2 = hlfir.declare %[[JREF]] {{.*}} {uniq_name = "_QFmerge_bits1_testEj"}
+ ! CHECK-DAG: %[[M_DECL:.*]]:2 = hlfir.declare %[[MREF]] {{.*}} {uniq_name = "_QFmerge_bits1_testEm"}
+ ! CHECK-DAG: %[[R_DECL:.*]]:2 = hlfir.declare %[[RREF]] {{.*}} {uniq_name = "_QFmerge_bits1_testEr"}
+ ! CHECK: %[[I:.*]] = fir.load %[[I_DECL]]#0 : !fir.ref<i8>
+ ! CHECK: %[[J:.*]] = fir.load %[[J_DECL]]#0 : !fir.ref<i8>
+ ! CHECK: %[[M:.*]] = fir.load %[[M_DECL]]#0 : !fir.ref<i8>
r = merge_bits(i, j, m)
! CHECK: %[[C__1:.*]] = arith.constant -1 : i8
! CHECK: %[[NM:.*]] = arith.xori %[[M]], %[[C__1]] : i8
! CHECK: %[[LFT:.*]] = arith.andi %[[I]], %[[M]] : i8
! CHECK: %[[RGT:.*]] = arith.andi %[[J]], %[[NM]] : i8
! CHECK: %[[RES:.*]] = arith.ori %[[LFT]], %[[RGT]] : i8
- ! CHECK: fir.store %[[RES]] to %[[RREF]] : !fir.ref<i8>
+ ! CHECK: hlfir.assign %[[RES]] to %[[R_DECL]]#0 : i8, !fir.ref<i8>
end subroutine merge_bits1_test
! CHECK-LABEL: merge_bits2_test
@@ -25,16 +28,20 @@ subroutine merge_bits2_test(i, j, m, r)
integer(2) :: i, j, m
integer(2) :: r
- ! CHECK: %[[I:.*]] = fir.load %[[IREF]] : !fir.ref<i16>
- ! CHECK: %[[J:.*]] = fir.load %[[JREF]] : !fir.ref<i16>
- ! CHECK: %[[M:.*]] = fir.load %[[MREF]] : !fir.ref<i16>
+ ! CHECK-DAG: %[[I_DECL:.*]]:2 = hlfir.declare %[[IREF]] {{.*}} {uniq_name = "_QFmerge_bits2_testEi"}
+ ! CHECK-DAG: %[[J_DECL:.*]]:2 = hlfir.declare %[[JREF]] {{.*}} {uniq_name = "_QFmerge_bits2_testEj"}
+ ! CHECK-DAG: %[[M_DECL:.*]]:2 = hlfir.declare %[[MREF]] {{.*}} {uniq_name = "_QFmerge_bits2_testEm"}
+ ! CHECK-DAG: %[[R_DECL:.*]]:2 = hlfir.declare %[[RREF]] {{.*}} {uniq_name = "_QFmerge_bits2_testEr"}
+ ! CHECK: %[[I:.*]] = fir.load %[[I_DECL]]#0 : !fir.ref<i16>
+ ! CHECK: %[[J:.*]] = fir.load %[[J_DECL]]#0 : !fir.ref<i16>
+ ! CHECK: %[[M:.*]] = fir.load %[[M_DECL]]#0 : !fir.ref<i16>
r = merge_bits(i, j, m)
! CHECK: %[[C__1:.*]] = arith.constant -1 : i16
! CHECK: %[[NM:.*]] = arith.xori %[[M]], %[[C__1]] : i16
! CHECK: %[[LFT:.*]] = arith.andi %[[I]], %[[M]] : i16
! CHECK: %[[RGT:.*]] = arith.andi %[[J]], %[[NM]] : i16
! CHECK: %[[RES:.*]] = arith.ori %[[LFT]], %[[RGT]] : i16
- ! CHECK: fir.store %[[RES]] to %[[RREF]] : !fir.ref<i16>
+ ! CHECK: hlfir.assign %[[RES]] to %[[R_DECL]]#0 : i16, !fir.ref<i16>
end subroutine merge_bits2_test
! CHECK-LABEL: merge_bits4_test
@@ -43,16 +50,20 @@ subroutine merge_bits4_test(i, j, m, r)
integer(4) :: i, j, m
integer(4) :: r
- ! CHECK: %[[I:.*]] = fir.load %[[IREF]] : !fir.ref<i32>
- ! CHECK: %[[J:.*]] = fir.load %[[JREF]] : !fir.ref<i32>
- ! CHECK: %[[M:.*]] = fir.load %[[MREF]] : !fir.ref<i32>
+ ! CHECK-DAG: %[[I_DECL:.*]]:2 = hlfir.declare %[[IREF]] {{.*}} {uniq_name = "_QFmerge_bits4_testEi"}
+ ! CHECK-DAG: %[[J_DECL:.*]]:2 = hlfir.declare %[[JREF]] {{.*}} {uniq_name = "_QFmerge_bits4_testEj"}
+ ! CHECK-DAG: %[[M_DECL:.*]]:2 = hlfir.declare %[[MREF]] {{.*}} {uniq_name = "_QFmerge_bits4_testEm"}
+ ! CHECK-DAG: %[[R_DECL:.*]]:2 = hlfir.declare %[[RREF]] {{.*}} {uniq_name = "_QFmerge_bits4_testEr"}
+ ! CHECK: %[[I:.*]] = fir.load %[[I_DECL]]#0 : !fir.ref<i32>
+ ! CHECK: %[[J:.*]] = fir.load %[[J_DECL]]#0 : !fir.ref<i32>
+ ! CHECK: %[[M:.*]] = fir.load %[[M_DECL]]#0 : !fir.ref<i32>
r = merge_bits(i, j, m)
! CHECK: %[[C__1:.*]] = arith.constant -1 : i32
! CHECK: %[[NM:.*]] = arith.xori %[[M]], %[[C__1]] : i32
! CHECK: %[[LFT:.*]] = arith.andi %[[I]], %[[M]] : i32
! CHECK: %[[RGT:.*]] = arith.andi %[[J]], %[[NM]] : i32
! CHECK: %[[RES:.*]] = arith.ori %[[LFT]], %[[RGT]] : i32
- ! CHECK: fir.store %[[RES]] to %[[RREF]] : !fir.ref<i32>
+ ! CHECK: hlfir.assign %[[RES]] to %[[R_DECL]]#0 : i32, !fir.ref<i32>
end subroutine merge_bits4_test
! CHECK-LABEL: merge_bits8_test
@@ -61,16 +72,20 @@ subroutine merge_bits8_test(i, j, m, r)
integer(8) :: i, j, m
integer(8) :: r
- ! CHECK: %[[I:.*]] = fir.load %[[IREF]] : !fir.ref<i64>
- ! CHECK: %[[J:.*]] = fir.load %[[JREF]] : !fir.ref<i64>
- ! CHECK: %[[M:.*]] = fir.load %[[MREF]] : !fir.ref<i64>
+ ! CHECK-DAG: %[[I_DECL:.*]]:2 = hlfir.declare %[[IREF]] {{.*}} {uniq_name = "_QFmerge_bits8_testEi"}
+ ! CHECK-DAG: %[[J_DECL:.*]]:2 = hlfir.declare %[[JREF]] {{.*}} {uniq_name = "_QFmerge_bits8_testEj"}
+ ! CHECK-DAG: %[[M_DECL:.*]]:2 = hlfir.declare %[[MREF]] {{.*}} {uniq_name = "_QFmerge_bits8_testEm"}
+ ! CHECK-DAG: %[[R_DECL:.*]]:2 = hlfir.declare %[[RREF]] {{.*}} {uniq_name = "_QFmerge_bits8_testEr"}
+ ! CHECK: %[[I:.*]] = fir.load %[[I_DECL]]#0 : !fir.ref<i64>
+ ! CHECK: %[[J:.*]] = fir.load %[[J_DECL]]#0 : !fir.ref<i64>
+ ! CHECK: %[[M:.*]] = fir.load %[[M_DECL]]#0 : !fir.ref<i64>
r = merge_bits(i, j, m)
! CHECK: %[[C__1:.*]] = arith.constant -1 : i64
! CHECK: %[[NM:.*]] = arith.xori %[[M]], %[[C__1]] : i64
! CHECK: %[[LFT:.*]] = arith.andi %[[I]], %[[M]] : i64
! CHECK: %[[RGT:.*]] = arith.andi %[[J]], %[[NM]] : i64
! CHECK: %[[RES:.*]] = arith.ori %[[LFT]], %[[RGT]] : i64
- ! CHECK: fir.store %[[RES]] to %[[RREF]] : !fir.ref<i64>
+ ! CHECK: hlfir.assign %[[RES]] to %[[R_DECL]]#0 : i64, !fir.ref<i64>
end subroutine merge_bits8_test
! CHECK-LABEL: merge_bitsz0_test
@@ -79,16 +94,19 @@ subroutine merge_bitsz0_test(j, m, r)
integer :: j, m
integer :: r
+ ! CHECK-DAG: %[[J_DECL:.*]]:2 = hlfir.declare %[[JREF]] {{.*}} {uniq_name = "_QFmerge_bitsz0_testEj"}
+ ! CHECK-DAG: %[[M_DECL:.*]]:2 = hlfir.declare %[[MREF]] {{.*}} {uniq_name = "_QFmerge_bitsz0_testEm"}
+ ! CHECK-DAG: %[[R_DECL:.*]]:2 = hlfir.declare %[[RREF]] {{.*}} {uniq_name = "_QFmerge_bitsz0_testEr"}
! CHECK: %[[I:.*]] = arith.constant 13 : i32
- ! CHECK: %[[J:.*]] = fir.load %[[JREF]] : !fir.ref<i32>
- ! CHECK: %[[M:.*]] = fir.load %[[MREF]] : !fir.ref<i32>
+ ! CHECK: %[[J:.*]] = fir.load %[[J_DECL]]#0 : !fir.ref<i32>
+ ! CHECK: %[[M:.*]] = fir.load %[[M_DECL]]#0 : !fir.ref<i32>
r = merge_bits(B'1101', j, m)
! CHECK: %[[C__1:.*]] = arith.constant -1 : i32
! CHECK: %[[NM:.*]] = arith.xori %[[M]], %[[C__1]] : i32
! CHECK: %[[LFT:.*]] = arith.andi %[[I]], %[[M]] : i32
! CHECK: %[[RGT:.*]] = arith.andi %[[J]], %[[NM]] : i32
! CHECK: %[[RES:.*]] = arith.ori %[[LFT]], %[[RGT]] : i32
- ! CHECK: fir.store %[[RES]] to %[[RREF]] : !fir.ref<i32>
+ ! CHECK: hlfir.assign %[[RES]] to %[[R_DECL]]#0 : i32, !fir.ref<i32>
end subroutine merge_bitsz0_test
! CHECK-LABEL: merge_bitsz1_test
@@ -97,14 +115,17 @@ subroutine merge_bitsz1_test(i, m, r)
integer :: i, m
integer :: r
- ! CHECK: %[[I:.*]] = fir.load %[[IREF]] : !fir.ref<i32>
+ ! CHECK-DAG: %[[I_DECL:.*]]:2 = hlfir.declare %[[IREF]] {{.*}} {uniq_name = "_QFmerge_bitsz1_testEi"}
+ ! CHECK-DAG: %[[M_DECL:.*]]:2 = hlfir.declare %[[MREF]] {{.*}} {uniq_name = "_QFmerge_bitsz1_testEm"}
+ ! CHECK-DAG: %[[R_DECL:.*]]:2 = hlfir.declare %[[RREF]] {{.*}} {uniq_name = "_QFmerge_bitsz1_testEr"}
! CHECK: %[[J:.*]] = arith.constant 13 : i32
- ! CHECK: %[[M:.*]] = fir.load %[[MREF]] : !fir.ref<i32>
+ ! CHECK: %[[I:.*]] = fir.load %[[I_DECL]]#0 : !fir.ref<i32>
+ ! CHECK: %[[M:.*]] = fir.load %[[M_DECL]]#0 : !fir.ref<i32>
r = merge_bits(i, Z'0D', m)
! CHECK: %[[C__1:.*]] = arith.constant -1 : i32
! CHECK: %[[NM:.*]] = arith.xori %[[M]], %[[C__1]] : i32
! CHECK: %[[LFT:.*]] = arith.andi %[[I]], %[[M]] : i32
! CHECK: %[[RGT:.*]] = arith.andi %[[J]], %[[NM]] : i32
! CHECK: %[[RES:.*]] = arith.ori %[[LFT]], %[[RGT]] : i32
- ! CHECK: fir.store %[[RES]] to %[[RREF]] : !fir.ref<i32>
+ ! CHECK: hlfir.assign %[[RES]] to %[[R_DECL]]#0 : i32, !fir.ref<i32>
end subroutine merge_bitsz1_test
diff --git a/flang/test/Lower/Intrinsics/minloc.f90 b/flang/test/Lower/Intrinsics/minloc.f90
index fa3bc9b67ad91..6660944f50b12 100644
--- a/flang/test/Lower/Intrinsics/minloc.f90
+++ b/flang/test/Lower/Intrinsics/minloc.f90
@@ -1,89 +1,66 @@
-! RUN: bbc -emit-fir -hlfir=false %s -o - | FileCheck %s
+! RUN: %flang_fc1 -emit-hlfir %s -o - | FileCheck %s
! CHECK-LABEL: func @_QPminloc_test(
-! CHECK-SAME: %[[arg0:.*]]: !fir.box<!fir.array<?xi32>>{{.*}}, %[[arg1:.*]]: !fir.box<!fir.array<?xi32>>
+! CHECK-SAME: %[[ARG0:.*]]: !fir.box<!fir.array<?xi32>>{{.*}}, %[[ARG1:.*]]: !fir.box<!fir.array<?xi32>>{{.*}}) {
subroutine minloc_test(arr,res)
integer :: arr(:)
integer :: res(:)
- ! CHECK-DAG: %[[c4:.*]] = arith.constant 4 : index
- ! CHECK-DAG: %[[a0:.*]] = fir.alloca !fir.box<!fir.heap<!fir.array<?xi32>>>
- ! CHECK-DAG: %[[a1:.*]] = fir.absent !fir.box<i1>
- ! CHECK-DAG: %[[a6:.*]] = fir.convert %[[a0]] : (!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>) -> !fir.ref<!fir.box<none>>
- ! CHECK-DAG: %[[a7:.*]] = fir.convert %[[arg0]] : (!fir.box<!fir.array<?xi32>>) -> !fir.box<none>
- ! CHECK-DAG: %[[a8:.*]] = fir.convert %[[c4]] : (index) -> i32
- ! CHECK-DAG: %[[a10:.*]] = fir.convert %[[a1]] : (!fir.box<i1>) -> !fir.box<none>
+ ! CHECK-DAG: %[[ARR:.*]]:2 = hlfir.declare %[[ARG0]] dummy_scope %{{.*}} arg 1 {uniq_name = "_QFminloc_testEarr"}
+ ! CHECK-DAG: %[[RES:.*]]:2 = hlfir.declare %[[ARG1]] dummy_scope %{{.*}} arg 2 {uniq_name = "_QFminloc_testEres"}
res = minloc(arr)
- ! CHECK: fir.call @_FortranAMinlocInteger4(%[[a6]], %[[a7]], %[[a8]], %{{.*}}, %{{.*}}, %[[a10]], %false) {{.*}}: (!fir.ref<!fir.box<none>>, !fir.box<none>, i32, !fir.ref<i8>, i32, !fir.box<none>, i1) -> ()
- ! CHECK-DAG: %[[a12:.*]] = fir.load %[[a0]] : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>
- ! CHECK-DAG: %[[a14:.*]] = fir.box_addr %[[a12]] : (!fir.box<!fir.heap<!fir.array<?xi32>>>) -> !fir.heap<!fir.array<?xi32>>
- ! CHECK-DAG: fir.freemem %[[a14]]
+ ! CHECK: %[[MINLOC:.*]] = hlfir.minloc %[[ARR]]#0 {fastmath = #arith.fastmath<contract>} : (!fir.box<!fir.array<?xi32>>) -> !hlfir.expr<1xi32>
+ ! CHECK: hlfir.assign %[[MINLOC]] to %[[RES]]#0 : !hlfir.expr<1xi32>, !fir.box<!fir.array<?xi32>>
+ ! CHECK: hlfir.destroy %[[MINLOC]] : !hlfir.expr<1xi32>
end subroutine
! CHECK-LABEL: func @_QPminloc_test2(
- ! CHECK-SAME: %[[arg0:.*]]: !fir.box<!fir.array<?xi32>>{{.*}}, %[[arg1:.*]]: !fir.box<!fir.array<?xi32>>{{.*}}, %[[arg2:.*]]: !fir.ref<i32>
+ ! CHECK-SAME: %[[ARG0:.*]]: !fir.box<!fir.array<?xi32>>{{.*}}, %[[ARG1:.*]]: !fir.box<!fir.array<?xi32>>{{.*}}, %[[ARG2:.*]]: !fir.ref<i32>{{.*}}) {
subroutine minloc_test2(arr,res,d)
integer :: arr(:)
integer :: res(:)
integer :: d
- ! CHECK-DAG: %[[c4:.*]] = arith.constant 4 : index
- ! CHECK-DAG: %[[a0:.*]] = fir.alloca !fir.box<!fir.heap<i32>>
- ! CHECK-DAG: %[[a1:.*]] = fir.load %arg2 : !fir.ref<i32>
- ! CHECK-DAG: %[[a2:.*]] = fir.absent !fir.box<i1>
- ! CHECK-DAG: %[[a6:.*]] = fir.convert %[[a0]] : (!fir.ref<!fir.box<!fir.heap<i32>>>) -> !fir.ref<!fir.box<none>>
- ! CHECK-DAG: %[[a7:.*]] = fir.convert %arg0 : (!fir.box<!fir.array<?xi32>>) -> !fir.box<none>
- ! CHECK-DAG: %[[a8:.*]] = fir.convert %[[c4]] : (index) -> i32
- ! CHECK-DAG: %[[a10:.*]] = fir.convert %[[a2]] : (!fir.box<i1>) -> !fir.box<none>
+ ! CHECK-DAG: %[[ARR:.*]]:2 = hlfir.declare %[[ARG0]] dummy_scope %{{.*}} arg 1 {uniq_name = "_QFminloc_test2Earr"}
+ ! CHECK-DAG: %[[D:.*]]:2 = hlfir.declare %[[ARG2]] dummy_scope %{{.*}} arg 3 {uniq_name = "_QFminloc_test2Ed"}
+ ! CHECK-DAG: %[[RES:.*]]:2 = hlfir.declare %[[ARG1]] dummy_scope %{{.*}} arg 2 {uniq_name = "_QFminloc_test2Eres"}
res = minloc(arr, dim=d)
- ! CHECK: fir.call @_FortranAMinlocDim(%[[a6]], %[[a7]], %[[a8]], %[[a1]], %{{.*}}, %{{.*}}, %[[a10]], %false) {{.*}}: (!fir.ref<!fir.box<none>>, !fir.box<none>, i32, i32, !fir.ref<i8>, i32, !fir.box<none>, i1) -> ()
- ! CHECK: %[[a12:.*]] = fir.load %0 : !fir.ref<!fir.box<!fir.heap<i32>>>
- ! CHECK: %[[a13:.*]] = fir.box_addr %[[a12]] : (!fir.box<!fir.heap<i32>>) -> !fir.heap<i32>
- ! CHECK: fir.freemem %[[a13]]
+ ! CHECK: %[[D_VAL:.*]] = fir.load %[[D]]#0 : !fir.ref<i32>
+ ! CHECK: %[[MINLOC:.*]] = hlfir.minloc %[[ARR]]#0 dim %[[D_VAL]] {fastmath = #arith.fastmath<contract>} : (!fir.box<!fir.array<?xi32>>, i32) -> i32
+ ! CHECK: hlfir.assign %[[MINLOC]] to %[[RES]]#0 : i32, !fir.box<!fir.array<?xi32>>
end subroutine
! CHECK-LABEL: func @_QPtest_minloc_optional_scalar_mask(
- ! CHECK-SAME: %[[VAL_0:[^:]+]]: !fir.ref<!fir.logical<4>>
- ! CHECK-SAME: %[[VAL_1:.*]]: !fir.ref<!fir.logical<4>>
+ ! CHECK-SAME: %[[VAL_0:[^:]+]]: !fir.ref<!fir.logical<4>> {fir.bindc_name = "mask", fir.optional}
+ ! CHECK-SAME: %[[VAL_1:.*]]: !fir.ref<!fir.logical<4>> {fir.bindc_name = "back", fir.optional}
subroutine test_minloc_optional_scalar_mask(mask, back, array)
integer :: array(:)
logical, optional :: mask
logical, optional :: back
print *, minloc(array, mask=mask, back=back)
- ! CHECK: %[[VAL_9:.*]] = fir.is_present %[[VAL_0]] : (!fir.ref<!fir.logical<4>>) -> i1
- ! CHECK: %[[VAL_10:.*]] = fir.embox %[[VAL_0]] : (!fir.ref<!fir.logical<4>>) -> !fir.box<!fir.logical<4>>
- ! CHECK: %[[VAL_11:.*]] = fir.absent !fir.box<!fir.logical<4>>
- ! CHECK: %[[VAL_12:.*]] = arith.select %[[VAL_9]], %[[VAL_10]], %[[VAL_11]] : !fir.box<!fir.logical<4>>
- ! CHECK: %[[VAL_13:.*]] = fir.is_present %[[VAL_1]] : (!fir.ref<!fir.logical<4>>) -> i1
- ! CHECK: %[[VAL_14:.*]] = fir.if %[[VAL_13]] -> (!fir.logical<4>) {
- ! CHECK: %[[VAL_15:.*]] = fir.load %[[VAL_1]] : !fir.ref<!fir.logical<4>>
- ! CHECK: fir.result %[[VAL_15]] : !fir.logical<4>
- ! CHECK: } else {
- ! CHECK: %[[VAL_16:.*]] = arith.constant false
- ! CHECK: %[[VAL_17:.*]] = fir.convert %[[VAL_16]] : (i1) -> !fir.logical<4>
- ! CHECK: fir.result %[[VAL_17]] : !fir.logical<4>
- ! CHECK: }
- ! CHECK: %[[VAL_29:.*]] = fir.convert %[[VAL_12]] : (!fir.box<!fir.logical<4>>) -> !fir.box<none>
- ! CHECK: %[[VAL_30:.*]] = fir.convert %[[VAL_14]] : (!fir.logical<4>) -> i1
- ! CHECK: fir.call @_FortranAMinlocInteger4(%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, %[[VAL_29]], %[[VAL_30]]) {{.*}}: (!fir.ref<!fir.box<none>>, !fir.box<none>, i32, !fir.ref<i8>, i32, !fir.box<none>, i1) -> ()
+ ! CHECK-DAG: %[[MASK:.*]]:2 = hlfir.declare %[[VAL_0]] dummy_scope %{{.*}} arg 1 {fortran_attrs = #fir.var_attrs<optional>,
+ ! CHECK-DAG: %[[BACK:.*]]:2 = hlfir.declare %[[VAL_1]] dummy_scope %{{.*}} arg 2 {fortran_attrs = #fir.var_attrs<optional>,
+ ! CHECK: %[[IS_PRESENT_MASK:.*]] = fir.is_present %[[MASK]]#0 : (!fir.ref<!fir.logical<4>>) -> i1
+ ! CHECK: %[[IS_PRESENT_BACK:.*]] = fir.is_present %[[BACK]]#0 : (!fir.ref<!fir.logical<4>>) -> i1
+ ! CHECK: %[[EMBOX:.*]] = fir.embox %[[MASK]]#0 : (!fir.ref<!fir.logical<4>>) -> !fir.box<!fir.logical<4>>
+ ! CHECK: %[[ABSENT:.*]] = fir.absent !fir.box<!fir.logical<4>>
+ ! CHECK: %[[MASK_SEL:.*]] = arith.select %[[IS_PRESENT_MASK]], %[[EMBOX]], %[[ABSENT]] : !fir.box<!fir.logical<4>>
+ ! CHECK: %[[BACK_VAL:.*]] = fir.if %[[IS_PRESENT_BACK]] -> (!fir.logical<4>)
+ ! CHECK: hlfir.minloc %{{.*}} mask %[[MASK_SEL]] back %[[BACK_VAL]] {fastmath = #arith.fastmath<contract>} : (!fir.box<!fir.array<?xi32>>, !fir.box<!fir.logical<4>>, !fir.logical<4>) -> !hlfir.expr<1xi32>
end subroutine
! CHECK-LABEL: func @_QPtest_minloc_optional_array_mask(
- ! CHECK-SAME: %[[VAL_0:.*]]: !fir.box<!fir.array<?x!fir.logical<4>>>
- ! CHECK-SAME: %[[VAL_1:.*]]: !fir.ref<!fir.logical<4>>
+ ! CHECK-SAME: %[[VAL_0:.*]]: !fir.box<!fir.array<?x!fir.logical<4>>> {fir.bindc_name = "mask", fir.optional}
+ ! CHECK-SAME: %[[VAL_1:.*]]: !fir.ref<!fir.logical<4>> {fir.bindc_name = "back", fir.optional}
subroutine test_minloc_optional_array_mask(mask, back, array)
integer :: array(:)
logical, optional :: mask(:)
logical, optional :: back
print *, minloc(array, mask=mask, back=back)
- ! CHECK: %[[VAL_9:.*]] = fir.is_present %[[VAL_1]] : (!fir.ref<!fir.logical<4>>) -> i1
- ! CHECK: %[[VAL_10:.*]] = fir.if %[[VAL_9]] -> (!fir.logical<4>) {
- ! CHECK: %[[VAL_11:.*]] = fir.load %[[VAL_1]] : !fir.ref<!fir.logical<4>>
- ! CHECK: fir.result %[[VAL_11]] : !fir.logical<4>
- ! CHECK: } else {
- ! CHECK: %[[VAL_12:.*]] = arith.constant false
- ! CHECK: %[[VAL_13:.*]] = fir.convert %[[VAL_12]] : (i1) -> !fir.logical<4>
- ! CHECK: fir.result %[[VAL_13]] : !fir.logical<4>
- ! CHECK: }
- ! CHECK: %[[VAL_25:.*]] = fir.convert %[[VAL_0]] : (!fir.box<!fir.array<?x!fir.logical<4>>>) -> !fir.box<none>
- ! CHECK: %[[VAL_26:.*]] = fir.convert %[[VAL_10]] : (!fir.logical<4>) -> i1
- ! CHECK: fir.call @_FortranAMinlocInteger4(%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, %[[VAL_25]], %[[VAL_26]]) {{.*}}: (!fir.ref<!fir.box<none>>, !fir.box<none>, i32, !fir.ref<i8>, i32, !fir.box<none>, i1) -> ()
+ ! CHECK-DAG: %[[MASK:.*]]:2 = hlfir.declare %[[VAL_0]] dummy_scope %{{.*}} arg 1 {fortran_attrs = #fir.var_attrs<optional>,
+ ! CHECK-DAG: %[[BACK:.*]]:2 = hlfir.declare %[[VAL_1]] dummy_scope %{{.*}} arg 2 {fortran_attrs = #fir.var_attrs<optional>,
+ ! CHECK: %[[IS_PRESENT_MASK:.*]] = fir.is_present %[[MASK]]#0 : (!fir.box<!fir.array<?x!fir.logical<4>>>) -> i1
+ ! CHECK: %[[IS_PRESENT_BACK:.*]] = fir.is_present %[[BACK]]#0 : (!fir.ref<!fir.logical<4>>) -> i1
+ ! CHECK: %[[ABSENT:.*]] = fir.absent !fir.box<!fir.array<?x!fir.logical<4>>>
+ ! CHECK: %[[MASK_SEL:.*]] = arith.select %[[IS_PRESENT_MASK]], %[[MASK]]#1, %[[ABSENT]] : !fir.box<!fir.array<?x!fir.logical<4>>>
+ ! CHECK: %[[BACK_VAL:.*]] = fir.if %[[IS_PRESENT_BACK]] -> (!fir.logical<4>)
+ ! CHECK: hlfir.minloc %{{.*}} mask %[[MASK_SEL]] back %[[BACK_VAL]] {fastmath = #arith.fastmath<contract>} : (!fir.box<!fir.array<?xi32>>, !fir.box<!fir.array<?x!fir.logical<4>>>, !fir.logical<4>) -> !hlfir.expr<1xi32>
end subroutine
More information about the flang-commits
mailing list