372 lines · plain
1! Test lowering of MINLOC intrinsic to HLFIR2! RUN: bbc -emit-hlfir -o - %s 2>&1 | FileCheck %s3 4! simple 1 argument MINLOC5subroutine minloc1(a, s)6 integer :: a(:), s(:)7 s = MINLOC(a)8end subroutine9! CHECK-LABEL: func.func @_QPminloc1(10! CHECK: %[[ARG0:.*]]: !fir.box<!fir.array<?xi32>> {fir.bindc_name = "a"}, %[[ARG1:.*]]: !fir.box<!fir.array<?xi32>>11! CHECK-DAG: %[[ARRAY:.*]]:2 = hlfir.declare %[[ARG0]]12! CHECK-DAG: %[[OUT:.*]]:2 = hlfir.declare %[[ARG1]]13! CHECK-NEXT: %[[EXPR:.*]] = hlfir.minloc %[[ARRAY]]#0 {fastmath = #arith.fastmath<contract>} : (!fir.box<!fir.array<?xi32>>) -> !hlfir.expr<1xi32>14! CHECK-NEXT: hlfir.assign %[[EXPR]] to %[[OUT]]#0 : !hlfir.expr<1xi32>, !fir.box<!fir.array<?xi32>>15! CHECK-NEXT: hlfir.destroy %[[EXPR]] : !hlfir.expr<1xi32>16! CHECK-NEXT: return17! CHECK-NEXT: }18 19! minloc with by-ref DIM argument20subroutine minloc2(a, s, d)21 integer :: a(:,:), s(:), d22 s = MINLOC(a, d)23end subroutine24! CHECK-LABEL: func.func @_QPminloc2(25! CHECK: %[[ARG0:.*]]: !fir.box<!fir.array<?x?xi32>> {fir.bindc_name = "a"}, %[[ARG1:.*]]: !fir.box<!fir.array<?xi32>> {fir.bindc_name = "s"}, %[[ARG2:.*]]: !fir.ref<i32>26! CHECK-DAG: %[[ARRAY:.*]]:2 = hlfir.declare %[[ARG0]]27! CHECK-DAG: %[[OUT:.*]]:2 = hlfir.declare %[[ARG1]]28! CHECK-DAG: %[[DIM_REF:.*]]:2 = hlfir.declare %[[ARG2]]29! CHECK-NEXT: %[[DIM:.*]] = fir.load %[[DIM_REF]]#0 : !fir.ref<i32>30! CHECK-NEXT: %[[EXPR:.*]] = hlfir.minloc %[[ARRAY]]#0 dim %[[DIM]] {fastmath = #arith.fastmath<contract>} : (!fir.box<!fir.array<?x?xi32>>, i32) -> !hlfir.expr<?xi32>31! CHECK-NEXT: hlfir.assign %[[EXPR]] to %[[OUT]]#0 : !hlfir.expr<?xi32>, !fir.box<!fir.array<?xi32>>32! CHECK-NEXT: hlfir.destroy %[[EXPR]]33! CHECK-NEXT: return34! CHECK-NEXT: }35 36! minloc with scalar mask argument37subroutine minloc3(a, s, m)38 integer :: a(:), s(:)39 logical :: m40 s = MINLOC(a, m)41end subroutine42! CHECK-LABEL: func.func @_QPminloc3(43! CHECK: %[[ARG0:.*]]: !fir.box<!fir.array<?xi32>> {fir.bindc_name = "a"}, %[[ARG1:.*]]: !fir.box<!fir.array<?xi32>> {fir.bindc_name = "s"}, %[[ARG2:.*]]: !fir.ref<!fir.logical<4>>44! CHECK-DAG: %[[ARRAY:.*]]:2 = hlfir.declare %[[ARG0]]45! CHECK-DAG: %[[OUT:.*]]:2 = hlfir.declare %[[ARG1]]46! CHECK-DAG: %[[MASK:.*]]:2 = hlfir.declare %[[ARG2]]47! CHECK-NEXT: %[[EXPR:.*]] = hlfir.minloc %[[ARRAY]]#0 mask %[[MASK]]#0 {fastmath = #arith.fastmath<contract>} : (!fir.box<!fir.array<?xi32>>, !fir.ref<!fir.logical<4>>) -> !hlfir.expr<1xi32>48! CHECK-NEXT: hlfir.assign %[[EXPR]] to %[[OUT]]#0 : !hlfir.expr<1xi32>, !fir.box<!fir.array<?xi32>>49! CHECK-NEXT: hlfir.destroy %[[EXPR]] : !hlfir.expr<1xi32>50! CHECK-NEXT: return51! CHECK-NEXT: }52 53! minloc with array mask argument54subroutine minloc4(a, s, m)55 integer :: a(:), s(:)56 logical :: m(:)57 s = MINLOC(a, m)58end subroutine59! CHECK-LABEL: func.func @_QPminloc4(60! CHECK: %[[ARG0:.*]]: !fir.box<!fir.array<?xi32>> {fir.bindc_name = "a"}, %[[ARG1:.*]]: !fir.box<!fir.array<?xi32>> {fir.bindc_name = "s"}, %[[ARG2:.*]]: !fir.box<!fir.array<?x!fir.logical<4>>>61! CHECK-DAG: %[[ARRAY:.*]]:2 = hlfir.declare %[[ARG0]]62! CHECK-DAG: %[[OUT:.*]]:2 = hlfir.declare %[[ARG1]]63! CHECK-DAG: %[[MASK:.*]]:2 = hlfir.declare %[[ARG2]]64! CHECK-NEXT: %[[EXPR:.*]] = hlfir.minloc %[[ARRAY]]#0 mask %[[MASK]]#0 {fastmath = #arith.fastmath<contract>} : (!fir.box<!fir.array<?xi32>>, !fir.box<!fir.array<?x!fir.logical<4>>>) -> !hlfir.expr<1xi32>65! CHECK-NEXT: hlfir.assign %[[EXPR]] to %[[OUT]]#0 : !hlfir.expr<1xi32>, !fir.box<!fir.array<?xi32>>66! CHECK-NEXT: hlfir.destroy %[[EXPR]] : !hlfir.expr<1xi32>67! CHECK-NEXT: return68! CHECK-NEXT: }69 70! minloc with all 3 arguments, dim is by-val, array isn't boxed71subroutine minloc5(s)72 integer :: s(2)73 integer :: a(2,2) = reshape((/1, 2, 3, 4/), [2,2])74 s = minloc(a, 1, .true.)75end subroutine76! CHECK-LABEL: func.func @_QPminloc577! CHECK: %[[ARG0:.*]]: !fir.ref<!fir.array<2xi32>>78! CHECK-DAG: %[[ADDR:.*]] = fir.address_of({{.*}}) : !fir.ref<!fir.array<2x2xi32>>79! CHECK-DAG: %[[ARRAY_SHAPE:.*]] = fir.shape {{.*}} -> !fir.shape<2>80! CHECK-DAG: %[[ARRAY:.*]]:2 = hlfir.declare %[[ADDR]](%[[ARRAY_SHAPE]])81! CHECK-DAG: %[[OUT_SHAPE:.*]] = fir.shape {{.*}} -> !fir.shape<1>82! CHECK-DAG: %[[OUT:.*]]:2 = hlfir.declare %[[ARG0]](%[[OUT_SHAPE]])83! CHECK-DAG: %[[TRUE:.*]] = arith.constant true84! CHECK-DAG: %[[C1:.*]] = arith.constant 1 : i3285! CHECK-NEXT: %[[EXPR:.*]] = hlfir.minloc %[[ARRAY]]#0 dim %[[C1]] mask %[[TRUE]] {fastmath = #arith.fastmath<contract>} : (!fir.ref<!fir.array<2x2xi32>>, i32, i1) -> !hlfir.expr<2xi32>86! CHECK-NEXT: hlfir.assign %[[EXPR]] to %[[OUT]]#0 : !hlfir.expr<2xi32>, !fir.ref<!fir.array<2xi32>>87! CHECK-NEXT: hlfir.destroy %[[EXPR]] : !hlfir.expr<2xi32>88! CHECK-NEXT: return89! CHECK-NEXT: }90 91! back argument as .true.92subroutine minloc_back(a, s)93 integer :: a(:), s(:)94 s = MINLOC(a, BACK=.TRUE.)95end subroutine96! CHECK-LABEL: func.func @_QPminloc_back(97! CHECK: %[[ARG0:.*]]: !fir.box<!fir.array<?xi32>> {fir.bindc_name = "a"}, %[[ARG1:.*]]: !fir.box<!fir.array<?xi32>>98! CHECK-DAG: %[[ARRAY:.*]]:2 = hlfir.declare %[[ARG0]]99! CHECK-DAG: %[[OUT:.*]]:2 = hlfir.declare %[[ARG1]]100! CHECK-DAG: %[[C1:.*]] = arith.constant true101! CHECK-NEXT: %[[EXPR:.*]] = hlfir.minloc %[[ARRAY]]#0 back %[[C1]] {fastmath = #arith.fastmath<contract>} : (!fir.box<!fir.array<?xi32>>, i1) -> !hlfir.expr<1xi32>102! CHECK-NEXT: hlfir.assign %[[EXPR]] to %[[OUT]]#0 : !hlfir.expr<1xi32>, !fir.box<!fir.array<?xi32>>103! CHECK-NEXT: hlfir.destroy %[[EXPR]] : !hlfir.expr<1xi32>104! CHECK-NEXT: return105! CHECK-NEXT: }106 107! back argument as logical108subroutine minloc_back2(a, s, b)109 integer :: a(:), s(:)110 logical :: b111 s = MINLOC(a, BACK=b)112end subroutine113! CHECK-LABEL: func.func @_QPminloc_back2(114! CHECK: %[[ARG0:.*]]: !fir.box<!fir.array<?xi32>> {fir.bindc_name = "a"}, %[[ARG1:.*]]: !fir.box<!fir.array<?xi32>> {fir.bindc_name = "s"}, %[[ARG2:.*]]: !fir.ref<!fir.logical<4>>115! CHECK-DAG: %[[ARRAY:.*]]:2 = hlfir.declare %[[ARG0]]116! CHECK-DAG: %[[BACKD:.*]]:2 = hlfir.declare %[[ARG2]]117! CHECK-DAG: %[[OUT:.*]]:2 = hlfir.declare %[[ARG1]]118! CHECK-NEXT: %[[BACK:.*]] = fir.load %[[BACKD]]#0 : !fir.ref<!fir.logical<4>>119! CHECK-NEXT: %[[EXPR:.*]] = hlfir.minloc %[[ARRAY]]#0 back %[[BACK]] {fastmath = #arith.fastmath<contract>} : (!fir.box<!fir.array<?xi32>>, !fir.logical<4>) -> !hlfir.expr<1xi32>120! CHECK-NEXT: hlfir.assign %[[EXPR]] to %[[OUT]]#0 : !hlfir.expr<1xi32>, !fir.box<!fir.array<?xi32>>121! CHECK-NEXT: hlfir.destroy %[[EXPR]] : !hlfir.expr<1xi32>122! CHECK-NEXT: return123! CHECK-NEXT: }124 125! back argument as optional logical126subroutine minloc_back3(a, s, b)127 integer :: a(:), s(:)128 logical, optional :: b129 s = MINLOC(a, BACK=b)130end subroutine131! CHECK-LABEL: func.func @_QPminloc_back3(132! CHECK: %[[ARG0:.*]]: !fir.box<!fir.array<?xi32>> {fir.bindc_name = "a"}, %[[ARG1:.*]]: !fir.box<!fir.array<?xi32>> {fir.bindc_name = "s"}, %[[ARG2:.*]]: !fir.ref<!fir.logical<4>> {fir.bindc_name = "b", fir.optional}) {133! CHECK: %[[ARRAY:.*]]:2 = hlfir.declare %[[ARG0]]134! CHECK-NEXT: %[[BACKD:.*]]:2 = hlfir.declare %[[ARG2]]135! CHECK-NEXT: %[[OUT:.*]]:2 = hlfir.declare %[[ARG1]]136! CHECK-NEXT: %[[IFP:.*]] = fir.is_present %[[BACKD]]#0 : (!fir.ref<!fir.logical<4>>) -> i1137! CHECK-NEXT: %[[BACK:.*]] = fir.if %[[IFP]] -> (!fir.logical<4>) {138! CHECK-NEXT: %[[IFT:.*]] = fir.load %[[BACKD]]#0 : !fir.ref<!fir.logical<4>>139! CHECK-NEXT: fir.result %[[IFT]] : !fir.logical<4>140! CHECK-NEXT: } else {141! CHECK-NEXT: %false = arith.constant false142! CHECK-NEXT: %[[IFE:.*]] = fir.convert %false : (i1) -> !fir.logical<4>143! CHECK-NEXT: fir.result %[[IFE]] : !fir.logical<4>144! CHECK-NEXT: }145! CHECK-NEXT: %[[EXPR:.*]] = hlfir.minloc %[[ARRAY]]#0 back %[[BACK]] {fastmath = #arith.fastmath<contract>} : (!fir.box<!fir.array<?xi32>>, !fir.logical<4>) -> !hlfir.expr<1xi32>146! CHECK-NEXT: hlfir.assign %[[EXPR]] to %[[OUT]]#0 : !hlfir.expr<1xi32>, !fir.box<!fir.array<?xi32>>147! CHECK-NEXT: hlfir.destroy %[[EXPR]] : !hlfir.expr<1xi32>148! CHECK-NEXT: return149! CHECK-NEXT: }150 151 152! kind = 2153subroutine minloc_kind(a, s)154 integer :: a(:), s(:)155 s = MINLOC(a, KIND=2)156end subroutine157! CHECK-LABEL: func.func @_QPminloc_kind(158! CHECK: %[[ARG0:.*]]: !fir.box<!fir.array<?xi32>> {fir.bindc_name = "a"}, %[[ARG1:.*]]: !fir.box<!fir.array<?xi32>>159! CHECK-DAG: %[[ARRAY:.*]]:2 = hlfir.declare %[[ARG0]]160! CHECK-DAG: %[[OUT:.*]]:2 = hlfir.declare %[[ARG1]]161! CHECK: %[[EXPR:.*]] = hlfir.minloc %[[ARRAY]]#0 {fastmath = #arith.fastmath<contract>} : (!fir.box<!fir.array<?xi32>>) -> !hlfir.expr<1xi16>162! CHECK: %[[ELM:.*]] = hlfir.elemental163! CHECK: hlfir.assign %[[ELM]] to %[[OUT]]#0 : !hlfir.expr<?xi32>, !fir.box<!fir.array<?xi32>>164! CHECK-NEXT: hlfir.destroy %[[ELM]] : !hlfir.expr<?xi32>165! CHECK-NEXT: hlfir.destroy %[[EXPR]] : !hlfir.expr<1xi16>166! CHECK-NEXT: return167! CHECK-NEXT: }168 169subroutine minloc6(a, s, d)170 integer, pointer :: d171 integer s(:)172 real :: a(:,:)173 s = minloc(a, (d))174end subroutine175! CHECK-LABEL: func.func @_QPminloc6(176! CHECK: %[[ARG0:.*]]: !fir.box<!fir.array<?x?xf32>>177! CHECK: %[[ARG1:.*]]: !fir.box<!fir.array<?xi32>>178! CHECK: %[[ARG2:.*]]: !fir.ref<!fir.box<!fir.ptr<i32>>>179! CHECK-DAG: %[[ARRAY:.*]]:2 = hlfir.declare %[[ARG0]]180! CHECK-DAG: %[[OUT:.*]]:2 = hlfir.declare %[[ARG1]]181! CHECK-DAG: %[[DIM_VAR:.*]]:2 = hlfir.declare %[[ARG2]]182! CHECK-NEXT: %[[DIM_BOX:.*]] = fir.load %[[DIM_VAR]]#0 : !fir.ref<!fir.box<!fir.ptr<i32>>>183! CHECK-NEXT: %[[DIM_ADDR:.*]] = fir.box_addr %[[DIM_BOX]] : (!fir.box<!fir.ptr<i32>>) -> !fir.ptr<i32>184! CHECK-NEXT: %[[DIM0:.*]] = fir.load %[[DIM_ADDR]] : !fir.ptr<i32>185! CHECK-NEXT: %[[DIM1:.*]] = hlfir.no_reassoc %[[DIM0]] : i32186! CHECK-NEXT: %[[EXPR:.*]] = hlfir.minloc %[[ARRAY]]#0 dim %[[DIM1]] {fastmath = #arith.fastmath<contract>} : (!fir.box<!fir.array<?x?xf32>>, i32) -> !hlfir.expr<?xi32>187! CHECK-NEXT: hlfir.assign %[[EXPR]] to %[[OUT]]#0 : !hlfir.expr<?xi32>, !fir.box<!fir.array<?xi32>>188! CHECK-NEXT: hlfir.destroy %[[EXPR]]189! CHECK-NEXT: return190! CHECK-NEXT: }191 192! simple 1 argument MINLOC for character193subroutine minloc7(a, s)194 character(*) :: a(:)195 integer :: s(:)196 s = MINLOC(a)197end subroutine198! CHECK-LABEL: func.func @_QPminloc7(199! CHECK: %[[ARG0:.*]]: !fir.box<!fir.array<?x!fir.char<1,?>>> {fir.bindc_name = "a"}, %[[ARG1:.*]]: !fir.box<!fir.array<?xi32>>200! CHECK-DAG: %[[ARRAY:.*]]:2 = hlfir.declare %[[ARG0]]201! CHECK-DAG: %[[OUT:.*]]:2 = hlfir.declare %[[ARG1]]202! CHECK-NEXT: %[[EXPR:.*]] = hlfir.minloc %[[ARRAY]]#0 {fastmath = #arith.fastmath<contract>} : (!fir.box<!fir.array<?x!fir.char<1,?>>>) -> !hlfir.expr<1xi32>203! CHECK-NEXT: hlfir.assign %[[EXPR]] to %[[OUT]]#0 : !hlfir.expr<1xi32>, !fir.box<!fir.array<?xi32>>204! CHECK-NEXT: hlfir.destroy %[[EXPR]]205! CHECK-NEXT: return206! CHECK-NEXT: }207 208! minloc for character with by-ref DIM argument209subroutine minloc8(a, s, d)210 character(*) :: a(:,:)211 integer :: d, s(:)212 s = MINLOC(a, d)213end subroutine214! CHECK-LABEL: func.func @_QPminloc8(215! CHECK: %[[ARG0:.*]]: !fir.box<!fir.array<?x?x!fir.char<1,?>>> {fir.bindc_name = "a"}, %[[ARG1:.*]]: !fir.box<!fir.array<?xi32>> {fir.bindc_name = "s"}, %[[ARG2:.*]]: !fir.ref<i32>216! CHECK-DAG: %[[ARRAY:.*]]:2 = hlfir.declare %[[ARG0]]217! CHECK-DAG: %[[OUT:.*]]:2 = hlfir.declare %[[ARG1]]218! CHECK-DAG: %[[DIM_REF:.*]]:2 = hlfir.declare %[[ARG2]]219! CHECK-NEXT: %[[DIM:.*]] = fir.load %[[DIM_REF]]#0 : !fir.ref<i32>220! CHECK-NEXT: %[[EXPR:.*]] = hlfir.minloc %[[ARRAY]]#0 dim %[[DIM]] {fastmath = #arith.fastmath<contract>} : (!fir.box<!fir.array<?x?x!fir.char<1,?>>>, i32) -> !hlfir.expr<?xi32>221! CHECK-NEXT: hlfir.assign %[[EXPR]] to %[[OUT]]#0 : !hlfir.expr<?xi32>, !fir.box<!fir.array<?xi32>>222! CHECK-NEXT: hlfir.destroy %[[EXPR]]223! CHECK-NEXT: return224! CHECK-NEXT: }225 226! minloc for character with scalar mask argument227subroutine minloc9(a, s, m)228 character(*) :: a(:)229 integer :: s(:)230 logical :: m231 s = MINLOC(a, m)232end subroutine233! CHECK-LABEL: func.func @_QPminloc9(234! CHECK: %[[ARG0:.*]]: !fir.box<!fir.array<?x!fir.char<1,?>>> {fir.bindc_name = "a"}, %[[ARG1:.*]]: !fir.box<!fir.array<?xi32>> {fir.bindc_name = "s"}, %[[ARG2:.*]]: !fir.ref<!fir.logical<4>>235! CHECK-DAG: %[[ARRAY:.*]]:2 = hlfir.declare %[[ARG0]]236! CHECK-DAG: %[[OUT:.*]]:2 = hlfir.declare %[[ARG1]]237! CHECK-DAG: %[[MASK:.*]]:2 = hlfir.declare %[[ARG2]]238! CHECK-NEXT: %[[EXPR:.*]] = hlfir.minloc %[[ARRAY]]#0 mask %[[MASK]]#0 {fastmath = #arith.fastmath<contract>} : (!fir.box<!fir.array<?x!fir.char<1,?>>>, !fir.ref<!fir.logical<4>>) -> !hlfir.expr<1xi32>239! CHECK-NEXT: hlfir.assign %[[EXPR]] to %[[OUT]]#0 : !hlfir.expr<1xi32>, !fir.box<!fir.array<?xi32>>240! CHECK-NEXT: hlfir.destroy %[[EXPR]]241! CHECK-NEXT: return242! CHECK-NEXT: }243 244subroutine testDynamicallyOptionalMask(array, mask, res)245 integer :: array(:), res(:)246 logical, allocatable :: mask(:)247 res = MINLOC(array, mask=mask)248end subroutine249! CHECK-LABEL: func.func @_QPtestdynamicallyoptionalmask(250! CHECK-SAME: %[[ARG0:.*]]: !fir.box<!fir.array<?xi32>> {fir.bindc_name = "array"}251! CHECK-SAME: %[[ARG1:.*]]: !fir.ref<!fir.box<!fir.heap<!fir.array<?x!fir.logical<4>>>>>252! CHECK-SAME: %[[ARG2:.*]]: !fir.box<!fir.array<?xi32>>253! CHECK-DAG: %[[ARRAY:.*]]:2 = hlfir.declare %[[ARG0]]254! CHECK-DAG: %[[MASK:.*]]:2 = hlfir.declare %[[ARG1]]255! CHECK-DAG: %[[RES:.*]]:2 = hlfir.declare %[[ARG2]]256! CHECK-NEXT: %[[MASK_LOAD:.*]] = fir.load %[[MASK]]#0257! CHECK-NEXT: %[[MASK_ADDR:.*]] = fir.box_addr %[[MASK_LOAD]]258! CHECK-NEXT: %[[MASK_ADDR_INT:.*]] = fir.convert %[[MASK_ADDR]]259! CHECK-NEXT: %[[C0:.*]] = arith.constant 0 : i64260! CHECK-NEXT: %[[CMP:.*]] = arith.cmpi ne, %[[MASK_ADDR_INT]], %[[C0]] : i64261! it is a shame there is a second load here. The first is generated for262! PreparedActualArgument::isPresent, the second is for optional handling263! CHECK-NEXT: %[[MASK_LOAD2:.*]] = fir.load %[[MASK]]#0264! CHECK-NEXT: %[[ABSENT:.*]] = fir.absent !fir.box<!fir.heap<!fir.array<?x!fir.logical<4>>>>265! CHECK-NEXT: %[[SELECT:.*]] = arith.select %[[CMP]], %[[MASK_LOAD2]], %[[ABSENT]]266! CHECK-NEXT: %[[MINLOC:.*]] = hlfir.minloc %[[ARRAY]]#0 mask %[[SELECT]]267! CHECK-NEXT: hlfir.assign %[[MINLOC]] to %[[RES]]#0268! CHECK-NEXT: hlfir.destroy %[[MINLOC]]269! CHECK-NEXT: return270! CHECK-NEXT: }271 272subroutine testAllocatableArray(array, mask, res)273 integer, allocatable :: array(:)274 integer :: res(:)275 logical :: mask(:)276 res = MINLOC(array, mask=mask)277end subroutine278! CHECK-LABEL: func.func @_QPtestallocatablearray(279! CHECK-SAME: %[[ARG0:.*]]: !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>280! CHECK-SAME: %[[ARG1:.*]]: !fir.box<!fir.array<?x!fir.logical<4>>>281! CHECK-SAME: %[[ARG2:.*]]: !fir.box<!fir.array<?xi32>>282! CHECK-DAG: %[[ARRAY:.*]]:2 = hlfir.declare %[[ARG0]]283! CHECK-DAG: %[[MASK:.*]]:2 = hlfir.declare %[[ARG1]]284! CHECK-DAG: %[[RES:.*]]:2 = hlfir.declare %[[ARG2]]285! CHECK-NEXT: %[[LOADED_ARRAY:.*]] = fir.load %[[ARRAY]]#0286! CHECK-NEXT: %[[MINLOC:.*]] = hlfir.minloc %[[LOADED_ARRAY]] mask %[[MASK]]#0287! CHECK-NEXT: hlfir.assign %[[MINLOC]] to %[[RES]]#0288! CHECK-NEXT: hlfir.destroy %[[MINLOC]]289! CHECK-NEXT: return290! CHECK-NEXT: }291 292function testOptionalScalar(array, mask)293 integer :: array(:)294 logical, optional :: mask295 integer :: testOptionalScalar(1)296 testOptionalScalar = minloc(array, mask)297end function298! CHECK-LABEL: func.func @_QPtestoptionalscalar(299! CHECK-SAME: %[[ARRAY_ARG:.*]]: !fir.box<!fir.array<?xi32>> {fir.bindc_name = "array"},300! CHECK-SAME: %[[MASK_ARG:.*]]: !fir.ref<!fir.logical<4>> {fir.bindc_name = "mask", fir.optional}) -> !fir.array<1xi32>301! CHECK: %[[ARRAY_VAR:.*]]:2 = hlfir.declare %[[ARRAY_ARG]]302! CHECK: %[[MASK_VAR:.*]]:2 = hlfir.declare %[[MASK_ARG]]303! CHECK: %[[RET_ALLOC:.*]] = fir.alloca !fir.array<1xi32> {bindc_name = "testoptionalscalar", uniq_name = "_QFtestoptionalscalarEtestoptionalscalar"}304! CHECK: %[[RET_VAR:.*]]:2 = hlfir.declare %[[RET_ALLOC]]305! CHECK: %[[MASK_IS_PRESENT:.*]] = fir.is_present %[[MASK_VAR]]#0 : (!fir.ref<!fir.logical<4>>) -> i1306! CHECK: %[[MASK_BOX:.*]] = fir.embox %[[MASK_VAR]]#0307! CHECK: %[[ABSENT:.*]] = fir.absent !fir.box<!fir.logical<4>>308! CHECK: %[[MASK_SELECT:.*]] = arith.select %[[MASK_IS_PRESENT]], %[[MASK_BOX]], %[[ABSENT]]309! CHECK: %[[RES:.*]] = hlfir.minloc %[[ARRAY_VAR]]#0 mask %[[MASK_SELECT]] {{.*}}: (!fir.box<!fir.array<?xi32>>, !fir.box<!fir.logical<4>>) -> !hlfir.expr<1xi32>310! CHECK: hlfir.assign %[[RES]] to %[[RET_VAR]]#0311! CHECK: hlfir.destroy %[[RES]]312! CHECK: %[[RET:.*]] = fir.load %[[RET_VAR]]#0 : !fir.ref<!fir.array<1xi32>>313! CHECK: return %[[RET]] : !fir.array<1xi32>314! CHECK: }315 316! Test that hlfir.minloc lowering inherits constant317! character length from the argument, when the length318! is unknown from the Fortran::evaluate expression type.319subroutine test_unknown_char_len_result320 character(len=3) :: array(3,3)321 integer :: res(2)322 res = minloc(array(:,:)(:))323end subroutine test_unknown_char_len_result324! CHECK-LABEL: func.func @_QPtest_unknown_char_len_result() {325! CHECK-DAG: %[[C3:.*]] = arith.constant 3 : index326! CHECK-DAG: %[[C3_0:.*]] = arith.constant 3 : index327! CHECK-DAG: %[[C3_1:.*]] = arith.constant 3 : index328! CHECK-DAG: %[[ARRAY_ALLOC:.*]] = fir.alloca !fir.array<3x3x!fir.char<1,3>>329! CHECK-DAG: %[[ARRAY_SHAPE:.*]] = fir.shape %[[C3_0]], %[[C3_1]] : (index, index) -> !fir.shape<2>330! CHECK-DAG: %[[ARRAY:.*]]:2 = hlfir.declare %[[ARRAY_ALLOC]](%[[ARRAY_SHAPE]]) typeparams %[[C3]]331! CHECK-DAG: %[[C2:.*]] = arith.constant 2 : index332! CHECK-DAG: %[[RES_ALLOC:.*]] = fir.alloca !fir.array<2xi32>333! CHECK-DAG: %[[RES_SHAPE:.*]] = fir.shape %[[C2]] : (index) -> !fir.shape<1>334! CHECK-DAG: %[[RES:.*]]:2 = hlfir.declare %[[RES_ALLOC]](%[[RES_SHAPE]])335! CHECK-DAG: %[[C1:.*]] = arith.constant 1 : index336! CHECK-DAG: %[[C1_3:.*]] = arith.constant 1 : index337! CHECK-DAG: %[[C3_4:.*]] = arith.constant 3 : index338! CHECK-DAG: %[[C1_5:.*]] = arith.constant 1 : index339! CHECK-DAG: %[[C3_6:.*]] = arith.constant 3 : index340! CHECK-DAG: %[[SHAPE:.*]] = fir.shape %[[C3_4]], %[[C3_6]] : (index, index) -> !fir.shape<2>341! CHECK-DAG: %[[C1_7:.*]] = arith.constant 1 : index342! CHECK-DAG: %[[C3_8:.*]] = arith.constant 3 : index343! CHECK-DAG: %[[C3_9:.*]] = arith.constant 3 : index344! CHECK-DAG: %[[ARRAY_REF:.*]] = hlfir.designate %[[ARRAY]]#0 (%[[C1]]:%[[C3_0]]:%[[C1_3]], %[[C1]]:%[[C3_1]]:%[[C1_5]]) substr %[[C1_7]], %[[C3_8]] shape %[[SHAPE]] typeparams %[[C3_9]] : (!fir.ref<!fir.array<3x3x!fir.char<1,3>>>, index, index, index, index, index, index, index, index, !fir.shape<2>, index) -> !fir.ref<!fir.array<3x3x!fir.char<1,3>>>345! CHECK: %[[EXPR:.*]] = hlfir.minloc %[[ARRAY_REF]] {fastmath = #arith.fastmath<contract>} : (!fir.ref<!fir.array<3x3x!fir.char<1,3>>>) -> !hlfir.expr<2xi32>346! CHECK-NEXT: hlfir.assign %[[EXPR]] to %[[RES]]#0 : !hlfir.expr<2xi32>, !fir.ref<!fir.array<2xi32>>347! CHECK-NEXT: hlfir.destroy %[[EXPR]]348! CHECK-NEXT: return349! CHECK-NEXT: }350 351 352subroutine scalar_dim1(a, d, m, b, s)353 integer :: a(:), d354 integer :: s(:)355 logical :: m(:), b356 s = MINLOC(a, dim=d, mask=m, kind=2, back=b)357end subroutine358! CHECK-LABEL: func.func @_QPscalar_dim1(359! CHECK: %[[ARG0:.*]]: !fir.box<!fir.array<?xi32>> {fir.bindc_name = "a"}, %[[ARG1:.*]]: !fir.ref<i32> {fir.bindc_name = "d"}, %[[ARG2:.*]]: !fir.box<!fir.array<?x!fir.logical<4>>> {fir.bindc_name = "m"}, %[[ARG3:.*]]: !fir.ref<!fir.logical<4>> {fir.bindc_name = "b"}, %[[ARG4:.*]]: !fir.box<!fir.array<?xi32>> {fir.bindc_name = "s"}) {360! CHECK-NEXT: %[[DSCOPE:.*]] = fir.dummy_scope : !fir.dscope361! CHECK-NEXT: %[[V0:.*]]:2 = hlfir.declare %[[ARG0]] dummy_scope %[[DSCOPE]]362! CHECK-NEXT: %[[V1:.*]]:2 = hlfir.declare %[[ARG3]] dummy_scope %[[DSCOPE]]363! CHECK-NEXT: %[[V2:.*]]:2 = hlfir.declare %[[ARG1]] dummy_scope %[[DSCOPE]]364! CHECK-NEXT: %[[V3:.*]]:2 = hlfir.declare %[[ARG2]] dummy_scope %[[DSCOPE]]365! CHECK-NEXT: %[[V4:.*]]:2 = hlfir.declare %[[ARG4]] dummy_scope %[[DSCOPE]]366! CHECK-NEXT: %[[V5:.*]] = fir.load %[[V1]]#0 : !fir.ref<!fir.logical<4>>367! CHECK-NEXT: %[[V6:.*]] = fir.load %[[V2]]#0 : !fir.ref<i32>368! CHECK-NEXT: %[[V7:.*]] = hlfir.minloc %[[V0]]#0 dim %[[V6]] mask %[[V3]]#0 back %[[V5]] {fastmath = #arith.fastmath<contract>} : (!fir.box<!fir.array<?xi32>>, i32, !fir.box<!fir.array<?x!fir.logical<4>>>, !fir.logical<4>) -> i16369! CHECK-NEXT: %[[V8:.*]] = fir.convert %[[V7]] : (i16) -> i32370! CHECK-NEXT: hlfir.assign %[[V8]] to %[[V4]]#0 : i32, !fir.box<!fir.array<?xi32>>371! CHECK-NEXT: return372