[flang-commits] [flang] [flang][NFC] Converted five tests from old lowering to new lowering (part 36) (PR #187628)
via flang-commits
flang-commits at lists.llvm.org
Thu Mar 19 21:11:17 PDT 2026
llvmbot wrote:
<!--LLVM PR SUMMARY COMMENT-->
@llvm/pr-subscribers-flang-fir-hlfir
Author: Eugene Epshteyn (eugeneepshteyn)
<details>
<summary>Changes</summary>
Tests converted from test/Lower/Intrinsics: maxloc.f90, maxval.f90, merge.f90, merge_bits.f90, minloc.f90
---
Patch is 46.97 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/187628.diff
5 Files Affected:
- (modified) flang/test/Lower/Intrinsics/maxloc.f90 (+35-58)
- (modified) flang/test/Lower/Intrinsics/maxval.f90 (+33-36)
- (modified) flang/test/Lower/Intrinsics/merge.f90 (+62-40)
- (modified) flang/test/Lower/Intrinsics/merge_bits.f90 (+45-24)
- (modified) flang/test/Lower/Intrinsics/minloc.f90 (+35-58)
``````````diff
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_sco...
[truncated]
``````````
</details>
https://github.com/llvm/llvm-project/pull/187628
More information about the flang-commits
mailing list