2620 lines · plain
1// RUN: fir-opt --split-input-file --simplify-intrinsics %s | FileCheck %s2 3// Call to SUM with 1D I32 array is replaced.4module attributes {fir.defaultkind = "a1c4d8i4l4r4", fir.kindmap = "", llvm.target_triple = "native"} {5 func.func @sum_1d_array_int(%arg0: !fir.ref<!fir.array<10xi32>> {fir.bindc_name = "a"}) -> i32 {6 %c10 = arith.constant 10 : index7 %0 = fir.alloca i32 {bindc_name = "test_sum_2", uniq_name = "_QFtest_sum_2Etest_sum_2"}8 %1 = fir.shape %c10 : (index) -> !fir.shape<1>9 %2 = fir.embox %arg0(%1) : (!fir.ref<!fir.array<10xi32>>, !fir.shape<1>) -> !fir.box<!fir.array<10xi32>>10 %3 = fir.absent !fir.box<i1>11 %c0 = arith.constant 0 : index12 %4 = fir.address_of(@_QQclX2E2F6973756D5F322E66393000) : !fir.ref<!fir.char<1,13>>13 %c5_i32 = arith.constant 5 : i3214 %5 = fir.convert %2 : (!fir.box<!fir.array<10xi32>>) -> !fir.box<none>15 %6 = fir.convert %4 : (!fir.ref<!fir.char<1,13>>) -> !fir.ref<i8>16 %7 = fir.convert %c0 : (index) -> i3217 %8 = fir.convert %3 : (!fir.box<i1>) -> !fir.box<none>18 %9 = fir.call @_FortranASumInteger4(%5, %6, %c5_i32, %7, %8) : (!fir.box<none>, !fir.ref<i8>, i32, i32, !fir.box<none>) -> i3219 fir.store %9 to %0 : !fir.ref<i32>20 %10 = fir.load %0 : !fir.ref<i32>21 return %10 : i3222 }23 func.func private @_FortranASumInteger4(!fir.box<none>, !fir.ref<i8>, i32, i32, !fir.box<none>) -> i32 attributes {fir.runtime}24 fir.global linkonce @_QQclX2E2F6973756D5F322E66393000 constant : !fir.char<1,13> {25 %0 = fir.string_lit "./isum_2.f90\00"(13) : !fir.char<1,13>26 fir.has_value %0 : !fir.char<1,13>27 }28}29 30 31// CHECK-LABEL: func.func @sum_1d_array_int(32// CHECK-SAME: %[[A:.*]]: !fir.ref<!fir.array<10xi32>> {fir.bindc_name = "a"}) -> i32 {33// CHECK: %[[SHAPE:.*]] = fir.shape %{{.*}} : (index) -> !fir.shape<1>34// CHECK: %[[A_BOX_I32:.*]] = fir.embox %[[A]](%[[SHAPE]]) : (!fir.ref<!fir.array<10xi32>>, !fir.shape<1>) -> !fir.box<!fir.array<10xi32>>35// CHECK: %[[A_BOX_NONE:.*]] = fir.convert %[[A_BOX_I32]] : (!fir.box<!fir.array<10xi32>>) -> !fir.box<none>36// CHECK-NOT: fir.call @_FortranASumInteger4({{.*}})37// CHECK: %[[RES:.*]] = fir.call @_FortranASumInteger4x1_simplified(%[[A_BOX_NONE]]) : (!fir.box<none>) -> i3238// CHECK-NOT: fir.call @_FortranASumInteger4({{.*}})39// CHECK: return %{{.*}} : i3240// CHECK: }41// CHECK: func.func private @_FortranASumInteger4(!fir.box<none>, !fir.ref<i8>, i32, i32, !fir.box<none>) -> i32 attributes {fir.runtime}42 43// CHECK-LABEL: func.func private @_FortranASumInteger4x1_simplified(44// CHECK-SAME: %[[ARR:.*]]: !fir.box<none>) -> i32 attributes {llvm.linkage = #llvm.linkage<linkonce_odr>} {45// CHECK: %[[CINDEX_0:.*]] = arith.constant 0 : index46// CHECK: %[[ARR_BOX_I32:.*]] = fir.convert %[[ARR]] : (!fir.box<none>) -> !fir.box<!fir.array<?xi32>>47// CHECK: %[[CI32_0:.*]] = arith.constant 0 : i3248// CHECK: %[[CINDEX_1:.*]] = arith.constant 1 : index49// CHECK: %[[DIMIDX_0:.*]] = arith.constant 0 : index50// CHECK: %[[DIMS:.*]]:3 = fir.box_dims %[[ARR_BOX_I32]], %[[DIMIDX_0]] : (!fir.box<!fir.array<?xi32>>, index) -> (index, index, index)51// CHECK: %[[EXTENT:.*]] = arith.subi %[[DIMS]]#1, %[[CINDEX_1]] : index52// CHECK: %[[RES:.*]] = fir.do_loop %[[ITER:.*]] = %[[CINDEX_0]] to %[[EXTENT]] step %[[CINDEX_1]] iter_args(%[[SUM:.*]] = %[[CI32_0]]) -> (i32) {53// CHECK: %[[ITEM:.*]] = fir.coordinate_of %[[ARR_BOX_I32]], %[[ITER]] : (!fir.box<!fir.array<?xi32>>, index) -> !fir.ref<i32>54// CHECK: %[[ITEM_VAL:.*]] = fir.load %[[ITEM]] : !fir.ref<i32>55// CHECK: %[[NEW_SUM:.*]] = arith.addi %[[ITEM_VAL]], %[[SUM]] : i3256// CHECK: fir.result %[[NEW_SUM]] : i3257// CHECK: }58// CHECK: return %[[RES]] : i3259// CHECK: }60 61// -----62 63// Call to SUM with 2D I32 arrays is replaced.64module attributes {fir.defaultkind = "a1c4d8i4l4r4", fir.kindmap = "", llvm.target_triple = "native"} {65 func.func @sum_2d_array_int(%arg0: !fir.ref<!fir.array<10x10xi32>> {fir.bindc_name = "a"}) -> i32 {66 %c10 = arith.constant 10 : index67 %c10_0 = arith.constant 10 : index68 %0 = fir.alloca i32 {bindc_name = "test_sum_3", uniq_name = "_QFtest_sum_3Etest_sum_3"}69 %1 = fir.shape %c10, %c10_0 : (index, index) -> !fir.shape<2>70 %2 = fir.embox %arg0(%1) : (!fir.ref<!fir.array<10x10xi32>>, !fir.shape<2>) -> !fir.box<!fir.array<10x10xi32>>71 %3 = fir.absent !fir.box<i1>72 %c0 = arith.constant 0 : index73 %4 = fir.address_of(@_QQclX2E2F6973756D5F332E66393000) : !fir.ref<!fir.char<1,13>>74 %c5_i32 = arith.constant 5 : i3275 %5 = fir.convert %2 : (!fir.box<!fir.array<10x10xi32>>) -> !fir.box<none>76 %6 = fir.convert %4 : (!fir.ref<!fir.char<1,13>>) -> !fir.ref<i8>77 %7 = fir.convert %c0 : (index) -> i3278 %8 = fir.convert %3 : (!fir.box<i1>) -> !fir.box<none>79 %9 = fir.call @_FortranASumInteger4(%5, %6, %c5_i32, %7, %8) : (!fir.box<none>, !fir.ref<i8>, i32, i32, !fir.box<none>) -> i3280 fir.store %9 to %0 : !fir.ref<i32>81 %10 = fir.load %0 : !fir.ref<i32>82 return %10 : i3283 }84 func.func private @_FortranASumInteger4(!fir.box<none>, !fir.ref<i8>, i32, i32, !fir.box<none>) -> i32 attributes {fir.runtime}85 fir.global linkonce @_QQclX2E2F6973756D5F332E66393000 constant : !fir.char<1,13> {86 %0 = fir.string_lit "./isum_3.f90\00"(13) : !fir.char<1,13>87 fir.has_value %0 : !fir.char<1,13>88 }89}90 91// CHECK-LABEL: func.func @sum_2d_array_int({{.*}} !fir.ref<!fir.array<10x10xi32>> {fir.bindc_name = "a"}) -> i32 {92// CHECK: %[[SHAPE:.*]] = fir.shape %{{.*}} : (index, index) -> !fir.shape<2>93// CHECK: %[[A_BOX_I32:.*]] = fir.embox %[[A]](%[[SHAPE]]) : (!fir.ref<!fir.array<10x10xi32>>, !fir.shape<2>) -> !fir.box<!fir.array<10x10xi32>>94// CHECK: %[[A_BOX_NONE:.*]] = fir.convert %[[A_BOX_I32]] : (!fir.box<!fir.array<10x10xi32>>) -> !fir.box<none>95// CHECK-NOT: fir.call @_FortranASumInteger4({{.*}})96// CHECK: %[[RES:.*]] = fir.call @_FortranASumInteger4x2_simplified(%[[A_BOX_NONE]]) : (!fir.box<none>) -> i3297// CHECK-NOT: fir.call @_FortranASumInteger4({{.*}})98// CHECK: return %{{.*}} : i3299// CHECK: }100// CHECK: func.func private @_FortranASumInteger4(!fir.box<none>, !fir.ref<i8>, i32, i32, !fir.box<none>) -> i32 attributes {fir.runtime}101 102// CHECK-LABEL: func.func private @_FortranASumInteger4x2_simplified(103// CHECK-SAME: %[[ARR:.*]]: !fir.box<none>) -> i32 attributes {llvm.linkage = #llvm.linkage<linkonce_odr>} {104// CHECK: %[[CINDEX_0:.*]] = arith.constant 0 : index105// CHECK: %[[ARR_BOX_I32:.*]] = fir.convert %[[ARR]] : (!fir.box<none>) -> !fir.box<!fir.array<?x?xi32>>106// CHECK: %[[CI32_0:.*]] = arith.constant 0 : i32107// CHECK: %[[CINDEX_1:.*]] = arith.constant 1 : index108// CHECK: %[[DIMIDX_0:.*]] = arith.constant 0 : index109// CHECK: %[[DIMS_0:.*]]:3 = fir.box_dims %[[ARR_BOX_I32]], %[[DIMIDX_0]] : (!fir.box<!fir.array<?x?xi32>>, index) -> (index, index, index)110// CHECK: %[[EXTENT_0:.*]] = arith.subi %[[DIMS_0]]#1, %[[CINDEX_1]] : index111// CHECK: %[[DIMIDX_1:.*]] = arith.constant 1 : index112// CHECK: %[[DIMS_1:.*]]:3 = fir.box_dims %[[ARR_BOX_I32]], %[[DIMIDX_1]] : (!fir.box<!fir.array<?x?xi32>>, index) -> (index, index, index)113// CHECK: %[[EXTENT_1:.*]] = arith.subi %[[DIMS_1]]#1, %[[CINDEX_1]] : index114// CHECK: %[[RES_1:.*]] = fir.do_loop %[[ITER_1:.*]] = %[[CINDEX_0]] to %[[EXTENT_1]] step %[[CINDEX_1]] iter_args(%[[SUM_1:.*]] = %[[CI32_0]]) -> (i32) {115// CHECK: %[[RES_0:.*]] = fir.do_loop %[[ITER_0:.*]] = %[[CINDEX_0]] to %[[EXTENT_0]] step %[[CINDEX_1]] iter_args(%[[SUM_0:.*]] = %[[SUM_1]]) -> (i32) {116// CHECK: %[[ITEM:.*]] = fir.coordinate_of %[[ARR_BOX_I32]], %[[ITER_0]], %[[ITER_1]] : (!fir.box<!fir.array<?x?xi32>>, index, index) -> !fir.ref<i32>117// CHECK: %[[ITEM_VAL:.*]] = fir.load %[[ITEM]] : !fir.ref<i32>118// CHECK: %[[NEW_SUM:.*]] = arith.addi %[[ITEM_VAL]], %[[SUM_0]] : i32119// CHECK: fir.result %[[NEW_SUM]] : i32120// CHECK: }121// CHECK: fir.result %[[RES_0]]122// CHECK: }123// CHECK: return %[[RES_1]] : i32124// CHECK: }125 126// -----127 128// Call to SUM with 1D F64 is replaced.129module attributes {fir.defaultkind = "a1c4d8i4l4r4", fir.kindmap = "", llvm.target_triple = "native"} {130 func.func @sum_1d_real(%arg0: !fir.ref<!fir.array<10xf64>> {fir.bindc_name = "a"}) -> f64 {131 %c10 = arith.constant 10 : index132 %0 = fir.alloca f64 {bindc_name = "sum_1d_real", uniq_name = "_QFsum_1d_realEsum_1d_real"}133 %1 = fir.shape %c10 : (index) -> !fir.shape<1>134 %2 = fir.embox %arg0(%1) : (!fir.ref<!fir.array<10xf64>>, !fir.shape<1>) -> !fir.box<!fir.array<10xf64>>135 %3 = fir.absent !fir.box<i1>136 %c0 = arith.constant 0 : index137 %4 = fir.address_of(@_QQclX2E2F6973756D5F352E66393000) : !fir.ref<!fir.char<1,13>>138 %c5_i32 = arith.constant 5 : i32139 %5 = fir.convert %2 : (!fir.box<!fir.array<10xf64>>) -> !fir.box<none>140 %6 = fir.convert %4 : (!fir.ref<!fir.char<1,13>>) -> !fir.ref<i8>141 %7 = fir.convert %c0 : (index) -> i32142 %8 = fir.convert %3 : (!fir.box<i1>) -> !fir.box<none>143 %9 = fir.call @_FortranASumReal8(%5, %6, %c5_i32, %7, %8) : (!fir.box<none>, !fir.ref<i8>, i32, i32, !fir.box<none>) -> f64144 fir.store %9 to %0 : !fir.ref<f64>145 %10 = fir.load %0 : !fir.ref<f64>146 return %10 : f64147 }148 func.func private @_FortranASumReal8(!fir.box<none>, !fir.ref<i8>, i32, i32, !fir.box<none>) -> f64 attributes {fir.runtime}149 fir.global linkonce @_QQclX2E2F6973756D5F352E66393000 constant : !fir.char<1,13> {150 %0 = fir.string_lit "./isum_5.f90\00"(13) : !fir.char<1,13>151 fir.has_value %0 : !fir.char<1,13>152 }153}154 155 156// CHECK-LABEL: func.func @sum_1d_real(157// CHECK-SAME: %[[A:.*]]: !fir.ref<!fir.array<10xf64>> {fir.bindc_name = "a"}) -> f64 {158// CHECK: %[[CINDEX_10:.*]] = arith.constant 10 : index159// CHECK: %[[SHAPE:.*]] = fir.shape %[[CINDEX_10]] : (index) -> !fir.shape<1>160// CHECK: %[[A_BOX_F64:.*]] = fir.embox %[[A]](%[[SHAPE]]) : (!fir.ref<!fir.array<10xf64>>, !fir.shape<1>) -> !fir.box<!fir.array<10xf64>>161// CHECK: %[[A_BOX_NONE:.*]] = fir.convert %[[A_BOX_F64]] : (!fir.box<!fir.array<10xf64>>) -> !fir.box<none>162// CHECK-NOT: fir.call @_FortranASumReal8({{.*}})163// CHECK: %[[RES:.*]] = fir.call @_FortranASumReal8x1_simplified(%[[A_BOX_NONE]]) : (!fir.box<none>) -> f64164// CHECK-NOT: fir.call @_FortranASumReal8({{.*}})165// CHECK: return %{{.*}} : f64166// CHECK: }167 168// CHECK-LABEL: func.func private @_FortranASumReal8x1_simplified(169// CHECK-SAME: %[[ARR:.*]]: !fir.box<none>) -> f64 attributes {llvm.linkage = #llvm.linkage<linkonce_odr>} {170// CHECK: %[[CINDEX_0:.*]] = arith.constant 0 : index171// CHECK: %[[ARR_BOX_F64:.*]] = fir.convert %[[ARR]] : (!fir.box<none>) -> !fir.box<!fir.array<?xf64>>172// CHECK: %[[ZERO:.*]] = arith.constant 0.000000e+00 : f64173// CHECK: %[[CINDEX_1:.*]] = arith.constant 1 : index174// CHECK: %[[DIMIDX_0:.*]] = arith.constant 0 : index175// CHECK: %[[DIMS:.*]]:3 = fir.box_dims %[[ARR_BOX_F64]], %[[DIMIDX_0]] : (!fir.box<!fir.array<?xf64>>, index) -> (index, index, index)176// CHECK: %[[EXTENT:.*]] = arith.subi %[[DIMS]]#1, %[[CINDEX_1]] : index177// CHECK: %[[RES:.*]] = fir.do_loop %[[ITER:.*]] = %[[CINDEX_0]] to %[[EXTENT]] step %[[CINDEX_1]] iter_args(%[[SUM]] = %[[ZERO]]) -> (f64) {178// CHECK: %[[ITEM:.*]] = fir.coordinate_of %[[ARR_BOX_F64]], %[[ITER]] : (!fir.box<!fir.array<?xf64>>, index) -> !fir.ref<f64>179// CHECK: %[[ITEM_VAL:.*]] = fir.load %[[ITEM]] : !fir.ref<f64>180// CHECK: %[[NEW_SUM:.*]] = arith.addf %[[ITEM_VAL]], %[[SUM]] : f64181// CHECK: fir.result %[[NEW_SUM]] : f64182// CHECK: }183// CHECK: return %[[RES]] : f64184// CHECK: }185 186// -----187 188// Call to SUM with 1D F32 is replaced.189module attributes {fir.defaultkind = "a1c4d8i4l4r4", fir.kindmap = "", llvm.target_triple = "native"} {190 func.func @sum_1d_real(%arg0: !fir.ref<!fir.array<10xf32>> {fir.bindc_name = "a"}) -> f32 {191 %c10 = arith.constant 10 : index192 %0 = fir.alloca f32 {bindc_name = "sum_1d_real", uniq_name = "_QFsum_1d_realEsum_1d_real"}193 %1 = fir.shape %c10 : (index) -> !fir.shape<1>194 %2 = fir.embox %arg0(%1) : (!fir.ref<!fir.array<10xf32>>, !fir.shape<1>) -> !fir.box<!fir.array<10xf32>>195 %3 = fir.absent !fir.box<i1>196 %c0 = arith.constant 0 : index197 %4 = fir.address_of(@_QQclX2E2F6973756D5F352E66393000) : !fir.ref<!fir.char<1,13>>198 %c5_i32 = arith.constant 5 : i32199 %5 = fir.convert %2 : (!fir.box<!fir.array<10xf32>>) -> !fir.box<none>200 %6 = fir.convert %4 : (!fir.ref<!fir.char<1,13>>) -> !fir.ref<i8>201 %7 = fir.convert %c0 : (index) -> i32202 %8 = fir.convert %3 : (!fir.box<i1>) -> !fir.box<none>203 %9 = fir.call @_FortranASumReal4(%5, %6, %c5_i32, %7, %8) : (!fir.box<none>, !fir.ref<i8>, i32, i32, !fir.box<none>) -> f32204 fir.store %9 to %0 : !fir.ref<f32>205 %10 = fir.load %0 : !fir.ref<f32>206 return %10 : f32207 }208 func.func private @_FortranASumReal4(!fir.box<none>, !fir.ref<i8>, i32, i32, !fir.box<none>) -> f32 attributes {fir.runtime}209 fir.global linkonce @_QQclX2E2F6973756D5F352E66393000 constant : !fir.char<1,13> {210 %0 = fir.string_lit "./isum_5.f90\00"(13) : !fir.char<1,13>211 fir.has_value %0 : !fir.char<1,13>212 }213}214 215 216// CHECK-LABEL: func.func @sum_1d_real(217// CHECK-SAME: %[[A:.*]]: !fir.ref<!fir.array<10xf32>> {fir.bindc_name = "a"}) -> f32 {218// CHECK: %[[CINDEX_10:.*]] = arith.constant 10 : index219// CHECK: %[[SHAPE:.*]] = fir.shape %[[CINDEX_10]] : (index) -> !fir.shape<1>220// CHECK: %[[A_BOX_F32:.*]] = fir.embox %[[A]](%[[SHAPE]]) : (!fir.ref<!fir.array<10xf32>>, !fir.shape<1>) -> !fir.box<!fir.array<10xf32>>221// CHECK: %[[A_BOX_NONE:.*]] = fir.convert %[[A_BOX_F32]] : (!fir.box<!fir.array<10xf32>>) -> !fir.box<none>222// CHECK-NOT: fir.call @_FortranASumReal4({{.*}})223// CHECK: %[[RES:.*]] = fir.call @_FortranASumReal4x1_simplified(%[[A_BOX_NONE]]) : (!fir.box<none>) -> f32224// CHECK-NOT: fir.call @_FortranASumReal4({{.*}})225// CHECK: return %{{.*}} : f32226// CHECK: }227 228// CHECK-LABEL: func.func private @_FortranASumReal4x1_simplified(229// CHECK-SAME: %[[ARR:.*]]: !fir.box<none>) -> f32 attributes {llvm.linkage = #llvm.linkage<linkonce_odr>} {230// CHECK: %[[CINDEX_0:.*]] = arith.constant 0 : index231// CHECK: %[[ARR_BOX_F32:.*]] = fir.convert %[[ARR]] : (!fir.box<none>) -> !fir.box<!fir.array<?xf32>>232// CHECK: %[[ZERO:.*]] = arith.constant 0.000000e+00 : f32233// CHECK: %[[CINDEX_1:.*]] = arith.constant 1 : index234// CHECK: %[[DIMIDX_0:.*]] = arith.constant 0 : index235// CHECK: %[[DIMS:.*]]:3 = fir.box_dims %[[ARR_BOX_F32]], %[[DIMIDX_0]] : (!fir.box<!fir.array<?xf32>>, index) -> (index, index, index)236// CHECK: %[[EXTENT:.*]] = arith.subi %[[DIMS]]#1, %[[CINDEX_1]] : index237// CHECK: %[[RES:.*]] = fir.do_loop %[[ITER:.*]] = %[[CINDEX_0]] to %[[EXTENT]] step %[[CINDEX_1]] iter_args(%[[SUM]] = %[[ZERO]]) -> (f32) {238// CHECK: %[[ITEM:.*]] = fir.coordinate_of %[[ARR_BOX_F32]], %[[ITER]] : (!fir.box<!fir.array<?xf32>>, index) -> !fir.ref<f32>239// CHECK: %[[ITEM_VAL:.*]] = fir.load %[[ITEM]] : !fir.ref<f32>240// CHECK: %[[NEW_SUM:.*]] = arith.addf %[[ITEM_VAL]], %[[SUM]] : f32241// CHECK: fir.result %[[NEW_SUM]] : f32242// CHECK: }243// CHECK: return %[[RES]] : f32244// CHECK: }245 246// -----247 248// Call to SUM with 1D COMPLEX array is not replaced.249module attributes {fir.defaultkind = "a1c4d8i4l4r4", fir.kindmap = "", llvm.target_triple = "native"} {250 func.func @sum_1d_complex(%arg0: !fir.ref<!fir.array<10xcomplex<f32>>> {fir.bindc_name = "a"}) -> complex<f32> {251 %0 = fir.alloca complex<f32>252 %c10 = arith.constant 10 : index253 %1 = fir.alloca complex<f32> {bindc_name = "sum_1d_complex", uniq_name = "_QFsum_1d_complexEsum_1d_complex"}254 %2 = fir.shape %c10 : (index) -> !fir.shape<1>255 %3 = fir.embox %arg0(%2) : (!fir.ref<!fir.array<10xcomplex<f32>>>, !fir.shape<1>) -> !fir.box<!fir.array<10xcomplex<f32>>>256 %4 = fir.absent !fir.box<i1>257 %c0 = arith.constant 0 : index258 %5 = fir.address_of(@_QQclX2E2F6973756D5F362E66393000) : !fir.ref<!fir.char<1,13>>259 %c5_i32 = arith.constant 5 : i32260 %6 = fir.convert %0 : (!fir.ref<complex<f32>>) -> !fir.ref<complex<f32>>261 %7 = fir.convert %3 : (!fir.box<!fir.array<10xcomplex<f32>>>) -> !fir.box<none>262 %8 = fir.convert %5 : (!fir.ref<!fir.char<1,13>>) -> !fir.ref<i8>263 %9 = fir.convert %c0 : (index) -> i32264 %10 = fir.convert %4 : (!fir.box<i1>) -> !fir.box<none>265 fir.call @_FortranACppSumComplex4(%6, %7, %8, %c5_i32, %9, %10) : (!fir.ref<complex<f32>>, !fir.box<none>, !fir.ref<i8>, i32, i32, !fir.box<none>) -> ()266 %12 = fir.load %0 : !fir.ref<complex<f32>>267 fir.store %12 to %1 : !fir.ref<complex<f32>>268 %13 = fir.load %1 : !fir.ref<complex<f32>>269 return %13 : complex<f32>270 }271 func.func private @_FortranACppSumComplex4(!fir.ref<complex<f32>>, !fir.box<none>, !fir.ref<i8>, i32, i32, !fir.box<none>) -> () attributes {fir.runtime}272 fir.global linkonce @_QQclX2E2F6973756D5F362E66393000 constant : !fir.char<1,13> {273 %0 = fir.string_lit "./isum_6.f90\00"(13) : !fir.char<1,13>274 fir.has_value %0 : !fir.char<1,13>275 }276}277 278// CHECK-LABEL: func.func @sum_1d_complex(%{{.*}}: !fir.ref<!fir.array<10xcomplex<f32>>> {fir.bindc_name = "a"}) -> complex<f32> {279// CHECK-NOT: fir.call @_FortranACppSumComplex4x1_simplified({{.*}})280// CHECK: fir.call @_FortranACppSumComplex4({{.*}}) : (!fir.ref<complex<f32>>, !fir.box<none>, !fir.ref<i8>, i32, i32, !fir.box<none>) -> ()281// CHECK-NOT: fir.call @_FortranACppSumComplex4x1_simplified({{.*}})282 283// -----284 285// Test that two functions calling the same SUM function286// generates only ONE function declaration (and that both287// calls are converted)288module attributes {fir.defaultkind = "a1c4d8i4l4r4", fir.kindmap = "", llvm.target_triple = "native"} {289 func.func @sum_1d_calla(%arg0: !fir.ref<!fir.array<10xi32>> {fir.bindc_name = "a"}) -> i32 {290 %c10 = arith.constant 10 : index291 %0 = fir.alloca i32 {bindc_name = "sum_1d_calla", uniq_name = "_QFsum_1d_callaEsum_1d_calla"}292 %1 = fir.shape %c10 : (index) -> !fir.shape<1>293 %2 = fir.embox %arg0(%1) : (!fir.ref<!fir.array<10xi32>>, !fir.shape<1>) -> !fir.box<!fir.array<10xi32>>294 %3 = fir.absent !fir.box<i1>295 %c0 = arith.constant 0 : index296 %4 = fir.address_of(@_QQclX2E2F6973756D5F372E66393000) : !fir.ref<!fir.char<1,13>>297 %c5_i32 = arith.constant 5 : i32298 %5 = fir.convert %2 : (!fir.box<!fir.array<10xi32>>) -> !fir.box<none>299 %6 = fir.convert %4 : (!fir.ref<!fir.char<1,13>>) -> !fir.ref<i8>300 %7 = fir.convert %c0 : (index) -> i32301 %8 = fir.convert %3 : (!fir.box<i1>) -> !fir.box<none>302 %9 = fir.call @_FortranASumInteger4(%5, %6, %c5_i32, %7, %8) : (!fir.box<none>, !fir.ref<i8>, i32, i32, !fir.box<none>) -> i32303 fir.store %9 to %0 : !fir.ref<i32>304 %10 = fir.load %0 : !fir.ref<i32>305 return %10 : i32306 }307 func.func @sum_1d_callb(%arg0: !fir.ref<!fir.array<20xi32>> {fir.bindc_name = "a"}) -> i32 {308 %c20 = arith.constant 20 : index309 %0 = fir.alloca i32 {bindc_name = "sum_1d_callb", uniq_name = "_QFsum_1d_callbEsum_1d_callb"}310 %1 = fir.shape %c20 : (index) -> !fir.shape<1>311 %2 = fir.embox %arg0(%1) : (!fir.ref<!fir.array<20xi32>>, !fir.shape<1>) -> !fir.box<!fir.array<20xi32>>312 %3 = fir.absent !fir.box<i1>313 %c0 = arith.constant 0 : index314 %4 = fir.address_of(@_QQclX2E2F6973756D5F372E66393000) : !fir.ref<!fir.char<1,13>>315 %c12_i32 = arith.constant 12 : i32316 %5 = fir.convert %2 : (!fir.box<!fir.array<20xi32>>) -> !fir.box<none>317 %6 = fir.convert %4 : (!fir.ref<!fir.char<1,13>>) -> !fir.ref<i8>318 %7 = fir.convert %c0 : (index) -> i32319 %8 = fir.convert %3 : (!fir.box<i1>) -> !fir.box<none>320 %9 = fir.call @_FortranASumInteger4(%5, %6, %c12_i32, %7, %8) : (!fir.box<none>, !fir.ref<i8>, i32, i32, !fir.box<none>) -> i32321 fir.store %9 to %0 : !fir.ref<i32>322 %10 = fir.load %0 : !fir.ref<i32>323 return %10 : i32324 }325 func.func private @_FortranASumInteger4(!fir.box<none>, !fir.ref<i8>, i32, i32, !fir.box<none>) -> i32 attributes {fir.runtime}326 fir.global linkonce @_QQclX2E2F6973756D5F372E66393000 constant : !fir.char<1,13> {327 %0 = fir.string_lit "./isum_7.f90\00"(13) : !fir.char<1,13>328 fir.has_value %0 : !fir.char<1,13>329 }330}331 332// CHECK-LABEL: func.func @sum_1d_calla(%{{.*}}) -> i32 {333// CHECK-NOT: fir.call @_FortranASumInteger4({{.*}})334// CHECK: fir.call @_FortranASumInteger4x1_simplified(%{{.*}})335// CHECK-NOT: fir.call @_FortranASumInteger4({{.*}})336// CHECK: }337 338// CHECK-LABEL: func.func @sum_1d_callb(%{{.*}}) -> i32 {339// CHECK-NOT: fir.call @_FortranASumInteger4({{.*}})340// CHECK: fir.call @_FortranASumInteger4x1_simplified(%{{.*}})341// CHECK-NOT: fir.call @_FortranASumInteger4({{.*}})342// CHECK: }343 344// CHECK-LABEL: func.func private @_FortranASumInteger4x1_simplified({{.*}}) -> i32 {{.*}} {345// CHECK: return %{{.*}} : i32346// CHECK: }347// CHECK-NOT: func.func private @_FortranASumInteger4x1_simplified({{.*}})348 349// -----350 351module attributes {fir.defaultkind = "a1c4d8i4l4r4", fir.kindmap = "", llvm.target_triple = "native"} {352 func.func @sum_1d_stride(%arg0: !fir.ref<!fir.array<20xi32>> {fir.bindc_name = "a"}) -> i32 {353 %c20 = arith.constant 20 : index354 %0 = fir.alloca i32 {bindc_name = "sum_1d_stride", uniq_name = "_QFsum_1d_strideEsum_1d_stride"}355 %c1 = arith.constant 1 : index356 %c2_i64 = arith.constant 2 : i64357 %1 = fir.convert %c2_i64 : (i64) -> index358 %2 = arith.addi %c1, %c20 : index359 %3 = arith.subi %2, %c1 : index360 %4 = fir.shape %c20 : (index) -> !fir.shape<1>361 %5 = fir.slice %c1, %3, %1 : (index, index, index) -> !fir.slice<1>362 %6 = fir.embox %arg0(%4) [%5] : (!fir.ref<!fir.array<20xi32>>, !fir.shape<1>, !fir.slice<1>) -> !fir.box<!fir.array<?xi32>>363 %7 = fir.absent !fir.box<i1>364 %c0 = arith.constant 0 : index365 %8 = fir.address_of(@_QQclX2E2F6973756D5F382E66393000) : !fir.ref<!fir.char<1,13>>366 %c5_i32 = arith.constant 5 : i32367 %9 = fir.convert %6 : (!fir.box<!fir.array<?xi32>>) -> !fir.box<none>368 %10 = fir.convert %8 : (!fir.ref<!fir.char<1,13>>) -> !fir.ref<i8>369 %11 = fir.convert %c0 : (index) -> i32370 %12 = fir.convert %7 : (!fir.box<i1>) -> !fir.box<none>371 %13 = fir.call @_FortranASumInteger4(%9, %10, %c5_i32, %11, %12) : (!fir.box<none>, !fir.ref<i8>, i32, i32, !fir.box<none>) -> i32372 fir.store %13 to %0 : !fir.ref<i32>373 %14 = fir.load %0 : !fir.ref<i32>374 return %14 : i32375 }376 func.func private @_FortranASumInteger4(!fir.box<none>, !fir.ref<i8>, i32, i32, !fir.box<none>) -> i32 attributes {fir.runtime}377 fir.global linkonce @_QQclX2E2F6973756D5F382E66393000 constant : !fir.char<1,13> {378 %0 = fir.string_lit "./isum_8.f90\00"(13) : !fir.char<1,13>379 fir.has_value %0 : !fir.char<1,13>380 }381}382 383// CHECK-LABEL: func.func @sum_1d_stride(%{{.*}} -> i32 {384// CHECK: %[[CI64_2:.*]] = arith.constant 2 : i64385// CHECK: %[[CINDEX_2:.*]] = fir.convert %[[CI64_2]] : (i64) -> index386// CHECK: %[[SHAPE:.*]] = fir.shape %{{.*}}387// CHECK: %[[SLICE:.*]] = fir.slice %{{.*}}, %{{.*}}, %[[CINDEX_2]] : (index, index, index) -> !fir.slice<1>388// CHECK: %[[A_BOX_I32:.*]] = fir.embox %{{.*}}(%[[SHAPE]]) {{\[}}%[[SLICE]]] : (!fir.ref<!fir.array<20xi32>>, !fir.shape<1>, !fir.slice<1>) -> !fir.box<!fir.array<?xi32>>389// CHECK: %[[A_BOX_NONE:.*]] = fir.convert %[[A_BOX_I32]] : (!fir.box<!fir.array<?xi32>>) -> !fir.box<none>390// CHECK: %{{.*}} = fir.call @_FortranASumInteger4x1_simplified(%[[A_BOX_NONE]]) : (!fir.box<none>) -> i32391// CHECK: return %{{.*}} : i32392// CHECK: }393 394// CHECK-LABEL: func.func private @_FortranASumInteger4x1_simplified(%{{.*}}) -> i32 attributes {llvm.linkage = #llvm.linkage<linkonce_odr>} {395// CHECK: %[[ARR_BOX_I32:.*]] = fir.convert %{{.*}} : (!fir.box<none>) -> !fir.box<!fir.array<?xi32>>396// CHECK: %[[CINDEX_1:.*]] = arith.constant 1 : index397// CHECK: %[[DIMS:.*]]:3 = fir.box_dims %[[ARR_BOX_I32]], %{{.*}} : (!fir.box<!fir.array<?xi32>>, index) -> (index, index, index)398// CHECK: %[[EXTENT:.*]] = arith.subi %[[DIMS]]#1, %[[CINDEX_1]] : index399// CHECK: %[[RES:.*]] = fir.do_loop %[[ITER:.*]] = %{{.*}} to %[[EXTENT]] step %[[CINDEX_1]] iter_args({{.*}}) -> (i32) {400// CHECK: %{{.*}} = fir.coordinate_of %[[ARR_BOX_I32]], %[[ITER]] : (!fir.box<!fir.array<?xi32>>, index) -> !fir.ref<i32>401// CHECK: }402// CHECK: return %[[RES]] : i32403// CHECK: }404 405// -----406 407// Check that the compiler accepts unknown size arrays.408module attributes {fir.defaultkind = "a1c4d8i4l4r4", fir.kindmap = "", llvm.target_triple = "native"} {409 func.func @sum_dim() {410 %arr = fir.alloca !fir.box<!fir.heap<!fir.array<?xi32>>>411 %var = fir.alloca !fir.array<8x8xi32> 412 %size = arith.constant 8 : index413 %c1 = arith.constant 1 : index414 %c1_i32 = arith.constant 1 : i32415 %lineno = arith.constant 12 : i32416 %shape = fir.shape %size, %size : (index, index) -> !fir.shape<2>417 %slice = fir.slice %c1, %size, %c1, %c1, %size, %c1 : (index, index, index, index, index, index) -> !fir.slice<2>418 %box_array = fir.embox %var(%shape) [%slice] : (!fir.ref<!fir.array<8x8xi32>>, !fir.shape<2>, !fir.slice<2>) -> !fir.box<!fir.array<?x?xi32>>419 %box_none = fir.convert %arr : (!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>) -> !fir.ref<!fir.box<none>>420 %box_none2 = fir.convert %box_array : (!fir.box<!fir.array<?x?xi32>>) -> !fir.box<none>421 %absent = fir.absent !fir.box<i1>422 %file = fir.address_of(@filename) : !fir.ref<!fir.char<1,16>>423 %file_ref = fir.convert %file : (!fir.ref<!fir.char<1,16>>) -> !fir.ref<i8>424 %absent_none = fir.convert %absent : (!fir.box<i1>) -> !fir.box<none>425 fir.call @_FortranASumDim(%box_none, %box_none2, %c1_i32, %file_ref, %lineno, %absent_none) : (!fir.ref<!fir.box<none>>, !fir.box<none>, i32, !fir.ref<i8>, i32, !fir.box<none>) -> ()426 func.return427 }428}429 430// Just check that SOMETHING is being output.431// CHECK-LABEL: @sum_dim() {432// CHECK: return433 434 435// -----436 437// Using an unknown size.438module attributes {fir.defaultkind = "a1c4d8i4l4r4", fir.kindmap = "", llvm.target_triple = "native"} {439 func.func @sum_1d_unknown(%arg0: !fir.box<!fir.array<?xi32>> {fir.bindc_name = "a"}) -> i32 {440 %0 = fir.alloca i32 {bindc_name = "test_sum_1", uniq_name = "_QFtest_sum_1Etest_sum_1"}441 %1 = fir.absent !fir.box<i1>442 %c0 = arith.constant 0 : index443 %2 = fir.address_of(@_QQclX2E2F696D61785F312E66393000) : !fir.ref<!fir.char<1,13>>444 %c5_i32 = arith.constant 5 : i32445 %3 = fir.convert %arg0 : (!fir.box<!fir.array<?xi32>>) -> !fir.box<none>446 %4 = fir.convert %2 : (!fir.ref<!fir.char<1,13>>) -> !fir.ref<i8>447 %5 = fir.convert %c0 : (index) -> i32448 %6 = fir.convert %1 : (!fir.box<i1>) -> !fir.box<none>449 %7 = fir.call @_FortranASumlInteger4(%3, %4, %c5_i32, %5, %6) : (!fir.box<none>, !fir.ref<i8>, i32, i32, !fir.box<none>) -> i32450 fir.store %7 to %0 : !fir.ref<i32>451 %8 = fir.load %0 : !fir.ref<i32>452 return %8 : i32453 }454 func.func private @_FortranASumInteger4(!fir.box<none>, !fir.ref<i8>, i32, i32, !fir.box<none>) -> i32 attributes {fir.runtime}455 fir.global linkonce @_QQclX2E2F696D61785F312E66393000 constant : !fir.char<1,13> {456 %0 = fir.string_lit "./imax_1.f90\00"(13) : !fir.char<1,13>457 fir.has_value %0 : !fir.char<1,13>458 }459}460 461// Just check that SOMETHING is being output.462// CHECK-LABEL: @sum_1d_unknown(463// CHECK: return464 465// -----466 467func.func @dot_f32(%arg0: !fir.box<!fir.array<?xf32>> {fir.bindc_name = "a"}, %arg1: !fir.box<!fir.array<?xf32>> {fir.bindc_name = "b"}) -> f32 {468 %0 = fir.alloca f32 {bindc_name = "dot", uniq_name = "_QFdotEdot"}469 %1 = fir.address_of(@_QQclX2E2F646F742E66393000) : !fir.ref<!fir.char<1,10>>470 %c3_i32 = arith.constant 3 : i32471 %2 = fir.convert %arg0 : (!fir.box<!fir.array<?xf32>>) -> !fir.box<none>472 %3 = fir.convert %arg1 : (!fir.box<!fir.array<?xf32>>) -> !fir.box<none>473 %4 = fir.convert %1 : (!fir.ref<!fir.char<1,10>>) -> !fir.ref<i8>474 %5 = fir.call @_FortranADotProductReal4(%2, %3, %4, %c3_i32) : (!fir.box<none>, !fir.box<none>, !fir.ref<i8>, i32) -> f32475 fir.store %5 to %0 : !fir.ref<f32>476 %6 = fir.load %0 : !fir.ref<f32>477 return %6 : f32478}479// CHECK-LABEL: func.func @dot_f32(480// CHECK-SAME: %[[A:.*]]: !fir.box<!fir.array<?xf32>> {fir.bindc_name = "a"},481// CHECK-SAME: %[[B:.*]]: !fir.box<!fir.array<?xf32>> {fir.bindc_name = "b"}) -> f32 {482// CHECK: %[[RESLOC:.*]] = fir.alloca f32 {bindc_name = "dot", uniq_name = "_QFdotEdot"}483// CHECK: %[[ACAST:.*]] = fir.convert %[[A]] : (!fir.box<!fir.array<?xf32>>) -> !fir.box<none>484// CHECK: %[[BCAST:.*]] = fir.convert %[[B]] : (!fir.box<!fir.array<?xf32>>) -> !fir.box<none>485// CHECK: %[[RES:.*]] = fir.call @_FortranADotProductReal4_f32_f32_simplified(%[[ACAST]], %[[BCAST]]) : (!fir.box<none>, !fir.box<none>) -> f32486// CHECK: fir.store %[[RES]] to %[[RESLOC]] : !fir.ref<f32>487// CHECK: %[[RET:.*]] = fir.load %[[RESLOC]] : !fir.ref<f32>488// CHECK: return %[[RET]] : f32489// CHECK: }490 491// CHECK-LABEL: func.func private @_FortranADotProductReal4_f32_f32_simplified(492// CHECK-SAME: %[[A:.*]]: !fir.box<none>,493// CHECK-SAME: %[[B:.*]]: !fir.box<none>) -> f32 attributes {llvm.linkage = #llvm.linkage<linkonce_odr>} {494// CHECK: %[[FZERO:.*]] = arith.constant 0.000000e+00 : f32495// CHECK: %[[IZERO:.*]] = arith.constant 0 : index496// CHECK: %[[ACAST:.*]] = fir.convert %[[A]] : (!fir.box<none>) -> !fir.box<!fir.array<?xf32>>497// CHECK: %[[BCAST:.*]] = fir.convert %[[B]] : (!fir.box<none>) -> !fir.box<!fir.array<?xf32>>498// CHECK: %[[DIMS:.*]]:3 = fir.box_dims %[[ACAST]], %[[IZERO]] : (!fir.box<!fir.array<?xf32>>, index) -> (index, index, index)499// CHECK: %[[IONE:.*]] = arith.constant 1 : index500// CHECK: %[[LEN:.*]] = arith.subi %[[DIMS]]#1, %[[IONE]] : index501// CHECK: %[[RES:.*]] = fir.do_loop %[[IDX:.*]] = %[[IZERO]] to %[[LEN]] step %[[IONE]] iter_args(%[[SUM:.*]] = %[[FZERO]]) -> (f32) {502// CHECK: %[[ALOC:.*]] = fir.coordinate_of %[[ACAST]], %[[IDX]] : (!fir.box<!fir.array<?xf32>>, index) -> !fir.ref<f32>503// CHECK: %[[AVAL:.*]] = fir.load %[[ALOC]] : !fir.ref<f32>504// CHECK: %[[AVALCAST:.*]] = fir.convert %[[AVAL]] : (f32) -> f32505// CHECK: %[[BLOC:.*]] = fir.coordinate_of %[[BCAST]], %[[IDX]] : (!fir.box<!fir.array<?xf32>>, index) -> !fir.ref<f32>506// CHECK: %[[BVAL:.*]] = fir.load %[[BLOC]] : !fir.ref<f32>507// CHECK: %[[BVALCAST:.*]] = fir.convert %[[BVAL]] : (f32) -> f32508// CHECK: %[[MUL:.*]] = arith.mulf %[[AVALCAST]], %[[BVALCAST]] : f32509// CHECK: %[[NEWSUM:.*]] = arith.addf %[[MUL]], %[[SUM]] : f32510// CHECK: fir.result %[[NEWSUM]] : f32511// CHECK: }512// CHECK: return %[[RES]] : f32513// CHECK: }514 515// -----516 517func.func @dot_f64(%arg0: !fir.box<!fir.array<?xf64>> {fir.bindc_name = "a"}, %arg1: !fir.box<!fir.array<?xf64>> {fir.bindc_name = "b"}) -> f64 {518 %0 = fir.alloca f64 {bindc_name = "dot", uniq_name = "_QFdotEdot"}519 %1 = fir.address_of(@_QQclX2E2F646F742E66393000) : !fir.ref<!fir.char<1,10>>520 %c3_i32 = arith.constant 3 : i32521 %2 = fir.convert %arg0 : (!fir.box<!fir.array<?xf64>>) -> !fir.box<none>522 %3 = fir.convert %arg1 : (!fir.box<!fir.array<?xf64>>) -> !fir.box<none>523 %4 = fir.convert %1 : (!fir.ref<!fir.char<1,10>>) -> !fir.ref<i8>524 %5 = fir.call @_FortranADotProductReal8(%2, %3, %4, %c3_i32) : (!fir.box<none>, !fir.box<none>, !fir.ref<i8>, i32) -> f64525 fir.store %5 to %0 : !fir.ref<f64>526 %6 = fir.load %0 : !fir.ref<f64>527 return %6 : f64528}529func.func private @_FortranADotProductReal8(!fir.box<none>, !fir.box<none>, !fir.ref<i8>, i32) -> f64 attributes {fir.runtime}530fir.global linkonce @_QQclX2E2F646F742E66393000 constant : !fir.char<1,10> {531 %0 = fir.string_lit "./dot.f90\00"(10) : !fir.char<1,10>532 fir.has_value %0 : !fir.char<1,10>533}534 535// The same code handles all FP types, so just check that there is no536// call to runtime:537// CHECK-LABEL: func.func @dot_f64(538// CHECK-SAME: %[[A:.*]]: !fir.box<!fir.array<?xf64>> {fir.bindc_name = "a"},539// CHECK-SAME: %[[B:.*]]: !fir.box<!fir.array<?xf64>> {fir.bindc_name = "b"}) -> f64 {540// CHECK-NOT: call{{.*}}_FortranADotProductReal8(541 542// -----543 544func.func @dot_f80(%arg0: !fir.box<!fir.array<?xf80>> {fir.bindc_name = "a"}, %arg1: !fir.box<!fir.array<?xf80>> {fir.bindc_name = "b"}) -> f80 {545 %0 = fir.alloca f80 {bindc_name = "dot", uniq_name = "_QFdotEdot"}546 %1 = fir.address_of(@_QQclX2E2F646F742E66393000) : !fir.ref<!fir.char<1,10>>547 %c3_i32 = arith.constant 3 : i32548 %2 = fir.convert %arg0 : (!fir.box<!fir.array<?xf80>>) -> !fir.box<none>549 %3 = fir.convert %arg1 : (!fir.box<!fir.array<?xf80>>) -> !fir.box<none>550 %4 = fir.convert %1 : (!fir.ref<!fir.char<1,10>>) -> !fir.ref<i8>551 %5 = fir.call @_FortranADotProductReal10(%2, %3, %4, %c3_i32) : (!fir.box<none>, !fir.box<none>, !fir.ref<i8>, i32) -> f80552 fir.store %5 to %0 : !fir.ref<f80>553 %6 = fir.load %0 : !fir.ref<f80>554 return %6 : f80555}556func.func private @_FortranADotProductReal10(!fir.box<none>, !fir.box<none>, !fir.ref<i8>, i32) -> f80 attributes {fir.runtime}557fir.global linkonce @_QQclX2E2F646F742E66393000 constant : !fir.char<1,10> {558 %0 = fir.string_lit "./dot.f90\00"(10) : !fir.char<1,10>559 fir.has_value %0 : !fir.char<1,10>560}561 562// The same code handles all FP types, so just check that there is no563// call to runtime:564// CHECK-LABEL: func.func @dot_f80(565// CHECK-SAME: %[[A:.*]]: !fir.box<!fir.array<?xf80>> {fir.bindc_name = "a"},566// CHECK-SAME: %[[B:.*]]: !fir.box<!fir.array<?xf80>> {fir.bindc_name = "b"}) -> f80 {567// CHECK-NOT: call{{.*}}_FortranADotProductReal10(568 569// -----570 571func.func @dot_f128(%arg0: !fir.box<!fir.array<?xf128>> {fir.bindc_name = "a"}, %arg1: !fir.box<!fir.array<?xf128>> {fir.bindc_name = "b"}) -> f128 {572 %0 = fir.alloca f128 {bindc_name = "dot", uniq_name = "_QFdotEdot"}573 %1 = fir.address_of(@_QQclX2E2F646F742E66393000) : !fir.ref<!fir.char<1,10>>574 %c3_i32 = arith.constant 3 : i32575 %2 = fir.convert %arg0 : (!fir.box<!fir.array<?xf128>>) -> !fir.box<none>576 %3 = fir.convert %arg1 : (!fir.box<!fir.array<?xf128>>) -> !fir.box<none>577 %4 = fir.convert %1 : (!fir.ref<!fir.char<1,10>>) -> !fir.ref<i8>578 %5 = fir.call @_FortranADotProductReal16(%2, %3, %4, %c3_i32) : (!fir.box<none>, !fir.box<none>, !fir.ref<i8>, i32) -> f128579 fir.store %5 to %0 : !fir.ref<f128>580 %6 = fir.load %0 : !fir.ref<f128>581 return %6 : f128582}583func.func private @_FortranADotProductReal16(!fir.box<none>, !fir.box<none>, !fir.ref<i8>, i32) -> f128 attributes {fir.runtime}584fir.global linkonce @_QQclX2E2F646F742E66393000 constant : !fir.char<1,10> {585 %0 = fir.string_lit "./dot.f90\00"(10) : !fir.char<1,10>586 fir.has_value %0 : !fir.char<1,10>587}588 589// The same code handles all FP types, so just check that there is no590// call to runtime:591// CHECK-LABEL: func.func @dot_f128(592// CHECK-SAME: %[[A:.*]]: !fir.box<!fir.array<?xf128>> {fir.bindc_name = "a"},593// CHECK-SAME: %[[B:.*]]: !fir.box<!fir.array<?xf128>> {fir.bindc_name = "b"}) -> f128 {594// CHECK-NOT: call{{.*}}_FortranADotProductReal16(595 596// -----597 598func.func @dot_i32(%arg0: !fir.box<!fir.array<?xi32>> {fir.bindc_name = "a"}, %arg1: !fir.box<!fir.array<?xi32>> {fir.bindc_name = "b"}) -> i32 {599 %0 = fir.alloca i32 {bindc_name = "dot", uniq_name = "_QFdotEdot"}600 %1 = fir.address_of(@_QQclX2E2F646F742E66393000) : !fir.ref<!fir.char<1,10>>601 %c3_i32 = arith.constant 3 : i32602 %2 = fir.convert %arg0 : (!fir.box<!fir.array<?xi32>>) -> !fir.box<none>603 %3 = fir.convert %arg1 : (!fir.box<!fir.array<?xi32>>) -> !fir.box<none>604 %4 = fir.convert %1 : (!fir.ref<!fir.char<1,10>>) -> !fir.ref<i8>605 %5 = fir.call @_FortranADotProductInteger4(%2, %3, %4, %c3_i32) : (!fir.box<none>, !fir.box<none>, !fir.ref<i8>, i32) -> i32606 fir.store %5 to %0 : !fir.ref<i32>607 %6 = fir.load %0 : !fir.ref<i32>608 return %6 : i32609}610func.func private @_FortranADotProductInteger4(!fir.box<none>, !fir.box<none>, !fir.ref<i8>, i32) -> i32 attributes {fir.runtime}611fir.global linkonce @_QQclX2E2F646F742E66393000 constant : !fir.char<1,10> {612 %0 = fir.string_lit "./dot.f90\00"(10) : !fir.char<1,10>613 fir.has_value %0 : !fir.char<1,10>614}615 616// CHECK-LABEL: func.func @dot_i32(617// CHECK-SAME: %[[A:.*]]: !fir.box<!fir.array<?xi32>> {fir.bindc_name = "a"},618// CHECK-SAME: %[[B:.*]]: !fir.box<!fir.array<?xi32>> {fir.bindc_name = "b"}) -> i32 {619// CHECK: %[[RESLOC:.*]] = fir.alloca i32 {bindc_name = "dot", uniq_name = "_QFdotEdot"}620// CHECK: %[[ACAST:.*]] = fir.convert %[[A]] : (!fir.box<!fir.array<?xi32>>) -> !fir.box<none>621// CHECK: %[[BCAST:.*]] = fir.convert %[[B]] : (!fir.box<!fir.array<?xi32>>) -> !fir.box<none>622// CHECK: %[[RES:.*]] = fir.call @_FortranADotProductInteger4_i32_i32_simplified(%[[ACAST]], %[[BCAST]]) : (!fir.box<none>, !fir.box<none>) -> i32623// CHECK: fir.store %[[RES]] to %[[RESLOC]] : !fir.ref<i32>624// CHECK: %[[RET:.*]] = fir.load %[[RESLOC]] : !fir.ref<i32>625// CHECK: return %[[RET]] : i32626// CHECK: }627 628// CHECK-LABEL: func.func private @_FortranADotProductInteger4_i32_i32_simplified(629// CHECK-SAME: %[[A:.*]]: !fir.box<none>,630// CHECK-SAME: %[[B:.*]]: !fir.box<none>) -> i32 attributes {llvm.linkage = #llvm.linkage<linkonce_odr>} {631// CHECK: %[[I32ZERO:.*]] = arith.constant 0 : i32632// CHECK: %[[IZERO:.*]] = arith.constant 0 : index633// CHECK: %[[ACAST:.*]] = fir.convert %[[A]] : (!fir.box<none>) -> !fir.box<!fir.array<?xi32>>634// CHECK: %[[BCAST:.*]] = fir.convert %[[B]] : (!fir.box<none>) -> !fir.box<!fir.array<?xi32>>635// CHECK: %[[DIMS:.*]]:3 = fir.box_dims %[[ACAST]], %[[IZERO]] : (!fir.box<!fir.array<?xi32>>, index) -> (index, index, index)636// CHECK: %[[IONE:.*]] = arith.constant 1 : index637// CHECK: %[[LEN:.*]] = arith.subi %[[DIMS]]#1, %[[IONE]] : index638// CHECK: %[[RES:.*]] = fir.do_loop %[[IDX:.*]] = %[[IZERO]] to %[[LEN]] step %[[IONE]] iter_args(%[[SUM:.*]] = %[[I32ZERO]]) -> (i32) {639// CHECK: %[[ALOC:.*]] = fir.coordinate_of %[[ACAST]], %[[IDX]] : (!fir.box<!fir.array<?xi32>>, index) -> !fir.ref<i32>640// CHECK: %[[AVAL:.*]] = fir.load %[[ALOC]] : !fir.ref<i32>641// CHECK: %[[AVALCAST:.*]] = fir.convert %[[AVAL]] : (i32) -> i32642// CHECK: %[[BLOC:.*]] = fir.coordinate_of %[[BCAST]], %[[IDX]] : (!fir.box<!fir.array<?xi32>>, index) -> !fir.ref<i32>643// CHECK: %[[BVAL:.*]] = fir.load %[[BLOC]] : !fir.ref<i32>644// CHECK: %[[BVALCAST:.*]] = fir.convert %[[BVAL]] : (i32) -> i32645// CHECK: %[[MUL:.*]] = arith.muli %[[AVALCAST]], %[[BVALCAST]] : i32646// CHECK: %[[NEWSUM:.*]] = arith.addi %[[MUL]], %[[SUM]] : i32647// CHECK: fir.result %[[NEWSUM]] : i32648// CHECK: }649// CHECK: return %[[RES]] : i32650// CHECK: }651 652// -----653 654func.func @dot_i8(%arg0: !fir.box<!fir.array<?xi8>> {fir.bindc_name = "a"}, %arg1: !fir.box<!fir.array<?xi8>> {fir.bindc_name = "b"}) -> i8 {655 %0 = fir.alloca i8 {bindc_name = "dot", uniq_name = "_QFdotEdot"}656 %1 = fir.address_of(@_QQclX2E2F646F742E66393000) : !fir.ref<!fir.char<1,10>>657 %c3_i32 = arith.constant 3 : i32658 %2 = fir.convert %arg0 : (!fir.box<!fir.array<?xi8>>) -> !fir.box<none>659 %3 = fir.convert %arg1 : (!fir.box<!fir.array<?xi8>>) -> !fir.box<none>660 %4 = fir.convert %1 : (!fir.ref<!fir.char<1,10>>) -> !fir.ref<i8>661 %5 = fir.call @_FortranADotProductInteger1(%2, %3, %4, %c3_i32) : (!fir.box<none>, !fir.box<none>, !fir.ref<i8>, i32) -> i8662 fir.store %5 to %0 : !fir.ref<i8>663 %6 = fir.load %0 : !fir.ref<i8>664 return %6 : i8665}666func.func private @_FortranADotProductInteger1(!fir.box<none>, !fir.box<none>, !fir.ref<i8>, i32) -> i8 attributes {fir.runtime}667fir.global linkonce @_QQclX2E2F646F742E66393000 constant : !fir.char<1,10> {668 %0 = fir.string_lit "./dot.f90\00"(10) : !fir.char<1,10>669 fir.has_value %0 : !fir.char<1,10>670}671 672// The same code handles all integer types, so just check that there is no673// call to runtime:674// CHECK-LABEL: func.func @dot_i8(675// CHECK-SAME: %[[A:.*]]: !fir.box<!fir.array<?xi8>> {fir.bindc_name = "a"},676// CHECK-SAME: %[[B:.*]]: !fir.box<!fir.array<?xi8>> {fir.bindc_name = "b"}) -> i8 {677// CHECK-NOT: call{{.*}}_FortranADotProductInteger1(678 679// -----680 681func.func @dot_i16(%arg0: !fir.box<!fir.array<?xi16>> {fir.bindc_name = "a"}, %arg1: !fir.box<!fir.array<?xi16>> {fir.bindc_name = "b"}) -> i16 {682 %0 = fir.alloca i16 {bindc_name = "dot", uniq_name = "_QFdotEdot"}683 %1 = fir.address_of(@_QQclX2E2F646F742E66393000) : !fir.ref<!fir.char<1,10>>684 %c3_i32 = arith.constant 3 : i32685 %2 = fir.convert %arg0 : (!fir.box<!fir.array<?xi16>>) -> !fir.box<none>686 %3 = fir.convert %arg1 : (!fir.box<!fir.array<?xi16>>) -> !fir.box<none>687 %4 = fir.convert %1 : (!fir.ref<!fir.char<1,10>>) -> !fir.ref<i8>688 %5 = fir.call @_FortranADotProductInteger2(%2, %3, %4, %c3_i32) : (!fir.box<none>, !fir.box<none>, !fir.ref<i8>, i32) -> i16689 fir.store %5 to %0 : !fir.ref<i16>690 %6 = fir.load %0 : !fir.ref<i16>691 return %6 : i16692}693func.func private @_FortranADotProductInteger2(!fir.box<none>, !fir.box<none>, !fir.ref<i8>, i32) -> i16 attributes {fir.runtime}694fir.global linkonce @_QQclX2E2F646F742E66393000 constant : !fir.char<1,10> {695 %0 = fir.string_lit "./dot.f90\00"(10) : !fir.char<1,10>696 fir.has_value %0 : !fir.char<1,10>697}698 699// The same code handles all integer types, so just check that there is no700// call to runtime:701// CHECK-LABEL: func.func @dot_i16(702// CHECK-SAME: %[[A:.*]]: !fir.box<!fir.array<?xi16>> {fir.bindc_name = "a"},703// CHECK-SAME: %[[B:.*]]: !fir.box<!fir.array<?xi16>> {fir.bindc_name = "b"}) -> i16 {704// CHECK-NOT: call{{.*}}_FortranADotProductInteger2(705 706// -----707 708func.func @dot_i64(%arg0: !fir.box<!fir.array<?xi64>> {fir.bindc_name = "a"}, %arg1: !fir.box<!fir.array<?xi64>> {fir.bindc_name = "b"}) -> i64 {709 %0 = fir.alloca i64 {bindc_name = "dot", uniq_name = "_QFdotEdot"}710 %1 = fir.address_of(@_QQclX2E2F646F742E66393000) : !fir.ref<!fir.char<1,10>>711 %c3_i32 = arith.constant 3 : i32712 %2 = fir.convert %arg0 : (!fir.box<!fir.array<?xi64>>) -> !fir.box<none>713 %3 = fir.convert %arg1 : (!fir.box<!fir.array<?xi64>>) -> !fir.box<none>714 %4 = fir.convert %1 : (!fir.ref<!fir.char<1,10>>) -> !fir.ref<i8>715 %5 = fir.call @_FortranADotProductInteger8(%2, %3, %4, %c3_i32) : (!fir.box<none>, !fir.box<none>, !fir.ref<i8>, i32) -> i64716 fir.store %5 to %0 : !fir.ref<i64>717 %6 = fir.load %0 : !fir.ref<i64>718 return %6 : i64719}720func.func private @_FortranADotProductInteger8(!fir.box<none>, !fir.box<none>, !fir.ref<i8>, i32) -> i64 attributes {fir.runtime}721fir.global linkonce @_QQclX2E2F646F742E66393000 constant : !fir.char<1,10> {722 %0 = fir.string_lit "./dot.f90\00"(10) : !fir.char<1,10>723 fir.has_value %0 : !fir.char<1,10>724}725 726// The same code handles all integer types, so just check that there is no727// call to runtime:728// CHECK-LABEL: func.func @dot_i64(729// CHECK-SAME: %[[A:.*]]: !fir.box<!fir.array<?xi64>> {fir.bindc_name = "a"},730// CHECK-SAME: %[[B:.*]]: !fir.box<!fir.array<?xi64>> {fir.bindc_name = "b"}) -> i64 {731// CHECK-NOT: call{{.*}}_FortranADotProductInteger8(732 733// -----734 735// Test mixed types, e.g. when _FortranADotProductReal8 is called736// with <?xf64> and <?xf32> arguments. The loaded elements must be converted737// to the result type REAL(8) before the computations.738 739func.func @dot_f64_f32(%arg0: !fir.box<!fir.array<?xf64>> {fir.bindc_name = "a"}, %arg1: !fir.box<!fir.array<?xf32>> {fir.bindc_name = "b"}) -> f64 {740 %0 = fir.alloca f64 {bindc_name = "dot", uniq_name = "_QFdotEdot"}741 %1 = fir.address_of(@_QQclX2E2F646F742E66393000) : !fir.ref<!fir.char<1,10>>742 %c3_i32 = arith.constant 3 : i32743 %2 = fir.convert %arg0 : (!fir.box<!fir.array<?xf64>>) -> !fir.box<none>744 %3 = fir.convert %arg1 : (!fir.box<!fir.array<?xf32>>) -> !fir.box<none>745 %4 = fir.convert %1 : (!fir.ref<!fir.char<1,10>>) -> !fir.ref<i8>746 %5 = fir.call @_FortranADotProductReal8(%2, %3, %4, %c3_i32) : (!fir.box<none>, !fir.box<none>, !fir.ref<i8>, i32) -> f64747 fir.store %5 to %0 : !fir.ref<f64>748 %6 = fir.load %0 : !fir.ref<f64>749 return %6 : f64750}751func.func private @_FortranADotProductReal4(!fir.box<none>, !fir.box<none>, !fir.ref<i8>, i32) -> f32 attributes {fir.runtime}752fir.global linkonce @_QQclX2E2F646F742E66393000 constant : !fir.char<1,10> {753 %0 = fir.string_lit "./dot.f90\00"(10) : !fir.char<1,10>754 fir.has_value %0 : !fir.char<1,10>755}756 757// CHECK-LABEL: func.func @dot_f64_f32(758// CHECK-SAME: %[[A:.*]]: !fir.box<!fir.array<?xf64>> {fir.bindc_name = "a"},759// CHECK-SAME: %[[B:.*]]: !fir.box<!fir.array<?xf32>> {fir.bindc_name = "b"}) -> f64 {760// CHECK: %[[RESLOC:.*]] = fir.alloca f64 {bindc_name = "dot", uniq_name = "_QFdotEdot"}761// CHECK: %[[ACAST:.*]] = fir.convert %[[A]] : (!fir.box<!fir.array<?xf64>>) -> !fir.box<none>762// CHECK: %[[BCAST:.*]] = fir.convert %[[B]] : (!fir.box<!fir.array<?xf32>>) -> !fir.box<none>763// CHECK: %[[RES:.*]] = fir.call @_FortranADotProductReal8_f64_f32_simplified(%[[ACAST]], %[[BCAST]]) : (!fir.box<none>, !fir.box<none>) -> f64764// CHECK: fir.store %[[RES]] to %[[RESLOC]] : !fir.ref<f64>765// CHECK: %[[RET:.*]] = fir.load %[[RESLOC]] : !fir.ref<f64>766// CHECK: return %[[RET]] : f64767// CHECK: }768 769// CHECK-LABEL: func.func private @_FortranADotProductReal8_f64_f32_simplified(770// CHECK-SAME: %[[A:.*]]: !fir.box<none>,771// CHECK-SAME: %[[B:.*]]: !fir.box<none>) -> f64 attributes {llvm.linkage = #llvm.linkage<linkonce_odr>} {772// CHECK: %[[FZERO:.*]] = arith.constant 0.000000e+00 : f64773// CHECK: %[[IZERO:.*]] = arith.constant 0 : index774// CHECK: %[[ACAST:.*]] = fir.convert %[[A]] : (!fir.box<none>) -> !fir.box<!fir.array<?xf64>>775// CHECK: %[[BCAST:.*]] = fir.convert %[[B]] : (!fir.box<none>) -> !fir.box<!fir.array<?xf32>>776// CHECK: %[[DIMS:.*]]:3 = fir.box_dims %[[ACAST]], %[[IZERO]] : (!fir.box<!fir.array<?xf64>>, index) -> (index, index, index)777// CHECK: %[[IONE:.*]] = arith.constant 1 : index778// CHECK: %[[LEN:.*]] = arith.subi %[[DIMS]]#1, %[[IONE]] : index779// CHECK: %[[RES:.*]] = fir.do_loop %[[IDX:.*]] = %[[IZERO]] to %[[LEN]] step %[[IONE]] iter_args(%[[SUM:.*]] = %[[FZERO]]) -> (f64) {780// CHECK: %[[ALOC:.*]] = fir.coordinate_of %[[ACAST]], %[[IDX]] : (!fir.box<!fir.array<?xf64>>, index) -> !fir.ref<f64>781// CHECK: %[[AVAL:.*]] = fir.load %[[ALOC]] : !fir.ref<f64>782// CHECK: %[[AVALCAST:.*]] = fir.convert %[[AVAL]] : (f64) -> f64783// CHECK: %[[BLOC:.*]] = fir.coordinate_of %[[BCAST]], %[[IDX]] : (!fir.box<!fir.array<?xf32>>, index) -> !fir.ref<f32>784// CHECK: %[[BVAL:.*]] = fir.load %[[BLOC]] : !fir.ref<f32>785// CHECK: %[[BVALCAST:.*]] = fir.convert %[[BVAL]] : (f32) -> f64786// CHECK: %[[MUL:.*]] = arith.mulf %[[AVALCAST]], %[[BVALCAST]] : f64787// CHECK: %[[NEWSUM:.*]] = arith.addf %[[MUL]], %[[SUM]] : f64788// CHECK: fir.result %[[NEWSUM]] : f64789// CHECK: }790// CHECK: return %[[RES]] : f64791// CHECK: }792 793 794// -----795 796// Call to MAXVAL with 1D I32 array is replaced.797module attributes {fir.defaultkind = "a1c4d8i4l4r4", fir.kindmap = "", llvm.target_triple = "native"} {798 func.func @maxval_1d_array_int(%arg0: !fir.ref<!fir.array<10xi32>> {fir.bindc_name = "a"}) -> i32 {799 %c10 = arith.constant 10 : index800 %0 = fir.alloca i32 {bindc_name = "test_max_2", uniq_name = "_QFtest_max_2Etest_max_2"}801 %1 = fir.shape %c10 : (index) -> !fir.shape<1>802 %2 = fir.embox %arg0(%1) : (!fir.ref<!fir.array<10xi32>>, !fir.shape<1>) -> !fir.box<!fir.array<10xi32>>803 %3 = fir.absent !fir.box<i1>804 %c0 = arith.constant 0 : index805 %4 = fir.address_of(@_QQclX2E2F696D61785F322E66393000) : !fir.ref<!fir.char<1,13>>806 %c5_i32 = arith.constant 5 : i32807 %5 = fir.convert %2 : (!fir.box<!fir.array<10xi32>>) -> !fir.box<none>808 %6 = fir.convert %4 : (!fir.ref<!fir.char<1,13>>) -> !fir.ref<i8>809 %7 = fir.convert %c0 : (index) -> i32810 %8 = fir.convert %3 : (!fir.box<i1>) -> !fir.box<none>811 %9 = fir.call @_FortranAMaxvalInteger4(%5, %6, %c5_i32, %7, %8) : (!fir.box<none>, !fir.ref<i8>, i32, i32, !fir.box<none>) -> i32812 fir.store %9 to %0 : !fir.ref<i32>813 %10 = fir.load %0 : !fir.ref<i32>814 return %10 : i32815 }816 func.func private @_FortranAMaxvalInteger4(!fir.box<none>, !fir.ref<i8>, i32, i32, !fir.box<none>) -> i32 attributes {fir.runtime}817 fir.global linkonce @_QQclX2E2F696D61785F322E66393000 constant : !fir.char<1,13> {818 %0 = fir.string_lit "./imax_2.f90\00"(13) : !fir.char<1,13>819 fir.has_value %0 : !fir.char<1,13>820 }821}822 823// CHECK-LABEL: func.func @maxval_1d_array_int(824// CHECK-SAME: %[[A:.*]]: !fir.ref<!fir.array<10xi32>> {fir.bindc_name = "a"}) -> i32 {825// CHECK: %[[SHAPE:.*]] = fir.shape %{{.*}} : (index) -> !fir.shape<1>826// CHECK: %[[A_BOX_I32:.*]] = fir.embox %[[A]](%[[SHAPE]]) : (!fir.ref<!fir.array<10xi32>>, !fir.shape<1>) -> !fir.box<!fir.array<10xi32>>827// CHECK: %[[A_BOX_NONE:.*]] = fir.convert %[[A_BOX_I32]] : (!fir.box<!fir.array<10xi32>>) -> !fir.box<none>828// CHECK: %[[RES:.*]] = fir.call @_FortranAMaxvalInteger4x1_simplified(%[[A_BOX_NONE]]) : (!fir.box<none>) -> i32829// CHECK: return %{{.*}} : i32830// CHECK: }831 832// CHECK-LABEL: func.func private @_FortranAMaxvalInteger4x1_simplified(833// CHECK-SAME: %[[ARR:.*]]: !fir.box<none>) -> i32 attributes {llvm.linkage = #llvm.linkage<linkonce_odr>} {834// CHECK: %[[CINDEX_0:.*]] = arith.constant 0 : index835// CHECK: %[[ARR_BOX_I32:.*]] = fir.convert %[[ARR]] : (!fir.box<none>) -> !fir.box<!fir.array<?xi32>>836// CHECK: %[[CI32_MININT:.*]] = arith.constant -2147483648 : i32837// CHECK: %[[CINDEX_1:.*]] = arith.constant 1 : index838// CHECK: %[[DIMIDX_0:.*]] = arith.constant 0 : index839// CHECK: %[[DIMS:.*]]:3 = fir.box_dims %[[ARR_BOX_I32]], %[[DIMIDX_0]] : (!fir.box<!fir.array<?xi32>>, index) -> (index, index, index)840// CHECK: %[[EXTENT:.*]] = arith.subi %[[DIMS]]#1, %[[CINDEX_1]] : index841// CHECK: %[[RES:.*]] = fir.do_loop %[[ITER:.*]] = %[[CINDEX_0]] to %[[EXTENT]] step %[[CINDEX_1]] iter_args(%[[MAX:.*]] = %[[CI32_MININT]]) -> (i32) {842// CHECK: %[[ITEM:.*]] = fir.coordinate_of %[[ARR_BOX_I32]], %[[ITER]] : (!fir.box<!fir.array<?xi32>>, index) -> !fir.ref<i32>843// CHECK: %[[ITEM_VAL:.*]] = fir.load %[[ITEM]] : !fir.ref<i32>844// CHECK: %[[NEW_MAX:.*]] = arith.maxsi %[[ITEM_VAL]], %[[MAX]] : i32845// CHECK: fir.result %[[NEW_MAX]] : i32846// CHECK: }847// CHECK: return %[[RES]] : i32848// CHECK: }849 850// -----851 852// Call to MAXVAL with 1D F64 is replaced.853module attributes {fir.defaultkind = "a1c4d8i4l4r4", fir.kindmap = "", llvm.target_triple = "native"} {854 func.func @maxval_1d_real(%arg0: !fir.ref<!fir.array<10xf64>> {fir.bindc_name = "a"}) -> f64 {855 %c10 = arith.constant 10 : index856 %0 = fir.alloca f64 {bindc_name = "maxval_1d_real", uniq_name = "_QFmaxval_1d_realEmaxval_1d_real"}857 %1 = fir.shape %c10 : (index) -> !fir.shape<1>858 %2 = fir.embox %arg0(%1) : (!fir.ref<!fir.array<10xf64>>, !fir.shape<1>) -> !fir.box<!fir.array<10xf64>>859 %3 = fir.absent !fir.box<i1>860 %c0 = arith.constant 0 : index861 %4 = fir.address_of(@_QQclX2E2F6973756D5F352E66393000) : !fir.ref<!fir.char<1,13>>862 %c5_i32 = arith.constant 5 : i32863 %5 = fir.convert %2 : (!fir.box<!fir.array<10xf64>>) -> !fir.box<none>864 %6 = fir.convert %4 : (!fir.ref<!fir.char<1,13>>) -> !fir.ref<i8>865 %7 = fir.convert %c0 : (index) -> i32866 %8 = fir.convert %3 : (!fir.box<i1>) -> !fir.box<none>867 %9 = fir.call @_FortranAMaxvalReal8(%5, %6, %c5_i32, %7, %8) : (!fir.box<none>, !fir.ref<i8>, i32, i32, !fir.box<none>) -> f64868 fir.store %9 to %0 : !fir.ref<f64>869 %10 = fir.load %0 : !fir.ref<f64>870 return %10 : f64871 }872 func.func private @_FortranAMaxvalReal8(!fir.box<none>, !fir.ref<i8>, i32, i32, !fir.box<none>) -> f64 attributes {fir.runtime}873 fir.global linkonce @_QQclX2E2F6973756D5F352E66393000 constant : !fir.char<1,13> {874 %0 = fir.string_lit "./imaxval_5.f90\00"(13) : !fir.char<1,13>875 fir.has_value %0 : !fir.char<1,13>876 }877}878 879 880// CHECK-LABEL: func.func @maxval_1d_real(881// CHECK-SAME: %[[A:.*]]: !fir.ref<!fir.array<10xf64>> {fir.bindc_name = "a"}) -> f64 {882// CHECK: %[[CINDEX_10:.*]] = arith.constant 10 : index883// CHECK: %[[SHAPE:.*]] = fir.shape %[[CINDEX_10]] : (index) -> !fir.shape<1>884// CHECK: %[[A_BOX_F64:.*]] = fir.embox %[[A]](%[[SHAPE]]) : (!fir.ref<!fir.array<10xf64>>, !fir.shape<1>) -> !fir.box<!fir.array<10xf64>>885// CHECK: %[[A_BOX_NONE:.*]] = fir.convert %[[A_BOX_F64]] : (!fir.box<!fir.array<10xf64>>) -> !fir.box<none>886// CHECK: %[[RES:.*]] = fir.call @_FortranAMaxvalReal8x1_simplified(%[[A_BOX_NONE]]) : (!fir.box<none>) -> f64887// CHECK: return %{{.*}} : f64888// CHECK: }889 890// CHECK-LABEL: func.func private @_FortranAMaxvalReal8x1_simplified(891// CHECK-SAME: %[[ARR:.*]]: !fir.box<none>) -> f64 attributes {llvm.linkage = #llvm.linkage<linkonce_odr>} {892// CHECK: %[[CINDEX_0:.*]] = arith.constant 0 : index893// CHECK: %[[ARR_BOX_F64:.*]] = fir.convert %[[ARR]] : (!fir.box<none>) -> !fir.box<!fir.array<?xf64>>894// CHECK: %[[NEG_DBL_MAX:.*]] = arith.constant -1.7976931348623157E+308 : f64895// CHECK: %[[CINDEX_1:.*]] = arith.constant 1 : index896// CHECK: %[[DIMIDX_0:.*]] = arith.constant 0 : index897// CHECK: %[[DIMS:.*]]:3 = fir.box_dims %[[ARR_BOX_F64]], %[[DIMIDX_0]] : (!fir.box<!fir.array<?xf64>>, index) -> (index, index, index)898// CHECK: %[[EXTENT:.*]] = arith.subi %[[DIMS]]#1, %[[CINDEX_1]] : index899// CHECK: %[[RES:.*]] = fir.do_loop %[[ITER:.*]] = %[[CINDEX_0]] to %[[EXTENT]] step %[[CINDEX_1]] iter_args(%[[MAX]] = %[[NEG_DBL_MAX]]) -> (f64) {900// CHECK: %[[ITEM:.*]] = fir.coordinate_of %[[ARR_BOX_F64]], %[[ITER]] : (!fir.box<!fir.array<?xf64>>, index) -> !fir.ref<f64>901// CHECK: %[[ITEM_VAL:.*]] = fir.load %[[ITEM]] : !fir.ref<f64>902// CHECK: %[[CMP:.*]] = arith.cmpf ogt, %[[ITEM_VAL]], %[[MAX]] : f64903// CHECK: %[[NEW_MAX:.*]] = arith.select %[[CMP]], %[[ITEM_VAL]], %[[MAX]] : f64904// CHECK: fir.result %[[NEW_MAX]] : f64905// CHECK: }906// CHECK: return %[[RES]] : f64907// CHECK: }908 909// -----910 911// SUM reduction of sliced explicit-shape array is replaced with912// 2D simplified implementation.913func.func @sum_sliced_embox_i64(%arg0: !fir.ref<!fir.array<10x10x10xi64>> {fir.bindc_name = "a"}) -> f32 {914 %c10 = arith.constant 10 : index915 %c10_0 = arith.constant 10 : index916 %c10_1 = arith.constant 10 : index917 %0 = fir.alloca f32 {bindc_name = "sum_sliced_embox_i64", uniq_name = "_QFsum_sliced_embox_i64Esum_sliced_embox_i64"}918 %1 = fir.alloca i64 {bindc_name = "sum_sliced_i64", uniq_name = "_QFsum_sliced_embox_i64Esum_sliced_i64"}919 %c1 = arith.constant 1 : index920 %c1_i64 = arith.constant 1 : i64921 %2 = fir.convert %c1_i64 : (i64) -> index922 %3 = arith.addi %c1, %c10 : index923 %4 = arith.subi %3, %c1 : index924 %c1_i64_2 = arith.constant 1 : i64925 %5 = fir.convert %c1_i64_2 : (i64) -> index926 %6 = arith.addi %c1, %c10_0 : index927 %7 = arith.subi %6, %c1 : index928 %c1_i64_3 = arith.constant 1 : i64929 %8 = fir.undefined index930 %9 = fir.shape %c10, %c10_0, %c10_1 : (index, index, index) -> !fir.shape<3>931 %10 = fir.slice %c1, %4, %2, %c1, %7, %5, %c1_i64_3, %8, %8 : (index, index, index, index, index, index, i64, index, index) -> !fir.slice<3>932 %11 = fir.embox %arg0(%9) [%10] : (!fir.ref<!fir.array<10x10x10xi64>>, !fir.shape<3>, !fir.slice<3>) -> !fir.box<!fir.array<?x?xi64>>933 %12 = fir.absent !fir.box<i1>934 %c0 = arith.constant 0 : index935 %13 = fir.address_of(@_QQclX2E2F746573742E66393000) : !fir.ref<!fir.char<1,11>>936 %c3_i32 = arith.constant 3 : i32937 %14 = fir.convert %11 : (!fir.box<!fir.array<?x?xi64>>) -> !fir.box<none>938 %15 = fir.convert %13 : (!fir.ref<!fir.char<1,11>>) -> !fir.ref<i8>939 %16 = fir.convert %c0 : (index) -> i32940 %17 = fir.convert %12 : (!fir.box<i1>) -> !fir.box<none>941 %18 = fir.call @_FortranASumInteger8(%14, %15, %c3_i32, %16, %17) : (!fir.box<none>, !fir.ref<i8>, i32, i32, !fir.box<none>) -> i64942 fir.store %18 to %1 : !fir.ref<i64>943 %19 = fir.load %0 : !fir.ref<f32>944 return %19 : f32945}946func.func private @_FortranASumInteger8(!fir.box<none>, !fir.ref<i8>, i32, i32, !fir.box<none>) -> i64 attributes {fir.runtime}947fir.global linkonce @_QQclX2E2F746573742E66393000 constant : !fir.char<1,11> {948 %0 = fir.string_lit "./test.f90\00"(11) : !fir.char<1,11>949 fir.has_value %0 : !fir.char<1,11>950}951 952// CHECK-NOT: call{{.*}}_FortranASumInteger8(953// CHECK: call @_FortranASumInteger8x2_simplified(954// CHECK-NOT: call{{.*}}_FortranASumInteger8(955 956// -----957 958// SUM reduction of sliced assumed-shape array is replaced with959// 2D simplified implementation.960func.func @_QPsum_sliced_rebox_i64(%arg0: !fir.box<!fir.array<?x?x?xi64>> {fir.bindc_name = "a"}) -> f32 {961 %0 = fir.alloca i64 {bindc_name = "sum_sliced_i64", uniq_name = "_QFsum_sliced_rebox_i64Esum_sliced_i64"}962 %1 = fir.alloca f32 {bindc_name = "sum_sliced_rebox_i64", uniq_name = "_QFsum_sliced_rebox_i64Esum_sliced_rebox_i64"}963 %c1 = arith.constant 1 : index964 %c1_i64 = arith.constant 1 : i64965 %2 = fir.convert %c1_i64 : (i64) -> index966 %c0 = arith.constant 0 : index967 %3:3 = fir.box_dims %arg0, %c0 : (!fir.box<!fir.array<?x?x?xi64>>, index) -> (index, index, index)968 %4 = arith.addi %c1, %3#1 : index969 %5 = arith.subi %4, %c1 : index970 %c1_i64_0 = arith.constant 1 : i64971 %6 = fir.convert %c1_i64_0 : (i64) -> index972 %c1_1 = arith.constant 1 : index973 %7:3 = fir.box_dims %arg0, %c1_1 : (!fir.box<!fir.array<?x?x?xi64>>, index) -> (index, index, index)974 %8 = arith.addi %c1, %7#1 : index975 %9 = arith.subi %8, %c1 : index976 %c1_i64_2 = arith.constant 1 : i64977 %10 = fir.undefined index978 %11 = fir.slice %c1, %5, %2, %c1, %9, %6, %c1_i64_2, %10, %10 : (index, index, index, index, index, index, i64, index, index) -> !fir.slice<3>979 %12 = fir.rebox %arg0 [%11] : (!fir.box<!fir.array<?x?x?xi64>>, !fir.slice<3>) -> !fir.box<!fir.array<?x?xi64>>980 %13 = fir.absent !fir.box<i1>981 %c0_3 = arith.constant 0 : index982 %14 = fir.address_of(@_QQclX2E2F746573742E66393000) : !fir.ref<!fir.char<1,11>>983 %c8_i32 = arith.constant 8 : i32984 %15 = fir.convert %12 : (!fir.box<!fir.array<?x?xi64>>) -> !fir.box<none>985 %16 = fir.convert %14 : (!fir.ref<!fir.char<1,11>>) -> !fir.ref<i8>986 %17 = fir.convert %c0_3 : (index) -> i32987 %18 = fir.convert %13 : (!fir.box<i1>) -> !fir.box<none>988 %19 = fir.call @_FortranASumInteger8(%15, %16, %c8_i32, %17, %18) : (!fir.box<none>, !fir.ref<i8>, i32, i32, !fir.box<none>) -> i64989 fir.store %19 to %0 : !fir.ref<i64>990 %20 = fir.load %1 : !fir.ref<f32>991 return %20 : f32992}993func.func private @_FortranASumInteger8(!fir.box<none>, !fir.ref<i8>, i32, i32, !fir.box<none>) -> i64 attributes {fir.runtime}994fir.global linkonce @_QQclX2E2F746573742E66393000 constant : !fir.char<1,11> {995 %0 = fir.string_lit "./test.f90\00"(11) : !fir.char<1,11>996 fir.has_value %0 : !fir.char<1,11>997}998 999// CHECK-NOT: call{{.*}}_FortranASumInteger8(1000// CHECK: call @_FortranASumInteger8x2_simplified(1001// CHECK-NOT: call{{.*}}_FortranASumInteger8(1002 1003// -----1004 1005func.func @dot_f32_contract_reassoc(%arg0: !fir.box<!fir.array<?xf32>> {fir.bindc_name = "a"}, %arg1: !fir.box<!fir.array<?xf32>> {fir.bindc_name = "b"}) -> f32 {1006 %0 = fir.alloca f32 {bindc_name = "dot", uniq_name = "_QFdotEdot"}1007 %1 = fir.address_of(@_QQclX2E2F646F742E66393000) : !fir.ref<!fir.char<1,10>>1008 %c3_i32 = arith.constant 3 : i321009 %2 = fir.convert %arg0 : (!fir.box<!fir.array<?xf32>>) -> !fir.box<none>1010 %3 = fir.convert %arg1 : (!fir.box<!fir.array<?xf32>>) -> !fir.box<none>1011 %4 = fir.convert %1 : (!fir.ref<!fir.char<1,10>>) -> !fir.ref<i8>1012 %5 = fir.call @_FortranADotProductReal4(%2, %3, %4, %c3_i32) fastmath<contract,reassoc> : (!fir.box<none>, !fir.box<none>, !fir.ref<i8>, i32) -> f321013 fir.store %5 to %0 : !fir.ref<f32>1014 %6 = fir.load %0 : !fir.ref<f32>1015 return %6 : f321016}1017 1018func.func @dot_f32_fast(%arg0: !fir.box<!fir.array<?xf32>> {fir.bindc_name = "a"}, %arg1: !fir.box<!fir.array<?xf32>> {fir.bindc_name = "b"}) -> f32 {1019 %0 = fir.alloca f32 {bindc_name = "dot", uniq_name = "_QFdotEdot"}1020 %1 = fir.address_of(@_QQclX2E2F646F742E66393000) : !fir.ref<!fir.char<1,10>>1021 %c3_i32 = arith.constant 3 : i321022 %2 = fir.convert %arg0 : (!fir.box<!fir.array<?xf32>>) -> !fir.box<none>1023 %3 = fir.convert %arg1 : (!fir.box<!fir.array<?xf32>>) -> !fir.box<none>1024 %4 = fir.convert %1 : (!fir.ref<!fir.char<1,10>>) -> !fir.ref<i8>1025 %5 = fir.call @_FortranADotProductReal4(%2, %3, %4, %c3_i32) fastmath<fast> : (!fir.box<none>, !fir.box<none>, !fir.ref<i8>, i32) -> f321026 fir.store %5 to %0 : !fir.ref<f32>1027 %6 = fir.load %0 : !fir.ref<f32>1028 return %6 : f321029}1030 1031func.func private @_FortranADotProductReal4(!fir.box<none>, !fir.box<none>, !fir.ref<i8>, i32) -> f32 attributes {fir.runtime}1032fir.global linkonce @_QQclX2E2F646F742E66393000 constant : !fir.char<1,10> {1033 %0 = fir.string_lit "./dot.f90\00"(10) : !fir.char<1,10>1034 fir.has_value %0 : !fir.char<1,10>1035}1036 1037// CHECK-LABEL: @dot_f32_contract_reassoc1038// CHECK: fir.call @_FortranADotProductReal4_reassoc_contract_f32_f32_simplified(%2, %3) fastmath<reassoc,contract>1039// CHECK-LABEL: @dot_f32_fast1040// CHECK: fir.call @_FortranADotProductReal4_fast_f32_f32_simplified(%2, %3) fastmath<fast>1041// CHECK-LABEL: func.func private @_FortranADotProductReal4_reassoc_contract_f32_f32_simplified1042// CHECK: arith.mulf %{{.*}}, %{{.*}} fastmath<reassoc,contract> : f321043// CHECK: arith.addf %{{.*}}, %{{.*}} fastmath<reassoc,contract> : f321044// CHECK-LABEL: func.func private @_FortranADotProductReal4_fast_f32_f32_simplified1045// CHECK: arith.mulf %{{.*}}, %{{.*}} fastmath<fast> : f321046// CHECK: arith.addf %{{.*}}, %{{.*}} fastmath<fast> : f321047 1048// -----1049 1050func.func @sum_1d_real_contract_reassoc(%arg0: !fir.ref<!fir.array<10xf64>> {fir.bindc_name = "a"}) -> f64 {1051 %c10 = arith.constant 10 : index1052 %0 = fir.alloca f64 {bindc_name = "sum_1d_real", uniq_name = "_QFsum_1d_realEsum_1d_real"}1053 %1 = fir.shape %c10 : (index) -> !fir.shape<1>1054 %2 = fir.embox %arg0(%1) : (!fir.ref<!fir.array<10xf64>>, !fir.shape<1>) -> !fir.box<!fir.array<10xf64>>1055 %3 = fir.absent !fir.box<i1>1056 %c0 = arith.constant 0 : index1057 %4 = fir.address_of(@_QQclX2E2F6973756D5F352E66393000) : !fir.ref<!fir.char<1,13>>1058 %c5_i32 = arith.constant 5 : i321059 %5 = fir.convert %2 : (!fir.box<!fir.array<10xf64>>) -> !fir.box<none>1060 %6 = fir.convert %4 : (!fir.ref<!fir.char<1,13>>) -> !fir.ref<i8>1061 %7 = fir.convert %c0 : (index) -> i321062 %8 = fir.convert %3 : (!fir.box<i1>) -> !fir.box<none>1063 %9 = fir.call @_FortranASumReal8(%5, %6, %c5_i32, %7, %8) fastmath<contract,reassoc> : (!fir.box<none>, !fir.ref<i8>, i32, i32, !fir.box<none>) -> f641064 fir.store %9 to %0 : !fir.ref<f64>1065 %10 = fir.load %0 : !fir.ref<f64>1066 return %10 : f641067}1068 1069func.func @sum_1d_real_fast(%arg0: !fir.ref<!fir.array<10xf64>> {fir.bindc_name = "a"}) -> f64 {1070 %c10 = arith.constant 10 : index1071 %0 = fir.alloca f64 {bindc_name = "sum_1d_real", uniq_name = "_QFsum_1d_realEsum_1d_real"}1072 %1 = fir.shape %c10 : (index) -> !fir.shape<1>1073 %2 = fir.embox %arg0(%1) : (!fir.ref<!fir.array<10xf64>>, !fir.shape<1>) -> !fir.box<!fir.array<10xf64>>1074 %3 = fir.absent !fir.box<i1>1075 %c0 = arith.constant 0 : index1076 %4 = fir.address_of(@_QQclX2E2F6973756D5F352E66393000) : !fir.ref<!fir.char<1,13>>1077 %c5_i32 = arith.constant 5 : i321078 %5 = fir.convert %2 : (!fir.box<!fir.array<10xf64>>) -> !fir.box<none>1079 %6 = fir.convert %4 : (!fir.ref<!fir.char<1,13>>) -> !fir.ref<i8>1080 %7 = fir.convert %c0 : (index) -> i321081 %8 = fir.convert %3 : (!fir.box<i1>) -> !fir.box<none>1082 %9 = fir.call @_FortranASumReal8(%5, %6, %c5_i32, %7, %8) fastmath<fast> : (!fir.box<none>, !fir.ref<i8>, i32, i32, !fir.box<none>) -> f641083 fir.store %9 to %0 : !fir.ref<f64>1084 %10 = fir.load %0 : !fir.ref<f64>1085 return %10 : f641086}1087 1088func.func private @_FortranASumReal8(!fir.box<none>, !fir.ref<i8>, i32, i32, !fir.box<none>) -> f64 attributes {fir.runtime}1089fir.global linkonce @_QQclX2E2F6973756D5F352E66393000 constant : !fir.char<1,13> {1090 %0 = fir.string_lit "./isum_5.f90\00"(13) : !fir.char<1,13>1091 fir.has_value %0 : !fir.char<1,13>1092}1093 1094// CHECK-LABEL: @sum_1d_real_contract_reassoc1095// CHECK: fir.call @_FortranASumReal8x1_reassoc_contract_simplified(%5) fastmath<reassoc,contract>1096// CHECK-LABEL: @sum_1d_real_fast1097// CHECK: fir.call @_FortranASumReal8x1_fast_simplified(%5) fastmath<fast>1098// CHECK-LABEL: func.func private @_FortranASumReal8x1_reassoc_contract_simplified1099// CHECK: arith.addf %{{.*}}, %{{.*}} fastmath<reassoc,contract> : f641100// CHECK-LABEL: func.func private @_FortranASumReal8x1_fast_simplified1101// CHECK: arith.addf %{{.*}}, %{{.*}} fastmath<fast> : f641102 1103// -----1104// Ensure count is simplified in valid case1105 1106func.func @_QMtestPcount_generate_mask(%arg0: !fir.ref<f32> {fir.bindc_name = "a"}) -> i32 {1107 %0 = fir.alloca i32 {bindc_name = "count_generate_mask", uniq_name = "_QMtestFcount_generate_maskEcount_generate_mask"}1108 %c10 = arith.constant 10 : index1109 %1 = fir.alloca !fir.array<10x!fir.logical<4>> {bindc_name = "mask", uniq_name = "_QMtestFcount_generate_maskEmask"}1110 %2 = fir.shape %c10 : (index) -> !fir.shape<1>1111 %3 = fir.embox %1(%2) : (!fir.ref<!fir.array<10x!fir.logical<4>>>, !fir.shape<1>) -> !fir.box<!fir.array<10x!fir.logical<4>>>1112 %c0 = arith.constant 0 : index1113 %4 = fir.address_of(@_QQclX2E2F746573746661696C2E66393000) : !fir.ref<!fir.char<1,15>>1114 %c10_i32 = arith.constant 10 : i321115 %5 = fir.convert %3 : (!fir.box<!fir.array<10x!fir.logical<4>>>) -> !fir.box<none>1116 %6 = fir.convert %4 : (!fir.ref<!fir.char<1,15>>) -> !fir.ref<i8>1117 %7 = fir.convert %c0 : (index) -> i321118 %8 = fir.call @_FortranACount(%5, %6, %c10_i32, %7) fastmath<contract> : (!fir.box<none>, !fir.ref<i8>, i32, i32) -> i641119 %9 = fir.convert %8 : (i64) -> i321120 fir.store %9 to %0 : !fir.ref<i32>1121 %10 = fir.load %0 : !fir.ref<i32>1122 return %10 : i321123}1124func.func private @_FortranACount(!fir.box<none>, !fir.ref<i8>, i32, i32) -> i64 attributes {fir.runtime}1125fir.global linkonce @_QQclX2E2F746573746661696C2E66393000 constant : !fir.char<1,15> {1126 %0 = fir.string_lit "./test.f90\00"(15) : !fir.char<1,15>1127 fir.has_value %0 : !fir.char<1,15>1128}1129 1130// CHECK-LABEL: func.func @_QMtestPcount_generate_mask(1131// CHECK-SAME: %[[A:.*]]: !fir.ref<f32> {fir.bindc_name = "a"}) -> i32 {1132// CHECK: %[[SHAPE:.*]] = fir.shape %{{.*}} : (index) -> !fir.shape<1>1133// CHECK: %[[A_BOX_LOGICAL:.*]] = fir.embox %{{.*}}(%[[SHAPE]]) : (!fir.ref<!fir.array<10x!fir.logical<4>>>, !fir.shape<1>) -> !fir.box<!fir.array<10x!fir.logical<4>>>1134// CHECK: %[[A_BOX_NONE:.*]] = fir.convert %[[A_BOX_LOGICAL]] : (!fir.box<!fir.array<10x!fir.logical<4>>>) -> !fir.box<none>1135// CHECK-NOT: fir.call @_FortranACount({{.*}})1136// CHECK: %[[RES:.*]] = fir.call @_FortranACountLogical4x1_simplified(%[[A_BOX_NONE]]) fastmath<contract> : (!fir.box<none>) -> i641137// CHECK-NOT: fir.call @_FortranACount({{.*}})1138// CHECK: return %{{.*}} : i321139// CHECK: }1140// CHECK: func.func private @_FortranACount(!fir.box<none>, !fir.ref<i8>, i32, i32) -> i64 attributes {fir.runtime}1141 1142// CHECK-LABEL: func.func private @_FortranACountLogical4x1_simplified(1143// CHECK-SAME: %[[ARR:.*]]: !fir.box<none>) -> i64 attributes {llvm.linkage = #llvm.linkage<linkonce_odr>} {1144// CHECK: %[[C_INDEX0:.*]] = arith.constant 0 : index1145// CHECK: %[[ARR_BOX_I32:.*]] = fir.convert %[[ARR]] : (!fir.box<none>) -> !fir.box<!fir.array<?xi32>>1146// CHECK: %[[IZERO:.*]] = arith.constant 0 : i641147// CHECK: %[[C_INDEX1:.*]] = arith.constant 1 : index1148// CHECK: %[[DIMIDX_0:.*]] = arith.constant 0 : index1149// CHECK: %[[DIMS:.*]]:3 = fir.box_dims %[[ARR_BOX_I32]], %[[DIMIDX_0]] : (!fir.box<!fir.array<?xi32>>, index) -> (index, index, index)1150// CHECK: %[[EXTENT:.*]] = arith.subi %[[DIMS]]#1, %[[C_INDEX1]] : index1151// CHECK: %[[RES:.*]] = fir.do_loop %[[ITER:.*]] = %[[C_INDEX0]] to %[[EXTENT]] step %[[C_INDEX1]] iter_args(%[[COUNT:.*]] = %[[IZERO]]) -> (i64) {1152// CHECK: %[[ITEM:.*]] = fir.coordinate_of %[[ARR_BOX_I32]], %[[ITER]] : (!fir.box<!fir.array<?xi32>>, index) -> !fir.ref<i32>1153// CHECK: %[[ITEM_VAL:.*]] = fir.load %[[ITEM]] : !fir.ref<i32>1154// CHECK: %[[I32_0:.*]] = arith.constant 0 : i321155// CHECK: %[[I64_0:.*]] = arith.constant 0 : i641156// CHECK: %[[I64_1:.*]] = arith.constant 1 : i641157// CHECK: %[[CMP:.*]] = arith.cmpi eq, %[[ITEM_VAL]], %[[I32_0]] : i321158// CHECK: %[[SELECT:.*]] = arith.select %[[CMP]], %[[I64_0]], %[[I64_1]] : i641159// CHECK: %[[NEW_COUNT:.*]] = arith.addi %[[SELECT]], %[[COUNT]] : i641160// CHECK: fir.result %[[NEW_COUNT]] : i641161// CHECK: }1162// CHECK: return %[[RES:.*]] : i641163// CHECK: }1164 1165// -----1166// Ensure count is properly simplified for different mask kind1167 1168func.func @_QPdiffkind(%arg0: !fir.ref<!fir.array<10x!fir.logical<2>>> {fir.bindc_name = "mask"}) -> i32 {1169 %0 = fir.alloca i32 {bindc_name = "diffkind", uniq_name = "_QFdiffkindEdiffkind"}1170 %c10 = arith.constant 10 : index1171 %1 = fir.shape %c10 : (index) -> !fir.shape<1>1172 %2 = fir.embox %arg0(%1) : (!fir.ref<!fir.array<10x!fir.logical<2>>>, !fir.shape<1>) -> !fir.box<!fir.array<10x!fir.logical<2>>>1173 %c0 = arith.constant 0 : index1174 %3 = fir.address_of(@_QQclX916d74b25894ddf7881ff7f913a677f5) : !fir.ref<!fir.char<1,52>>1175 %c5_i32 = arith.constant 5 : i321176 %4 = fir.convert %2 : (!fir.box<!fir.array<10x!fir.logical<2>>>) -> !fir.box<none>1177 %5 = fir.convert %3 : (!fir.ref<!fir.char<1,52>>) -> !fir.ref<i8>1178 %6 = fir.convert %c0 : (index) -> i321179 %7 = fir.call @_FortranACount(%4, %5, %c5_i32, %6) fastmath<contract> : (!fir.box<none>, !fir.ref<i8>, i32, i32) -> i641180 %8 = fir.convert %7 : (i64) -> i321181 fir.store %8 to %0 : !fir.ref<i32>1182 %9 = fir.load %0 : !fir.ref<i32>1183 return %9 : i321184}1185 1186// CHECK-LABEL: func.func @_QPdiffkind(1187// CHECK-SAME: %[[A:.*]]: !fir.ref<!fir.array<10x!fir.logical<2>>> {fir.bindc_name = "mask"}) -> i32 {1188// CHECK: %[[res:.*]] = fir.call @_FortranACountLogical2x1_simplified({{.*}}) fastmath<contract> : (!fir.box<none>) -> i641189 1190// CHECK-LABEL: func.func private @_FortranACountLogical2x1_simplified(1191// CHECK-SAME: %[[ARR:.*]]: !fir.box<none>) -> i64 attributes {llvm.linkage = #llvm.linkage<linkonce_odr>} {1192// CHECK: %[[C_INDEX0:.*]] = arith.constant 0 : index1193// CHECK: %[[ARR_BOX_I16:.*]] = fir.convert %[[ARR]] : (!fir.box<none>) -> !fir.box<!fir.array<?xi16>>1194// CHECK: %[[IZERO:.*]] = arith.constant 0 : i641195// CHECK: %[[C_INDEX1:.*]] = arith.constant 1 : index1196// CHECK: %[[DIMIDX_0:.*]] = arith.constant 0 : index1197// CHECK: %[[DIMS:.*]]:3 = fir.box_dims %[[ARR_BOX_I16]], %[[DIMIDX_0]] : (!fir.box<!fir.array<?xi16>>, index) -> (index, index, index)1198// CHECK: %[[EXTENT:.*]] = arith.subi %[[DIMS]]#1, %[[C_INDEX1]] : index1199// CHECK: %[[RES:.*]] = fir.do_loop %[[ITER:.*]] = %[[C_INDEX0]] to %[[EXTENT]] step %[[C_INDEX1]] iter_args(%[[COUNT:.*]] = %[[IZERO]]) -> (i64) {1200// CHECK: %[[ITEM:.*]] = fir.coordinate_of %[[ARR_BOX_I16]], %[[ITER]] : (!fir.box<!fir.array<?xi16>>, index) -> !fir.ref<i16>1201// CHECK: %[[ITEM_VAL:.*]] = fir.load %[[ITEM]] : !fir.ref<i16>1202// CHECK: %[[I16_0:.*]] = arith.constant 0 : i161203// CHECK: %[[I64_0:.*]] = arith.constant 0 : i641204// CHECK: %[[I64_1:.*]] = arith.constant 1 : i641205// CHECK: %[[CMP:.*]] = arith.cmpi eq, %[[ITEM_VAL]], %[[I16_0]] : i161206// CHECK: %[[SELECT:.*]] = arith.select %[[CMP]], %[[I64_0]], %[[I64_1]] : i641207// CHECK: %[[NEW_COUNT:.*]] = arith.addi %[[SELECT]], %[[COUNT]] : i641208// CHECK: fir.result %[[NEW_COUNT]] : i641209// CHECK: }1210// CHECK: return %[[RES:.*]] : i641211// CHECK: }1212 1213// -----1214// Ensure count isn't simplified when given dim argument1215 1216func.func @_QMtestPcount_generate_mask(%arg0: !fir.ref<!fir.array<10x10x!fir.logical<4>>> {fir.bindc_name = "mask"}) -> !fir.array<10xi32> {1217 %0 = fir.alloca !fir.box<!fir.heap<!fir.array<?xi32>>>1218 %c10 = arith.constant 10 : index1219 %c10_0 = arith.constant 10 : index1220 %c10_1 = arith.constant 10 : index1221 %1 = fir.alloca !fir.array<10xi32> {bindc_name = "res", uniq_name = "_QMtestFcount_generate_maskEres"}1222 %2 = fir.shape %c10_1 : (index) -> !fir.shape<1>1223 %3 = fir.array_load %1(%2) : (!fir.ref<!fir.array<10xi32>>, !fir.shape<1>) -> !fir.array<10xi32>1224 %c2_i32 = arith.constant 2 : i321225 %4 = fir.shape %c10, %c10_0 : (index, index) -> !fir.shape<2>1226 %5 = fir.embox %arg0(%4) : (!fir.ref<!fir.array<10x10x!fir.logical<4>>>, !fir.shape<2>) -> !fir.box<!fir.array<10x10x!fir.logical<4>>>1227 %c4 = arith.constant 4 : index1228 %6 = fir.zero_bits !fir.heap<!fir.array<?xi32>>1229 %c0 = arith.constant 0 : index1230 %7 = fir.shape %c0 : (index) -> !fir.shape<1>1231 %8 = fir.embox %6(%7) : (!fir.heap<!fir.array<?xi32>>, !fir.shape<1>) -> !fir.box<!fir.heap<!fir.array<?xi32>>>1232 fir.store %8 to %0 : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>1233 %9 = fir.address_of(@_QQclX2E2F746573746661696C2E66393000) : !fir.ref<!fir.char<1,15>>1234 %c11_i32 = arith.constant 11 : i321235 %10 = fir.convert %0 : (!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>) -> !fir.ref<!fir.box<none>>1236 %11 = fir.convert %5 : (!fir.box<!fir.array<10x10x!fir.logical<4>>>) -> !fir.box<none>1237 %12 = fir.convert %c4 : (index) -> i321238 %13 = fir.convert %9 : (!fir.ref<!fir.char<1,15>>) -> !fir.ref<i8>1239 fir.call @_FortranACountDim(%10, %11, %c2_i32, %12, %13, %c11_i32) fastmath<contract> : (!fir.ref<!fir.box<none>>, !fir.box<none>, i32, i32, !fir.ref<i8>, i32) -> ()1240 %15 = fir.load %0 : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>1241 %c0_2 = arith.constant 0 : index1242 %16:3 = fir.box_dims %15, %c0_2 : (!fir.box<!fir.heap<!fir.array<?xi32>>>, index) -> (index, index, index)1243 %17 = fir.box_addr %15 : (!fir.box<!fir.heap<!fir.array<?xi32>>>) -> !fir.heap<!fir.array<?xi32>>1244 %18 = fir.shape_shift %16#0, %16#1 : (index, index) -> !fir.shapeshift<1>1245 %19 = fir.array_load %17(%18) : (!fir.heap<!fir.array<?xi32>>, !fir.shapeshift<1>) -> !fir.array<?xi32>1246 %c1 = arith.constant 1 : index1247 %c0_3 = arith.constant 0 : index1248 %20 = arith.subi %c10_1, %c1 : index1249 %21 = fir.do_loop %arg1 = %c0_3 to %20 step %c1 unordered iter_args(%arg2 = %3) -> (!fir.array<10xi32>) {1250 %23 = fir.array_fetch %19, %arg1 : (!fir.array<?xi32>, index) -> i321251 %24 = fir.array_update %arg2, %23, %arg1 : (!fir.array<10xi32>, i32, index) -> !fir.array<10xi32>1252 fir.result %24 : !fir.array<10xi32>1253 }1254 fir.array_merge_store %3, %21 to %1 : !fir.array<10xi32>, !fir.array<10xi32>, !fir.ref<!fir.array<10xi32>>1255 fir.freemem %17 : !fir.heap<!fir.array<?xi32>>1256 %22 = fir.load %1 : !fir.ref<!fir.array<10xi32>>1257 return %22 : !fir.array<10xi32>1258}1259func.func private @_FortranACountDim(!fir.ref<!fir.box<none>>, !fir.box<none>, i32, i32, !fir.ref<i8>, i32) -> () attributes {fir.runtime}1260 1261// CHECK-LABEL: func.func @_QMtestPcount_generate_mask(1262// CHECK-SAME: %[[A:.*]]: !fir.ref<!fir.array<10x10x!fir.logical<4>>> {fir.bindc_name = "mask"}) -> !fir.array<10xi32> {1263// CHECK-NOT: fir.call @_FortranACountDimLogical4_simplified({{.*}})1264// CHECK: fir.call @_FortranACountDim({{.*}}) fastmath<contract> : (!fir.ref<!fir.box<none>>, !fir.box<none>, i32, i32, !fir.ref<i8>, i32) -> ()1265// CHECK-NOT: fir.call @_FortranACountDimLogical4_simplified({{.*}})1266 1267// -----1268// Ensure count isn't simplified for unknown dimension arrays1269 1270func.func @_QPmc(%arg0: !fir.box<!fir.array<?x?x?x!fir.logical<4>>> {fir.bindc_name = "m"}) -> i32 {1271 %0 = fir.alloca i32 {bindc_name = "mc", uniq_name = "_QFmcEmc"}1272 %c0 = arith.constant 0 : index1273 %1 = fir.address_of(@_QQclX95529933117f47914fc21e220c1a0896) : !fir.ref<!fir.char<1,58>>1274 %c3_i32 = arith.constant 3 : i321275 %2 = fir.convert %arg0 : (!fir.box<!fir.array<?x?x?x!fir.logical<4>>>) -> !fir.box<none>1276 %3 = fir.convert %1 : (!fir.ref<!fir.char<1,58>>) -> !fir.ref<i8>1277 %4 = fir.convert %c0 : (index) -> i321278 %5 = fir.call @_FortranACount(%2, %3, %c3_i32, %4) fastmath<contract> : (!fir.box<none>, !fir.ref<i8>, i32, i32) -> i641279 %6 = fir.convert %5 : (i64) -> i321280 fir.store %6 to %0 : !fir.ref<i32>1281 %7 = fir.load %0 : !fir.ref<i32>1282 return %7 : i321283}1284func.func private @_FortranACount(!fir.box<none>, !fir.ref<i8>, i32, i32) -> i64 attributes {fir.runtime}1285 1286// CHECK-LABEL: func.func @_QPmc(1287// CHECK-SAME: %[[VAL_0:.*]]: !fir.box<!fir.array<?x?x?x!fir.logical<4>>> {fir.bindc_name = "m"}) -> i32 {1288// CHECK-NOT: fir.call @_FortranACountLogical4_simplified({{.*}})1289// CHECK: %[[RES:.*]] = fir.call @_FortranACount({{.*}}) fastmath<contract> : (!fir.box<none>, !fir.ref<i8>, i32, i32) -> i641290// CHECK-NOT: fir.call @_FortranACountLogical4_simplified({{.*}})1291 1292// -----1293// Ensure Any is simplified in correct usage1294 1295func.func @_QPtestAny_NoDimArg(%arg0: !fir.ref<!fir.array<10x!fir.logical<4>>> {fir.bindc_name = "a"}) -> !fir.logical<4> {1296 %c10 = arith.constant 10 : index1297 %0 = fir.alloca !fir.logical<4> {bindc_name = "testAny_NoDimArg", uniq_name = "_QFtestAny_NoDimArgEtestAny_NoDimArg"}1298 %1 = fir.shape %c10 : (index) -> !fir.shape<1>1299 %2 = fir.embox %arg0(%1) : (!fir.ref<!fir.array<10x!fir.logical<4>>>, !fir.shape<1>) -> !fir.box<!fir.array<10x!fir.logical<4>>>1300 %c1 = arith.constant 1 : index1301 %3 = fir.address_of(@_QQclX04ab56883945fd2c21a3b6d132f0bb37) : !fir.ref<!fir.char<1,48>>1302 %c3_i32 = arith.constant 3 : i321303 %4 = fir.convert %2 : (!fir.box<!fir.array<10x!fir.logical<4>>>) -> !fir.box<none>1304 %5 = fir.convert %3 : (!fir.ref<!fir.char<1,48>>) -> !fir.ref<i8>1305 %6 = fir.convert %c1 : (index) -> i321306 %7 = fir.call @_FortranAAny(%4, %5, %c3_i32, %6) fastmath<contract> : (!fir.box<none>, !fir.ref<i8>, i32, i32) -> i11307 %8 = fir.convert %7 : (i1) -> !fir.logical<4>1308 fir.store %8 to %0 : !fir.ref<!fir.logical<4>>1309 %9 = fir.load %0 : !fir.ref<!fir.logical<4>>1310 return %9 : !fir.logical<4>1311}1312func.func private @_FortranAAny(!fir.box<none>, !fir.ref<i8>, i32, i32) -> i1 attributes {fir.runtime}1313 1314// CHECK-LABEL: func.func @_QPtestAny_NoDimArg(1315// CHECK-SAME: %[[ARR:.*]]: !fir.ref<!fir.array<10x!fir.logical<4>>> {fir.bindc_name = "a"}) -> !fir.logical<4> {1316// CHECK: %[[SIZE:.*]] = arith.constant 10 : index1317// CHECK: %[[SHAPE:.*]] = fir.shape %[[SIZE]] : (index) -> !fir.shape<1>1318// CHECK: %[[A_BOX_LOGICAL:.*]] = fir.embox %[[ARR]](%[[SHAPE]]) : (!fir.ref<!fir.array<10x!fir.logical<4>>>, !fir.shape<1>) -> !fir.box<!fir.array<10x!fir.logical<4>>>1319// CHECK: %[[A_BOX_NONE:.*]] = fir.convert %[[A_BOX_LOGICAL]] : (!fir.box<!fir.array<10x!fir.logical<4>>>) -> !fir.box<none>1320// CHECK: %[[RES:.*]] = fir.call @_FortranAAnyLogical4x1_simplified(%[[A_BOX_NONE]]) fastmath<contract> : (!fir.box<none>) -> i11321// CHECK: }1322 1323// CHECK-LABEL: func.func private @_FortranAAnyLogical4x1_simplified(1324// CHECK-SAME: %[[ARR:.*]]: !fir.box<none>) -> i1 attributes {llvm.linkage = #llvm.linkage<linkonce_odr>} {1325// CHECK: %[[INIT_COND:.*]] = arith.constant true1326// CHECK: %[[C_INDEX0:.*]] = arith.constant 0 : index1327// CHECK: %[[A_BOX_I32:.*]] = fir.convert %[[ARR]] : (!fir.box<none>) -> !fir.box<!fir.array<?xi32>>1328// CHECK: %[[FALSE:.*]] = arith.constant false1329// CHECK: %[[C_INDEX1:.*]] = arith.constant 1 : index1330// CHECK: %[[DIM_IDX0:.*]] = arith.constant 0 : index1331// CHECK: %[[DIMS:.*]]:3 = fir.box_dims %[[A_BOX_I32]], %[[DIM_IDX0]] : (!fir.box<!fir.array<?xi32>>, index) -> (index, index, index)1332// CHECK: %[[EXTENT:.*]] = arith.subi %[[DIMS]]#1, %[[C_INDEX1]] : index1333// CHECK: %[[RES:.*]]:2 = fir.iterate_while (%[[ITER:.*]] = %[[C_INDEX0]] to %[[EXTENT]] step %[[C_INDEX1]]) and (%[[OK:.*]] = %[[INIT_COND]]) iter_args(%[[INIT:.*]] = %[[FALSE]]) -> (i1) {1334// CHECK: %[[ITEM:.*]] = fir.coordinate_of %[[A_BOX_I32]], %[[ITER]] : (!fir.box<!fir.array<?xi32>>, index) -> !fir.ref<i32>1335// CHECK: %[[ITEM_VAL:.*]] = fir.load %[[ITEM]] : !fir.ref<i32>1336// CHECK: %[[I32_0:.*]] = arith.constant 0 : i321337// CHECK: %[[CMP:.*]] = arith.cmpi ne, %[[ITEM_VAL]], %[[I32_0]] : i321338// CHECK: %[[I1_1:.*]] = arith.constant true1339// CHECK: %[[CONTINUE:.*]] = arith.xori %[[CMP]], %[[I1_1]] : i11340// CHECK: fir.result %[[CONTINUE]], %[[CMP]] : i1, i11341// CHECK: }1342// CHECK: return %[[RES:.*]]#1 : i11343// CHECK: }1344 1345// -----1346// Ensure Any is simpified correctly for different kind logical1347 1348func.func @_QPtestAny_NoDimArgLogical8(%arg0: !fir.ref<!fir.array<10x!fir.logical<8>>> {fir.bindc_name = "a"}) -> !fir.logical<8> {1349 %c10 = arith.constant 10 : index1350 %0 = fir.alloca !fir.logical<8> {bindc_name = "testAny_NoDimArgLogical8", uniq_name = "_QFtestAny_NoDimArgLogical8EtestAny_NoDimArgLogical8"}1351 %1 = fir.shape %c10 : (index) -> !fir.shape<1>1352 %2 = fir.embox %arg0(%1) : (!fir.ref<!fir.array<10x!fir.logical<8>>>, !fir.shape<1>) -> !fir.box<!fir.array<10x!fir.logical<8>>>1353 %c1 = arith.constant 1 : index1354 %3 = fir.address_of(@_QQclX04ab56883945fd2c21a3b6d132f0bb37) : !fir.ref<!fir.char<1,48>>1355 %c3_i32 = arith.constant 3 : i321356 %4 = fir.convert %2 : (!fir.box<!fir.array<10x!fir.logical<8>>>) -> !fir.box<none>1357 %5 = fir.convert %3 : (!fir.ref<!fir.char<1,48>>) -> !fir.ref<i8>1358 %6 = fir.convert %c1 : (index) -> i321359 %7 = fir.call @_FortranAAny(%4, %5, %c3_i32, %6) fastmath<contract> : (!fir.box<none>, !fir.ref<i8>, i32, i32) -> i11360 %8 = fir.convert %7 : (i1) -> !fir.logical<8>1361 fir.store %8 to %0 : !fir.ref<!fir.logical<8>>1362 %9 = fir.load %0 : !fir.ref<!fir.logical<8>>1363 return %9 : !fir.logical<8>1364}1365func.func private @_FortranAAny(!fir.box<none>, !fir.ref<i8>, i32, i32) -> i1 attributes {fir.runtime}1366 1367// CHECK-LABEL: func.func @_QPtestAny_NoDimArgLogical8(1368// CHECK-SAME: %[[ARR:.*]]: !fir.ref<!fir.array<10x!fir.logical<8>>> {fir.bindc_name = "a"}) -> !fir.logical<8> {1369// CHECK: %[[SIZE:.*]] = arith.constant 10 : index1370// CHECK: %[[SHAPE:.*]] = fir.shape %[[SIZE]] : (index) -> !fir.shape<1>1371// CHECK: %[[A_BOX_LOGICAL:.*]] = fir.embox %[[ARR]](%[[SHAPE]]) : (!fir.ref<!fir.array<10x!fir.logical<8>>>, !fir.shape<1>) -> !fir.box<!fir.array<10x!fir.logical<8>>>1372// CHECK: %[[A_BOX_NONE:.*]] = fir.convert %[[A_BOX_LOGICAL]] : (!fir.box<!fir.array<10x!fir.logical<8>>>) -> !fir.box<none>1373// CHECK: %[[RES:.*]] = fir.call @_FortranAAnyLogical8x1_simplified(%[[A_BOX_NONE]]) fastmath<contract> : (!fir.box<none>) -> i11374// CHECK: }1375 1376// CHECK-LABEL: func.func private @_FortranAAnyLogical8x1_simplified(1377// CHECK-SAME: %[[ARR:.*]]: !fir.box<none>) -> i1 attributes {llvm.linkage = #llvm.linkage<linkonce_odr>} {1378// CHECK: %[[INIT_COND:.*]] = arith.constant true1379// CHECK: %[[C_INDEX0:.*]] = arith.constant 0 : index1380// CHECK: %[[A_BOX_I64:.*]] = fir.convert %[[ARR]] : (!fir.box<none>) -> !fir.box<!fir.array<?xi64>>1381// CHECK: %[[FALSE:.*]] = arith.constant false1382// CHECK: %[[C_INDEX1:.*]] = arith.constant 1 : index1383// CHECK: %[[DIM_IDX0:.*]] = arith.constant 0 : index1384// CHECK: %[[DIMS:.*]]:3 = fir.box_dims %[[A_BOX_I64]], %[[DIM_IDX0]] : (!fir.box<!fir.array<?xi64>>, index) -> (index, index, index)1385// CHECK: %[[EXTENT:.*]] = arith.subi %[[DIMS]]#1, %[[C_INDEX1]] : index1386// CHECK: %[[RES:.*]]:2 = fir.iterate_while (%[[ITER:.*]] = %[[C_INDEX0]] to %[[EXTENT]] step %[[C_INDEX1]]) and (%[[OK:.*]] = %[[INIT_COND]]) iter_args(%[[INIT:.*]] = %[[FALSE]]) -> (i1) {1387// CHECK: %[[ITEM:.*]] = fir.coordinate_of %[[A_BOX_I64]], %[[ITER]] : (!fir.box<!fir.array<?xi64>>, index) -> !fir.ref<i64>1388// CHECK: %[[ITEM_VAL:.*]] = fir.load %[[ITEM]] : !fir.ref<i64>1389// CHECK: %[[I64_0:.*]] = arith.constant 0 : i641390// CHECK: %[[CMP:.*]] = arith.cmpi ne, %[[ITEM_VAL]], %[[I64_0]] : i641391// CHECK: %[[I1_1:.*]] = arith.constant true1392// CHECK: %[[CONTINUE:.*]] = arith.xori %[[CMP]], %[[I1_1]] : i11393// CHECK: fir.result %[[CONTINUE]], %[[CMP]] : i1, i11394// CHECK: }1395// CHECK: return %[[RES:.*]]#1 : i11396// CHECK: }1397 1398// -----1399// Ensure Any is not simplified when call ends in 'Dim'1400 1401func.func @_QPtestAny_DimArg(%arg0: !fir.ref<!fir.array<10x10x!fir.logical<4>>> {fir.bindc_name = "a"}) -> !fir.array<10x!fir.logical<4>> {1402 %0 = fir.alloca !fir.box<!fir.heap<!fir.array<?x!fir.logical<4>>>>1403 %c10 = arith.constant 10 : index1404 %c10_0 = arith.constant 10 : index1405 %c10_1 = arith.constant 10 : index1406 %1 = fir.alloca !fir.array<10x!fir.logical<4>> {bindc_name = "testAny_DimArg", uniq_name = "_QFtestAny_DimArgEtestAny_DimArg"}1407 %2 = fir.shape %c10_1 : (index) -> !fir.shape<1>1408 %3 = fir.array_load %1(%2) : (!fir.ref<!fir.array<10x!fir.logical<4>>>, !fir.shape<1>) -> !fir.array<10x!fir.logical<4>>1409 %c2_i32 = arith.constant 2 : i321410 %4 = fir.shape %c10, %c10_0 : (index, index) -> !fir.shape<2>1411 %5 = fir.embox %arg0(%4) : (!fir.ref<!fir.array<10x10x!fir.logical<4>>>, !fir.shape<2>) -> !fir.box<!fir.array<10x10x!fir.logical<4>>>1412 %6 = fir.zero_bits !fir.heap<!fir.array<?x!fir.logical<4>>>1413 %c0 = arith.constant 0 : index1414 %7 = fir.shape %c0 : (index) -> !fir.shape<1>1415 %8 = fir.embox %6(%7) : (!fir.heap<!fir.array<?x!fir.logical<4>>>, !fir.shape<1>) -> !fir.box<!fir.heap<!fir.array<?x!fir.logical<4>>>>1416 fir.store %8 to %0 : !fir.ref<!fir.box<!fir.heap<!fir.array<?x!fir.logical<4>>>>>1417 %9 = fir.address_of(@_QQclX04ab56883945fd2c21a3b6d132f0bb37) : !fir.ref<!fir.char<1,48>>1418 %c3_i32 = arith.constant 3 : i321419 %10 = fir.convert %0 : (!fir.ref<!fir.box<!fir.heap<!fir.array<?x!fir.logical<4>>>>>) -> !fir.ref<!fir.box<none>>1420 %11 = fir.convert %5 : (!fir.box<!fir.array<10x10x!fir.logical<4>>>) -> !fir.box<none>1421 %12 = fir.convert %9 : (!fir.ref<!fir.char<1,48>>) -> !fir.ref<i8>1422 fir.call @_FortranAAnyDim(%10, %11, %c2_i32, %12, %c3_i32) fastmath<contract> : (!fir.ref<!fir.box<none>>, !fir.box<none>, i32, !fir.ref<i8>, i32) -> ()1423 %14 = fir.load %0 : !fir.ref<!fir.box<!fir.heap<!fir.array<?x!fir.logical<4>>>>>1424 %c0_2 = arith.constant 0 : index1425 %15:3 = fir.box_dims %14, %c0_2 : (!fir.box<!fir.heap<!fir.array<?x!fir.logical<4>>>>, index) -> (index, index, index)1426 %16 = fir.box_addr %14 : (!fir.box<!fir.heap<!fir.array<?x!fir.logical<4>>>>) -> !fir.heap<!fir.array<?x!fir.logical<4>>>1427 %17 = fir.shape_shift %15#0, %15#1 : (index, index) -> !fir.shapeshift<1>1428 %18 = fir.array_load %16(%17) : (!fir.heap<!fir.array<?x!fir.logical<4>>>, !fir.shapeshift<1>) -> !fir.array<?x!fir.logical<4>>1429 %c1 = arith.constant 1 : index1430 %c0_3 = arith.constant 0 : index1431 %19 = arith.subi %c10_1, %c1 : index1432 %20 = fir.do_loop %arg1 = %c0_3 to %19 step %c1 unordered iter_args(%arg2 = %3) -> (!fir.array<10x!fir.logical<4>>) {1433 %22 = fir.array_fetch %18, %arg1 : (!fir.array<?x!fir.logical<4>>, index) -> !fir.logical<4>1434 %23 = fir.array_update %arg2, %22, %arg1 : (!fir.array<10x!fir.logical<4>>, !fir.logical<4>, index) -> !fir.array<10x!fir.logical<4>>1435 fir.result %23 : !fir.array<10x!fir.logical<4>>1436 }1437 fir.array_merge_store %3, %20 to %1 : !fir.array<10x!fir.logical<4>>, !fir.array<10x!fir.logical<4>>, !fir.ref<!fir.array<10x!fir.logical<4>>>1438 fir.freemem %16 : !fir.heap<!fir.array<?x!fir.logical<4>>>1439 %21 = fir.load %1 : !fir.ref<!fir.array<10x!fir.logical<4>>>1440 return %21 : !fir.array<10x!fir.logical<4>>1441}1442func.func private @_FortranAAnyDim(!fir.ref<!fir.box<none>>, !fir.box<none>, i32, !fir.ref<i8>, i32) -> () attributes {fir.runtime}1443 1444// CHECK-LABEL: func.func @_QPtestAny_DimArg(1445// CHECK-SAME: %[[ARR:.*]]: !fir.ref<!fir.array<10x10x!fir.logical<4>>> {fir.bindc_name = "a"}) -> !fir.array<10x!fir.logical<4>> {1446// CHECK-NOT: fir.call @_FortranAAnyDimLogical4x1_simplified({{.*}})1447// CHECK: fir.call @_FortranAAnyDim({{.*}}) fastmath<contract> : (!fir.ref<!fir.box<none>>, !fir.box<none>, i32, !fir.ref<i8>, i32) -> ()1448// CHECK-NOT: fir.call @_FortranAAnyDimLogical4x1_simplified({{.*}})1449 1450// -----1451// Ensure Any is not simplified for unknown dimension arrays1452 1453func.func @_QPtestAny_UnknownDim(%arg0: !fir.box<!fir.array<?x!fir.logical<4>>> {fir.bindc_name = "a"}) -> !fir.logical<4> {1454 %0 = fir.alloca !fir.logical<4> {bindc_name = "testAny_UnknownDim", uniq_name = "_QFtestAny_UnknownDimEtestAny_UnknownDim"}1455 %c1 = arith.constant 1 : index1456 %1 = fir.address_of(@_QQclX04ab56883945fd2c21a3b6d132f0bb37) : !fir.ref<!fir.char<1,48>>1457 %c3_i32 = arith.constant 3 : i321458 %2 = fir.convert %arg0 : (!fir.box<!fir.array<?x!fir.logical<4>>>) -> !fir.box<none>1459 %3 = fir.convert %1 : (!fir.ref<!fir.char<1,48>>) -> !fir.ref<i8>1460 %4 = fir.convert %c1 : (index) -> i321461 %5 = fir.call @_FortranAAny(%2, %3, %c3_i32, %4) fastmath<contract> : (!fir.box<none>, !fir.ref<i8>, i32, i32) -> i11462 %6 = fir.convert %5 : (i1) -> !fir.logical<4>1463 fir.store %6 to %0 : !fir.ref<!fir.logical<4>>1464 %7 = fir.load %0 : !fir.ref<!fir.logical<4>>1465 return %7 : !fir.logical<4>1466}1467func.func private @_FortranAAny(!fir.box<none>, !fir.ref<i8>, i32, i32) -> i1 attributes {fir.runtime}1468 1469// CHECK-LABEL: func.func @_QPtestAny_UnknownDim(1470// CHECK-SAME: %[[VAL_0:.*]]: !fir.box<!fir.array<?x!fir.logical<4>>> {fir.bindc_name = "a"}) -> !fir.logical<4> {1471// CHECK-NOT: fir.call @_FortranAAnyLogical4x1_simplified({{.*}})1472// CHECK: fir.call @_FortranAAny({{.*}}) fastmath<contract> : (!fir.box<none>, !fir.ref<i8>, i32, i32) -> i11473// CHECK-NOT: fir.call @_FortranAAnyLogical4x1_simplified({{.*}})1474 1475// -----1476// Check that multi-rank Any cases are properly simplified1477 1478func.func @_QPtestAny_2D(%arg0: !fir.ref<!fir.array<10x0x!fir.logical<4>>> {fir.bindc_name = "a"}) -> !fir.logical<4> {1479 %c10 = arith.constant 10 : index1480 %c0 = arith.constant 0 : index1481 %0 = fir.alloca !fir.logical<4> {bindc_name = "testAny_2D", uniq_name = "_QFtestAny_2DEtestAny_2D"}1482 %1 = fir.shape %c10, %c0 : (index, index) -> !fir.shape<2>1483 %2 = fir.embox %arg0(%1) : (!fir.ref<!fir.array<10x0x!fir.logical<4>>>, !fir.shape<2>) -> !fir.box<!fir.array<10x0x!fir.logical<4>>>1484 %c1 = arith.constant 1 : index1485 %3 = fir.address_of(@_QQclX04ab56883945fd2c21a3b6d132f0bb37) : !fir.ref<!fir.char<1,48>>1486 %c3_i32 = arith.constant 3 : i321487 %4 = fir.convert %2 : (!fir.box<!fir.array<10x0x!fir.logical<4>>>) -> !fir.box<none>1488 %5 = fir.convert %3 : (!fir.ref<!fir.char<1,48>>) -> !fir.ref<i8>1489 %6 = fir.convert %c1 : (index) -> i321490 %7 = fir.call @_FortranAAny(%4, %5, %c3_i32, %6) fastmath<contract> : (!fir.box<none>, !fir.ref<i8>, i32, i32) -> i11491 %8 = fir.convert %7 : (i1) -> !fir.logical<4>1492 fir.store %8 to %0 : !fir.ref<!fir.logical<4>>1493 %9 = fir.load %0 : !fir.ref<!fir.logical<4>>1494 return %9 : !fir.logical<4>1495 }1496 1497// CHECK-LABEL: func.func @_QPtestAny_2D(1498// CHECK-SAME: %[[A:.*]]: !fir.ref<!fir.array<10x0x!fir.logical<4>>> {fir.bindc_name = "a"}) -> !fir.logical<4> {1499// CHECK: %[[SIZE10:.*]] = arith.constant 10 : index1500// CHECK: %[[SIZE_0:.*]] = arith.constant 0 : index1501// CHECK: %[[SHAPE:.*]] = fir.shape %[[SIZE10]], %[[SIZE_0]] : (index, index) -> !fir.shape<2>1502// CHECK: %[[A_BOX_LOGICAL:.*]] = fir.embox %[[VAL_0]](%[[SHAPE]]) : (!fir.ref<!fir.array<10x0x!fir.logical<4>>>, !fir.shape<2>) -> !fir.box<!fir.array<10x0x!fir.logical<4>>>1503// CHECK: %[[A_BOX_NONE:.*]] = fir.convert %[[A_BOX_LOGICAL]] : (!fir.box<!fir.array<10x0x!fir.logical<4>>>) -> !fir.box<none>1504// CHECK: %[[RES:.*]] = fir.call @_FortranAAnyLogical4x2_simplified(%[[A_BOX_NONE]]) fastmath<contract> : (!fir.box<none>) -> i11505 1506// CHECK-LABEL: func.func private @_FortranAAnyLogical4x2_simplified(1507// CHECK-SAME: %[[ARR:.*]]: !fir.box<none>) -> i1 attributes {llvm.linkage = #llvm.linkage<linkonce_odr>} {1508// CHECK: %[[TRUE:.*]] = arith.constant true1509// CHECK: %[[CINDEX_0:.*]] = arith.constant 0 : index1510// CHECK: %[[A_BOX_I32:.*]] = fir.convert %[[VAL_0]] : (!fir.box<none>) -> !fir.box<!fir.array<?x?xi32>>1511// CHECK: %[[FALSE:.*]] = arith.constant false1512// CHECK: %[[CINDEX_1:.*]] = arith.constant 1 : index1513// CHECK: %[[DIMINDEX_0:.*]] = arith.constant 0 : index1514// CHECK: %[[DIMS:.*]]:3 = fir.box_dims %[[A_BOX_I32]], %[[DIMINDEX_0]] : (!fir.box<!fir.array<?x?xi32>>, index) -> (index, index, index)1515// CHECK: %[[EXTENT:.*]] = arith.subi %[[DIMS]]#1, %[[CINDEX_1]] : index1516// CHECK: %[[DIMINDEX_1:.*]] = arith.constant 1 : index1517// CHECK: %[[DIMS_1:.*]]:3 = fir.box_dims %[[A_BOX_I32]], %[[DIMINDEX_1]] : (!fir.box<!fir.array<?x?xi32>>, index) -> (index, index, index)1518// CHECK: %[[EXTENT1:.*]] = arith.subi %[[DIMS_1]]#1, %[[CINDEX_1]] : index1519// CHECK: %[[RES:.*]]:2 = fir.iterate_while (%[[ITER:.*]] = %[[CINDEX_0]] to %[[EXTENT1]] step %[[CINDEX_1]]) and (%[[OK:.*]] = %[[TRUE]]) iter_args(%[[INIT:.*]] = %[[FALSE]]) -> (i1) {1520// CHECK: %[[INNER_RES:.*]]:2 = fir.iterate_while (%[[ITER_1:.*]] = %[[CINDEX_0]] to %[[EXTENT]] step %[[CINDEX_1]]) and (%[[OK1:.*]] = %[[TRUE]]) iter_args(%[[INNER_INIT:.*]] = %[[INIT]]) -> (i1) {1521// CHECK: %[[ITEM:.*]] = fir.coordinate_of %[[A_BOX_I32]], %[[ITER_1]], %[[ITER]] : (!fir.box<!fir.array<?x?xi32>>, index, index) -> !fir.ref<i32>1522// CHECK: %[[ITEMVAL:.*]] = fir.load %[[ITEM]] : !fir.ref<i32>1523// CHECK: %[[I32_0:.*]] = arith.constant 0 : i321524// CHECK: %[[NEXT_ANY:.*]] = arith.cmpi ne, %[[ITEMVAL]], %[[I32_0]] : i321525// CHECK: %[[I1_1:.*]] = arith.constant true1526// CHECK: %[[CONTINUE:.*]] = arith.xori %[[NEXT_ANY]], %[[I1_1]] : i11527// CHECK: fir.result %[[CONTINUE]], %[[NEXT_ANY]] : i1, i11528// CHECK: }1529// CHECK: fir.result %[[RETURN_VALS:.*]]#0, %[[RETURN_VALS]]#1 : i1, i11530// CHECK: }1531// CHECK: return %[[RETURN_VAL:.*]]#1 : i11532// CHECK: }1533 1534// -----1535// Ensure All is simplified in correct usage1536 1537func.func @_QPtestAll_NoDimArg(%arg0: !fir.ref<!fir.array<10x!fir.logical<4>>> {fir.bindc_name = "a"}) -> !fir.logical<4> {1538 %c10 = arith.constant 10 : index1539 %0 = fir.alloca !fir.logical<4> {bindc_name = "testAll_NoDimArg", uniq_name = "_QFtestAll_NoDimArgEtestAll_NoDimArg"}1540 %1 = fir.shape %c10 : (index) -> !fir.shape<1>1541 %2 = fir.embox %arg0(%1) : (!fir.ref<!fir.array<10x!fir.logical<4>>>, !fir.shape<1>) -> !fir.box<!fir.array<10x!fir.logical<4>>>1542 %c1 = arith.constant 1 : index1543 %3 = fir.address_of(@_QQclX04ab56883945fd2c21a3b6d132f0bb37) : !fir.ref<!fir.char<1,48>>1544 %c3_i32 = arith.constant 3 : i321545 %4 = fir.convert %2 : (!fir.box<!fir.array<10x!fir.logical<4>>>) -> !fir.box<none>1546 %5 = fir.convert %3 : (!fir.ref<!fir.char<1,48>>) -> !fir.ref<i8>1547 %6 = fir.convert %c1 : (index) -> i321548 %7 = fir.call @_FortranAAll(%4, %5, %c3_i32, %6) fastmath<contract> : (!fir.box<none>, !fir.ref<i8>, i32, i32) -> i11549 %8 = fir.convert %7 : (i1) -> !fir.logical<4>1550 fir.store %8 to %0 : !fir.ref<!fir.logical<4>>1551 %9 = fir.load %0 : !fir.ref<!fir.logical<4>>1552 return %9 : !fir.logical<4>1553}1554func.func private @_FortranAAll(!fir.box<none>, !fir.ref<i8>, i32, i32) -> i1 attributes {fir.runtime}1555 1556// CHECK-LABEL: func.func @_QPtestAll_NoDimArg(1557// CHECK-SAME: %[[ARR:.*]]: !fir.ref<!fir.array<10x!fir.logical<4>>> {fir.bindc_name = "a"}) -> !fir.logical<4> {1558// CHECK: %[[SIZE:.*]] = arith.constant 10 : index1559// CHECK: %[[SHAPE:.*]] = fir.shape %[[SIZE]] : (index) -> !fir.shape<1>1560// CHECK: %[[A_BOX_LOGICAL:.*]] = fir.embox %[[ARR]](%[[SHAPE]]) : (!fir.ref<!fir.array<10x!fir.logical<4>>>, !fir.shape<1>) -> !fir.box<!fir.array<10x!fir.logical<4>>>1561// CHECK: %[[A_BOX_NONE:.*]] = fir.convert %[[A_BOX_LOGICAL]] : (!fir.box<!fir.array<10x!fir.logical<4>>>) -> !fir.box<none>1562// CHECK: %[[RES:.*]] = fir.call @_FortranAAllLogical4x1_simplified(%[[A_BOX_NONE]]) fastmath<contract> : (!fir.box<none>) -> i11563// CHECK: }1564 1565// CHECK-LABEL: func.func private @_FortranAAllLogical4x1_simplified(1566// CHECK-SAME: %[[ARR:.*]]: !fir.box<none>) -> i1 attributes {llvm.linkage = #llvm.linkage<linkonce_odr>} {1567// CHECK: %[[INIT_COND:.*]] = arith.constant true1568// CHECK: %[[C_INDEX0:.*]] = arith.constant 0 : index1569// CHECK: %[[A_BOX_I32:.*]] = fir.convert %[[ARR]] : (!fir.box<none>) -> !fir.box<!fir.array<?xi32>>1570// CHECK: %[[TRUE:.*]] = arith.constant true1571// CHECK: %[[C_INDEX1:.*]] = arith.constant 1 : index1572// CHECK: %[[DIM_INDEX0:.*]] = arith.constant 0 : index1573// CHECK: %[[DIMS:.*]]:3 = fir.box_dims %[[A_BOX_I32]], %[[DIM_INDEX0]] : (!fir.box<!fir.array<?xi32>>, index) -> (index, index, index)1574// CHECK: %[[EXTENT:.*]] = arith.subi %[[DIMS]]#1, %[[C_INDEX1]] : index1575// CHECK: %[[RES:.*]]:2 = fir.iterate_while (%[[ITER:.*]] = %[[C_INDEX0]] to %[[EXTENT]] step %[[C_INDEX1]]) and (%[[OK:.*]] = %[[INIT_COND]]) iter_args(%[[INIT:.*]] = %[[TRUE]]) -> (i1) {1576// CHECK: %[[ITEM:.*]] = fir.coordinate_of %[[A_BOX_I32]], %[[ITER]] : (!fir.box<!fir.array<?xi32>>, index) -> !fir.ref<i32>1577// CHECK: %[[ITEM_VAL:.*]] = fir.load %[[ITEM]] : !fir.ref<i32>1578// CHECK: %[[I32_0:.*]] = arith.constant 0 : i321579// CHECK: %[[CMP_AND_CONTINUE:.*]] = arith.cmpi ne, %[[ITEM_VAL]], %[[I32_0]] : i321580// CHECK: fir.result %[[CMP_AND_CONTINUE]], %[[CMP_AND_CONTINUE]] : i1, i11581// CHECK: }1582// CHECK: return %[[RES:.*]]#1 : i11583// CHECK: }1584 1585// -----1586// Ensure All is correctly simplified for different kind logical1587 1588func.func @_QPtestAll_NoDimArgLogical1(%arg0: !fir.ref<!fir.array<10x!fir.logical<1>>> {fir.bindc_name = "a"}) -> !fir.logical<1> {1589 %c10 = arith.constant 10 : index1590 %0 = fir.alloca !fir.logical<1> {bindc_name = "testAll_NoDimArgLogical1", uniq_name = "_QFtestAll_NoDimArgLogical1EtestAll_NoDimArgLogical1"}1591 %1 = fir.shape %c10 : (index) -> !fir.shape<1>1592 %2 = fir.embox %arg0(%1) : (!fir.ref<!fir.array<10x!fir.logical<1>>>, !fir.shape<1>) -> !fir.box<!fir.array<10x!fir.logical<1>>>1593 %c1 = arith.constant 1 : index1594 %3 = fir.address_of(@_QQclX04ab56883945fd2c21a3b6d132f0bb37) : !fir.ref<!fir.char<1,48>>1595 %c3_i32 = arith.constant 3 : i321596 %4 = fir.convert %2 : (!fir.box<!fir.array<10x!fir.logical<1>>>) -> !fir.box<none>1597 %5 = fir.convert %3 : (!fir.ref<!fir.char<1,48>>) -> !fir.ref<i8>1598 %6 = fir.convert %c1 : (index) -> i321599 %7 = fir.call @_FortranAAll(%4, %5, %c3_i32, %6) fastmath<contract> : (!fir.box<none>, !fir.ref<i8>, i32, i32) -> i11600 %8 = fir.convert %7 : (i1) -> !fir.logical<1>1601 fir.store %8 to %0 : !fir.ref<!fir.logical<1>>1602 %9 = fir.load %0 : !fir.ref<!fir.logical<1>>1603 return %9 : !fir.logical<1>1604}1605func.func private @_FortranAAll(!fir.box<none>, !fir.ref<i8>, i32, i32) -> i1 attributes {fir.runtime}1606 1607// CHECK-LABEL: func.func @_QPtestAll_NoDimArgLogical1(1608// CHECK-SAME: %[[ARR:.*]]: !fir.ref<!fir.array<10x!fir.logical<1>>> {fir.bindc_name = "a"}) -> !fir.logical<1> {1609// CHECK: %[[SIZE:.*]] = arith.constant 10 : index1610// CHECK: %[[SHAPE:.*]] = fir.shape %[[SIZE]] : (index) -> !fir.shape<1>1611// CHECK: %[[A_BOX_LOGICAL:.*]] = fir.embox %[[ARR]](%[[SHAPE]]) : (!fir.ref<!fir.array<10x!fir.logical<1>>>, !fir.shape<1>) -> !fir.box<!fir.array<10x!fir.logical<1>>>1612// CHECK: %[[A_BOX_NONE:.*]] = fir.convert %[[A_BOX_LOGICAL]] : (!fir.box<!fir.array<10x!fir.logical<1>>>) -> !fir.box<none>1613// CHECK: %[[RES:.*]] = fir.call @_FortranAAllLogical1x1_simplified(%[[A_BOX_NONE]]) fastmath<contract> : (!fir.box<none>) -> i11614// CHECK: }1615 1616// CHECK-LABEL: func.func private @_FortranAAllLogical1x1_simplified(1617// CHECK-SAME: %[[ARR:.*]]: !fir.box<none>) -> i1 attributes {llvm.linkage = #llvm.linkage<linkonce_odr>} {1618// CHECK: %[[INIT_COND:.*]] = arith.constant true1619// CHECK: %[[C_INDEX0:.*]] = arith.constant 0 : index1620// CHECK: %[[A_BOX_I8:.*]] = fir.convert %[[ARR]] : (!fir.box<none>) -> !fir.box<!fir.array<?xi8>>1621// CHECK: %[[TRUE:.*]] = arith.constant true1622// CHECK: %[[C_INDEX1:.*]] = arith.constant 1 : index1623// CHECK: %[[DIM_INDEX0:.*]] = arith.constant 0 : index1624// CHECK: %[[DIMS:.*]]:3 = fir.box_dims %[[A_BOX_I8]], %[[DIM_INDEX0]] : (!fir.box<!fir.array<?xi8>>, index) -> (index, index, index)1625// CHECK: %[[EXTENT:.*]] = arith.subi %[[DIMS]]#1, %[[C_INDEX1]] : index1626// CHECK: %[[RES:.*]]:2 = fir.iterate_while (%[[ITER:.*]] = %[[C_INDEX0]] to %[[EXTENT]] step %[[C_INDEX1]]) and (%[[OK:.*]] = %[[INIT_COND]]) iter_args(%[[INIT:.*]] = %[[TRUE]]) -> (i1) {1627// CHECK: %[[ITEM:.*]] = fir.coordinate_of %[[A_BOX_I8]], %[[ITER]] : (!fir.box<!fir.array<?xi8>>, index) -> !fir.ref<i8>1628// CHECK: %[[ITEM_VAL:.*]] = fir.load %[[ITEM]] : !fir.ref<i8>1629// CHECK: %[[I8_0:.*]] = arith.constant 0 : i81630// CHECK: %[[CMP_AND_CONTINUE:.*]] = arith.cmpi ne, %[[ITEM_VAL]], %[[I8_0]] : i81631// CHECK: fir.result %[[CMP_AND_CONTINUE]], %[[CMP_AND_CONTINUE]] : i1, i11632// CHECK: }1633// CHECK: return %[[RES:.*]]#1 : i11634// CHECK: }1635 1636 1637// -----1638// Ensure All is not simplified when call ends in 'Dim'1639 1640func.func @_QPtestAll_DimArg(%arg0: !fir.ref<!fir.array<10x10x!fir.logical<4>>> {fir.bindc_name = "a"}) -> !fir.array<10x!fir.logical<4>> {1641 %0 = fir.alloca !fir.box<!fir.heap<!fir.array<?x!fir.logical<4>>>>1642 %c10 = arith.constant 10 : index1643 %c10_0 = arith.constant 10 : index1644 %c10_1 = arith.constant 10 : index1645 %1 = fir.alloca !fir.array<10x!fir.logical<4>> {bindc_name = "testAll_DimArg", uniq_name = "_QFtestAll_DimArgEtestAll_DimArg"}1646 %2 = fir.shape %c10_1 : (index) -> !fir.shape<1>1647 %3 = fir.array_load %1(%2) : (!fir.ref<!fir.array<10x!fir.logical<4>>>, !fir.shape<1>) -> !fir.array<10x!fir.logical<4>>1648 %c1_i32 = arith.constant 1 : i321649 %4 = fir.shape %c10, %c10_0 : (index, index) -> !fir.shape<2>1650 %5 = fir.embox %arg0(%4) : (!fir.ref<!fir.array<10x10x!fir.logical<4>>>, !fir.shape<2>) -> !fir.box<!fir.array<10x10x!fir.logical<4>>>1651 %6 = fir.zero_bits !fir.heap<!fir.array<?x!fir.logical<4>>>1652 %c0 = arith.constant 0 : index1653 %7 = fir.shape %c0 : (index) -> !fir.shape<1>1654 %8 = fir.embox %6(%7) : (!fir.heap<!fir.array<?x!fir.logical<4>>>, !fir.shape<1>) -> !fir.box<!fir.heap<!fir.array<?x!fir.logical<4>>>>1655 fir.store %8 to %0 : !fir.ref<!fir.box<!fir.heap<!fir.array<?x!fir.logical<4>>>>>1656 %9 = fir.address_of(@_QQclX04ab56883945fd2c21a3b6d132f0bb37) : !fir.ref<!fir.char<1,48>>1657 %c3_i32 = arith.constant 3 : i321658 %10 = fir.convert %0 : (!fir.ref<!fir.box<!fir.heap<!fir.array<?x!fir.logical<4>>>>>) -> !fir.ref<!fir.box<none>>1659 %11 = fir.convert %5 : (!fir.box<!fir.array<10x10x!fir.logical<4>>>) -> !fir.box<none>1660 %12 = fir.convert %9 : (!fir.ref<!fir.char<1,48>>) -> !fir.ref<i8>1661 fir.call @_FortranAAllDim(%10, %11, %c1_i32, %12, %c3_i32) fastmath<contract> : (!fir.ref<!fir.box<none>>, !fir.box<none>, i32, !fir.ref<i8>, i32) -> ()1662 %14 = fir.load %0 : !fir.ref<!fir.box<!fir.heap<!fir.array<?x!fir.logical<4>>>>>1663 %c0_2 = arith.constant 0 : index1664 %15:3 = fir.box_dims %14, %c0_2 : (!fir.box<!fir.heap<!fir.array<?x!fir.logical<4>>>>, index) -> (index, index, index)1665 %16 = fir.box_addr %14 : (!fir.box<!fir.heap<!fir.array<?x!fir.logical<4>>>>) -> !fir.heap<!fir.array<?x!fir.logical<4>>>1666 %17 = fir.shape_shift %15#0, %15#1 : (index, index) -> !fir.shapeshift<1>1667 %18 = fir.array_load %16(%17) : (!fir.heap<!fir.array<?x!fir.logical<4>>>, !fir.shapeshift<1>) -> !fir.array<?x!fir.logical<4>>1668 %c1 = arith.constant 1 : index1669 %c0_3 = arith.constant 0 : index1670 %19 = arith.subi %c10_1, %c1 : index1671 %20 = fir.do_loop %arg1 = %c0_3 to %19 step %c1 unordered iter_args(%arg2 = %3) -> (!fir.array<10x!fir.logical<4>>) {1672 %22 = fir.array_fetch %18, %arg1 : (!fir.array<?x!fir.logical<4>>, index) -> !fir.logical<4>1673 %23 = fir.array_update %arg2, %22, %arg1 : (!fir.array<10x!fir.logical<4>>, !fir.logical<4>, index) -> !fir.array<10x!fir.logical<4>>1674 fir.result %23 : !fir.array<10x!fir.logical<4>>1675 }1676 fir.array_merge_store %3, %20 to %1 : !fir.array<10x!fir.logical<4>>, !fir.array<10x!fir.logical<4>>, !fir.ref<!fir.array<10x!fir.logical<4>>>1677 fir.freemem %16 : !fir.heap<!fir.array<?x!fir.logical<4>>>1678 %21 = fir.load %1 : !fir.ref<!fir.array<10x!fir.logical<4>>>1679 return %21 : !fir.array<10x!fir.logical<4>>1680}1681func.func private @_FortranAAllDim(!fir.ref<!fir.box<none>>, !fir.box<none>, i32, !fir.ref<i8>, i32) -> () attributes {fir.runtime}1682 1683// CHECK-LABEL: func.func @_QPtestAll_DimArg(1684// CHECK-SAME: %[[ARR:.*]]: !fir.ref<!fir.array<10x10x!fir.logical<4>>> {fir.bindc_name = "a"}) -> !fir.array<10x!fir.logical<4>> {1685// CHECK-NOT: fir.call @_FortranAAllDimLogical4x1_simplified({{.*}})1686// CHECK: fir.call @_FortranAAllDim({{.*}}) fastmath<contract> : (!fir.ref<!fir.box<none>>, !fir.box<none>, i32, !fir.ref<i8>, i32) -> ()1687// CHECK-NOT: fir.call @_FortranAAllDimLogical4x1_simplified({{.*}})1688 1689// -----1690// Check Minloc simplifies correctly for 1D case with 1D mask, I32 input1691func.func @_QPtestminloc_works1d(%arg0: !fir.ref<!fir.array<10xi32>> {fir.bindc_name = "a"}, %arg1: !fir.ref<!fir.array<10x!fir.logical<4>>> {fir.bindc_name = "b"}) -> !fir.array<1xi32> {1692 %0 = fir.alloca !fir.box<!fir.heap<!fir.array<?xi32>>>1693 %c10 = arith.constant 10 : index1694 %c10_0 = arith.constant 10 : index1695 %c1 = arith.constant 1 : index1696 %1 = fir.alloca !fir.array<1xi32> {bindc_name = "testminloc_works1d", uniq_name = "_QFtestminloc_works1dEtestminloc_works1d"}1697 %2 = fir.shape %c1 : (index) -> !fir.shape<1>1698 %3 = fir.array_load %1(%2) : (!fir.ref<!fir.array<1xi32>>, !fir.shape<1>) -> !fir.array<1xi32>1699 %4 = fir.shape %c10 : (index) -> !fir.shape<1>1700 %5 = fir.embox %arg0(%4) : (!fir.ref<!fir.array<10xi32>>, !fir.shape<1>) -> !fir.box<!fir.array<10xi32>>1701 %6 = fir.shape %c10_0 : (index) -> !fir.shape<1>1702 %7 = fir.embox %arg1(%6) : (!fir.ref<!fir.array<10x!fir.logical<4>>>, !fir.shape<1>) -> !fir.box<!fir.array<10x!fir.logical<4>>>1703 %c4 = arith.constant 4 : index1704 %false = arith.constant false1705 %8 = fir.zero_bits !fir.heap<!fir.array<?xi32>>1706 %c0 = arith.constant 0 : index1707 %9 = fir.shape %c0 : (index) -> !fir.shape<1>1708 %10 = fir.embox %8(%9) : (!fir.heap<!fir.array<?xi32>>, !fir.shape<1>) -> !fir.box<!fir.heap<!fir.array<?xi32>>>1709 fir.store %10 to %0 : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>1710 %11 = fir.address_of(@_QQclXea5bcf7f706678e1796661f8916f3379) : !fir.ref<!fir.char<1,55>>1711 %c5_i32 = arith.constant 5 : i321712 %12 = fir.convert %0 : (!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>) -> !fir.ref<!fir.box<none>>1713 %13 = fir.convert %5 : (!fir.box<!fir.array<10xi32>>) -> !fir.box<none>1714 %14 = fir.convert %c4 : (index) -> i321715 %15 = fir.convert %11 : (!fir.ref<!fir.char<1,55>>) -> !fir.ref<i8>1716 %16 = fir.convert %7 : (!fir.box<!fir.array<10x!fir.logical<4>>>) -> !fir.box<none>1717 fir.call @_FortranAMinlocInteger4(%12, %13, %14, %15, %c5_i32, %16, %false) fastmath<contract> : (!fir.ref<!fir.box<none>>, !fir.box<none>, i32, !fir.ref<i8>, i32, !fir.box<none>, i1) -> ()1718 %18 = fir.load %0 : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>1719 %c0_1 = arith.constant 0 : index1720 %19:3 = fir.box_dims %18, %c0_1 : (!fir.box<!fir.heap<!fir.array<?xi32>>>, index) -> (index, index, index)1721 %20 = fir.box_addr %18 : (!fir.box<!fir.heap<!fir.array<?xi32>>>) -> !fir.heap<!fir.array<?xi32>>1722 %21 = fir.shape_shift %19#0, %19#1 : (index, index) -> !fir.shapeshift<1>1723 %22 = fir.array_load %20(%21) : (!fir.heap<!fir.array<?xi32>>, !fir.shapeshift<1>) -> !fir.array<?xi32>1724 %c1_2 = arith.constant 1 : index1725 %c0_3 = arith.constant 0 : index1726 %23 = arith.subi %c1, %c1_2 : index1727 %24 = fir.do_loop %arg2 = %c0_3 to %23 step %c1_2 unordered iter_args(%arg3 = %3) -> (!fir.array<1xi32>) {1728 %26 = fir.array_fetch %22, %arg2 : (!fir.array<?xi32>, index) -> i321729 %27 = fir.array_update %arg3, %26, %arg2 : (!fir.array<1xi32>, i32, index) -> !fir.array<1xi32>1730 fir.result %27 : !fir.array<1xi32>1731 }1732 fir.array_merge_store %3, %24 to %1 : !fir.array<1xi32>, !fir.array<1xi32>, !fir.ref<!fir.array<1xi32>>1733 fir.freemem %20 : !fir.heap<!fir.array<?xi32>>1734 %25 = fir.load %1 : !fir.ref<!fir.array<1xi32>>1735 return %25 : !fir.array<1xi32>1736}1737 1738// CHECK-LABEL: func.func @_QPtestminloc_works1d(1739// CHECK-SAME: %[[INARR:.*]]: !fir.ref<!fir.array<10xi32>> {fir.bindc_name = "a"},1740// CHECK-SAME: %[[MASK:.*]]: !fir.ref<!fir.array<10x!fir.logical<4>>> {fir.bindc_name = "b"}) -> !fir.array<1xi32> {1741// CHECK: %[[OUTARR:.*]] = fir.alloca !fir.box<!fir.heap<!fir.array<?xi32>>>1742// CHECK: %[[SIZE10_0:.*]] = arith.constant 10 : index1743// CHECK: %[[SIZE10_1:.*]] = arith.constant 10 : index1744// CHECK: %[[INARR_SHAPE:.*]] = fir.shape %[[SIZE10_0]] : (index) -> !fir.shape<1>1745// CHECK: %[[BOX_INARR:.*]] = fir.embox %[[INARR]](%[[INARR_SHAPE]]) : (!fir.ref<!fir.array<10xi32>>, !fir.shape<1>) -> !fir.box<!fir.array<10xi32>>1746// CHECK: %[[MASK_SHAPE:.*]] = fir.shape %[[SIZE10_1]] : (index) -> !fir.shape<1>1747// CHECK: %[[BOX_MASK:.*]] = fir.embox %[[MASK]](%[[MASK_SHAPE]]) : (!fir.ref<!fir.array<10x!fir.logical<4>>>, !fir.shape<1>) -> !fir.box<!fir.array<10x!fir.logical<4>>>1748// CHECK: %[[REF_BOX_OUTARR_NONE:.*]] = fir.convert %[[OUTARR]] : (!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>) -> !fir.ref<!fir.box<none>>1749// CHECK: %[[BOX_INARR_NONE:.*]] = fir.convert %[[BOX_INARR]] : (!fir.box<!fir.array<10xi32>>) -> !fir.box<none>1750// CHECK: %[[BOX_MASK_NONE:.*]] = fir.convert %[[BOX_MASK]] : (!fir.box<!fir.array<10x!fir.logical<4>>>) -> !fir.box<none>1751// CHECK: fir.call @_FortranAMinlocInteger4x1_Logical4x1_i32_contract_simplified(%[[REF_BOX_OUTARR_NONE]], %[[BOX_INARR_NONE]], %[[BOX_MASK_NONE]]) fastmath<contract> : (!fir.ref<!fir.box<none>>, !fir.box<none>, !fir.box<none>) -> ()1752 1753// CHECK-LABEL: func.func private @_FortranAMinlocInteger4x1_Logical4x1_i32_contract_simplified(1754// CHECK-SAME: %[[REF_BOX_OUTARR_NONE:.*]]: !fir.ref<!fir.box<none>>,1755// CHECK-SAME: %[[BOX_INARR_NONE:.*]]: !fir.box<none>,1756// CHECK-SAME: %[[BOX_MASK_NONE:.*]]: !fir.box<none>) attributes {llvm.linkage = #llvm.linkage<linkonce_odr>} {1757// CHECK: %[[FLAG_ALLOC:.*]] = fir.alloca i321758// CHECK: %[[INIT_OUT_IDX:.*]] = arith.constant 0 : i321759// CHECK: %[[OUTARR_SIZE:.*]] = arith.constant 1 : index1760// CHECK: %[[OUTARR:.*]] = fir.allocmem !fir.array<1xi32>1761// CHECK: %[[OUTARR_SHAPE:.*]] = fir.shape %[[OUTARR_SIZE]] : (index) -> !fir.shape<1>1762// CHECK: %[[BOX_OUTARR:.*]] = fir.embox %[[OUTARR]](%[[OUTARR_SHAPE]]) : (!fir.heap<!fir.array<1xi32>>, !fir.shape<1>) -> !fir.box<!fir.heap<!fir.array<1xi32>>>1763// CHECK: %[[BOX_MASK:.*]] = fir.convert %[[BOX_MASK_NONE]] : (!fir.box<none>) -> !fir.box<!fir.array<?x!fir.logical<4>>>1764// CHECK: %[[OUTARR_IDX0:.*]] = arith.constant 0 : index1765// CHECK: %[[OUTARR_ITEM0:.*]] = fir.coordinate_of %[[BOX_OUTARR]], %[[OUTARR_IDX0]] : (!fir.box<!fir.heap<!fir.array<1xi32>>>, index) -> !fir.ref<i32>1766// CHECK: fir.store %[[INIT_OUT_IDX]] to %[[OUTARR_ITEM0]] : !fir.ref<i32>1767// CHECK: %[[CINDEX_0:.*]] = arith.constant 0 : index1768// CHECK: %[[BOX_INARR:.*]] = fir.convert %[[BOX_INARR_NONE]] : (!fir.box<none>) -> !fir.box<!fir.array<?xi32>>1769// CHECK: %[[FLAG_SET:.*]] = arith.constant 1 : i321770// CHECK: %[[FLAG_EMPTY:.*]] = arith.constant 0 : i321771// CHECK: fir.store %[[FLAG_EMPTY]] to %[[FLAG_ALLOC]] : !fir.ref<i32>1772// CHECK: %[[MAX:.*]] = arith.constant 2147483647 : i321773// CHECK: %[[CINDEX_1:.*]] = arith.constant 1 : index1774// CHECK: %[[DIM_INDEX0:.*]] = arith.constant 0 : index1775// CHECK: %[[DIMS:.*]]:3 = fir.box_dims %[[BOX_INARR]], %[[DIM_INDEX0]] : (!fir.box<!fir.array<?xi32>>, index) -> (index, index, index)1776// CHECK: %[[EXTENT:.*]] = arith.subi %[[DIMS]]#1, %[[CINDEX_1]] : index1777// CHECK: %[[DOLOOP:.*]] = fir.do_loop %[[ITER:.*]] = %[[CINDEX_0]] to %[[EXTENT]] step %[[CINDEX_1]] iter_args(%[[MIN:.*]] = %[[MAX]]) -> (i32) {1778// CHECK: %[[MASK_ITEM:.*]] = fir.coordinate_of %[[BOX_MASK]], %[[ITER]] : (!fir.box<!fir.array<?x!fir.logical<4>>>, index) -> !fir.ref<!fir.logical<4>>1779// CHECK: %[[MASK_ITEMVAL:.*]] = fir.load %[[MASK_ITEM]] : !fir.ref<!fir.logical<4>>1780// CHECK: %[[MASK_IF_ITEM:.*]] = fir.convert %[[MASK_ITEMVAL]] : (!fir.logical<4>) -> i11781// CHECK: %[[IF_MASK:.*]] = fir.if %[[MASK_IF_ITEM]] -> (i32) {1782// CHECK: %[[FLAG_SET2:.*]] = arith.constant 1 : i321783// CHECK: %[[ISFIRST:.*]] = fir.load %[[FLAG_ALLOC]] : !fir.ref<i32>1784// CHECK: %[[INARR_ITEM:.*]] = fir.coordinate_of %[[BOX_INARR]], %[[ITER]] : (!fir.box<!fir.array<?xi32>>, index) -> !fir.ref<i32>1785// CHECK: %[[INARR_ITEMVAL:.*]] = fir.load %[[INARR_ITEM]] : !fir.ref<i32>1786// CHECK: %[[NEW_MIN:.*]] = arith.cmpi slt, %[[INARR_ITEMVAL]], %[[MIN]] : i321787// CHECK: %[[ISFIRSTL:.*]] = fir.convert %[[ISFIRST]] : (i32) -> i11788// CHECK: %[[ISFIRSTNOT:.*]] = arith.xori %[[ISFIRSTL]], %true : i11789// CHECK: %[[ORCOND:.*]] = arith.ori %[[NEW_MIN]], %[[ISFIRSTNOT]] : i11790// CHECK: %[[IF_NEW_MIN:.*]] = fir.if %[[ORCOND]] -> (i32) {1791// CHECK: fir.store %[[FLAG_SET2]] to %[[FLAG_ALLOC]] : !fir.ref<i32>1792// CHECK: %[[ONE:.*]] = arith.constant 1 : i321793// CHECK: %[[OUTARR_IDX:.*]] = arith.constant 0 : index1794// CHECK: %[[OUTARR_ITEM:.*]] = fir.coordinate_of %[[BOX_OUTARR]], %[[OUTARR_IDX]] : (!fir.box<!fir.heap<!fir.array<1xi32>>>, index) -> !fir.ref<i32>1795// CHECK: %[[ITER_I32:.*]] = fir.convert %[[ITER]] : (index) -> i321796// CHECK: %[[FORTRAN_IDX:.*]] = arith.addi %[[ITER_I32]], %[[ONE]] : i321797// CHECK: fir.store %[[FORTRAN_IDX]] to %[[OUTARR_ITEM]] : !fir.ref<i32>1798// CHECK: fir.result %[[INARR_ITEMVAL]] : i321799// CHECK: } else {1800// CHECK: fir.result %[[MIN]] : i321801// CHECK: }1802// CHECK: fir.result %[[IF_NEW_MIN:.*]] : i321803// CHECK: } else {1804// CHECK: fir.result %[[MIN]] : i321805// CHECK: }1806// CHECK: fir.result %[[IF_MASK:.*]] : i321807// CHECK: }1808// CHECK: %[[REF_BOX_OUTARR:.*]] = fir.convert %[[REF_BOX_OUTARR_NONE]] : (!fir.ref<!fir.box<none>>) -> !fir.ref<!fir.box<!fir.heap<!fir.array<1xi32>>>>1809// CHECK: fir.store %[[BOX_OUTARR]] to %[[REF_BOX_OUTARR]] : !fir.ref<!fir.box<!fir.heap<!fir.array<1xi32>>>>1810// CHECK: return1811// CHECK: }1812 1813// -----1814// Check Minloc simplifies correctly for 2D case with no mask and I64 Int as result1815 1816func.func @_QPtestminloc_works2d_nomask(%arg0: !fir.ref<!fir.array<10x10xi32>> {fir.bindc_name = "a"}) -> !fir.array<2xi32> {1817 %0 = fir.alloca !fir.box<!fir.heap<!fir.array<?xi64>>>1818 %c10 = arith.constant 10 : index1819 %c10_0 = arith.constant 10 : index1820 %c2 = arith.constant 2 : index1821 %1 = fir.alloca !fir.array<2xi32> {bindc_name = "testminloc_works2d_nomask", uniq_name = "_QFtestminloc_works2d_nomaskEtestminloc_works2d_nomask"}1822 %2 = fir.shape %c2 : (index) -> !fir.shape<1>1823 %3 = fir.array_load %1(%2) : (!fir.ref<!fir.array<2xi32>>, !fir.shape<1>) -> !fir.array<2xi32>1824 %4 = fir.shape %c10, %c10_0 : (index, index) -> !fir.shape<2>1825 %5 = fir.embox %arg0(%4) : (!fir.ref<!fir.array<10x10xi32>>, !fir.shape<2>) -> !fir.box<!fir.array<10x10xi32>>1826 %c8_i32 = arith.constant 8 : i321827 %6 = fir.absent !fir.box<i1>1828 %false = arith.constant false1829 %7 = fir.zero_bits !fir.heap<!fir.array<?xi64>>1830 %c0 = arith.constant 0 : index1831 %8 = fir.shape %c0 : (index) -> !fir.shape<1>1832 %9 = fir.embox %7(%8) : (!fir.heap<!fir.array<?xi64>>, !fir.shape<1>) -> !fir.box<!fir.heap<!fir.array<?xi64>>>1833 fir.store %9 to %0 : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi64>>>>1834 %10 = fir.address_of(@_QQclXcba8b79c45ccae77d79d66a39ac99823) : !fir.ref<!fir.char<1,62>>1835 %c4_i32 = arith.constant 4 : i321836 %11 = fir.convert %0 : (!fir.ref<!fir.box<!fir.heap<!fir.array<?xi64>>>>) -> !fir.ref<!fir.box<none>>1837 %12 = fir.convert %5 : (!fir.box<!fir.array<10x10xi32>>) -> !fir.box<none>1838 %13 = fir.convert %10 : (!fir.ref<!fir.char<1,62>>) -> !fir.ref<i8>1839 %14 = fir.convert %6 : (!fir.box<i1>) -> !fir.box<none>1840 fir.call @_FortranAMinlocInteger4(%11, %12, %c8_i32, %13, %c4_i32, %14, %false) fastmath<contract> : (!fir.ref<!fir.box<none>>, !fir.box<none>, i32, !fir.ref<i8>, i32, !fir.box<none>, i1) -> ()1841 %16 = fir.load %0 : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi64>>>>1842 %c0_1 = arith.constant 0 : index1843 %17:3 = fir.box_dims %16, %c0_1 : (!fir.box<!fir.heap<!fir.array<?xi64>>>, index) -> (index, index, index)1844 %18 = fir.box_addr %16 : (!fir.box<!fir.heap<!fir.array<?xi64>>>) -> !fir.heap<!fir.array<?xi64>>1845 %19 = fir.shape_shift %17#0, %17#1 : (index, index) -> !fir.shapeshift<1>1846 %20 = fir.array_load %18(%19) : (!fir.heap<!fir.array<?xi64>>, !fir.shapeshift<1>) -> !fir.array<?xi64>1847 %c1 = arith.constant 1 : index1848 %c0_2 = arith.constant 0 : index1849 %21 = arith.subi %c2, %c1 : index1850 %22 = fir.do_loop %arg1 = %c0_2 to %21 step %c1 unordered iter_args(%arg2 = %3) -> (!fir.array<2xi32>) {1851 %24 = fir.array_fetch %20, %arg1 : (!fir.array<?xi64>, index) -> i641852 %25 = fir.convert %24 : (i64) -> i321853 %26 = fir.array_update %arg2, %25, %arg1 : (!fir.array<2xi32>, i32, index) -> !fir.array<2xi32>1854 fir.result %26 : !fir.array<2xi32>1855 }1856 fir.array_merge_store %3, %22 to %1 : !fir.array<2xi32>, !fir.array<2xi32>, !fir.ref<!fir.array<2xi32>>1857 fir.freemem %18 : !fir.heap<!fir.array<?xi64>>1858 %23 = fir.load %1 : !fir.ref<!fir.array<2xi32>>1859 return %23 : !fir.array<2xi32>1860}1861 1862// CHECK-LABEL: func.func @_QPtestminloc_works2d_nomask(1863// CHECK-SAME: %[[INARR:.*]]: !fir.ref<!fir.array<10x10xi32>> {fir.bindc_name = "a"}) -> !fir.array<2xi32> {1864// CHECK: %[[ABSENT_MASK:.*]] = fir.absent !fir.box<i1>1865// CHECK: %[[ABSENT_MASK_NONE:.*]] = fir.convert %[[ABSENT_MASK]] : (!fir.box<i1>) -> !fir.box<none>1866// CHECK: fir.call @_FortranAMinlocInteger4x2_i64_contract_simplified(%{{.*}}, %{{.*}}, %[[ABSENT_MASK_NONE]]) fastmath<contract> : (!fir.ref<!fir.box<none>>, !fir.box<none>, !fir.box<none>) -> ()1867 1868// CHECK-LABEL: func.func private @_FortranAMinlocInteger4x2_i64_contract_simplified(1869// CHECK-SAME: %[[REF_BOX_OUTARR_NONE:.*]]: !fir.ref<!fir.box<none>>,1870// CHECK-SAME: %[[BOX_INARR_NONE:.*]]: !fir.box<none>,1871// CHECK-SAME: %[[BOX_MASK_NONE:.*]]: !fir.box<none>) attributes {llvm.linkage = #llvm.linkage<linkonce_odr>} {1872// CHECK: %[[FLAG_ALLOC:.*]] = fir.alloca i641873// CHECK: %[[INIT_OUT_IDX:.*]] = arith.constant 0 : i641874// CHECK: %[[OUTARR_SIZE:.*]] = arith.constant 2 : index1875// CHECK: %[[OUTARR:.*]] = fir.allocmem !fir.array<2xi64>1876// CHECK: %[[OUTARR_SHAPE:.*]] = fir.shape %[[OUTARR_SIZE]] : (index) -> !fir.shape<1>1877// CHECK: %[[BOX_OUTARR:.*]] = fir.embox %[[OUTARR]](%[[OUTARR_SHAPE]]) : (!fir.heap<!fir.array<2xi64>>, !fir.shape<1>) -> !fir.box<!fir.heap<!fir.array<2xi64>>>1878// CHECK: %[[OUTARR_IDX0:.*]] = arith.constant 0 : index1879// CHECK: %[[OUTARR_ITEM0:.*]] = fir.coordinate_of %[[BOX_OUTARR]], %[[OUTARR_IDX0]] : (!fir.box<!fir.heap<!fir.array<2xi64>>>, index) -> !fir.ref<i64>1880// CHECK: fir.store %[[INIT_OUT_IDX]] to %[[OUTARR_ITEM0]] : !fir.ref<i64>1881// CHECK: %[[OUTARR_IDX1:.*]] = arith.constant 1 : index1882// CHECK: %[[OUTARR_ITEM1:.*]] = fir.coordinate_of %[[BOX_OUTARR]], %[[OUTARR_IDX1]] : (!fir.box<!fir.heap<!fir.array<2xi64>>>, index) -> !fir.ref<i64>1883// CHECK: fir.store %[[INIT_OUT_IDX]] to %[[OUTARR_ITEM1]] : !fir.ref<i64>1884// CHECK: %[[C_INDEX0:.*]] = arith.constant 0 : index1885// CHECK: %[[BOX_INARR:.*]] = fir.convert %[[BOX_INARR_NONE]] : (!fir.box<none>) -> !fir.box<!fir.array<?x?xi32>>1886// CHECK: %[[FLAG_SET:.*]] = arith.constant 1 : i641887// CHECK: %[[FLAG_EMPTY:.*]] = arith.constant 0 : i641888// CHECK: fir.store %[[FLAG_EMPTY]] to %[[FLAG_ALLOC]] : !fir.ref<i64>1889// CHECK: %[[MAX:.*]] = arith.constant 2147483647 : i321890// CHECK: %[[C_INDEX1:.*]] = arith.constant 1 : index1891// CHECK: %[[DIM_INDEX0:.*]] = arith.constant 0 : index1892// CHECK: %[[DIMS0:.*]]:3 = fir.box_dims %[[BOX_INARR]], %[[DIM_INDEX0]] : (!fir.box<!fir.array<?x?xi32>>, index) -> (index, index, index)1893// CHECK: %[[EXTENT0:.*]] = arith.subi %[[DIMS0]]#1, %[[C_INDEX1]] : index1894// CHECK: %[[DIM_INDEX1:.*]] = arith.constant 1 : index1895// CHECK: %[[DIMS1:.*]]:3 = fir.box_dims %[[BOX_INARR]], %[[DIM_INDEX1]] : (!fir.box<!fir.array<?x?xi32>>, index) -> (index, index, index)1896// CHECK: %[[EXTENT1:.*]] = arith.subi %[[DIMS1]]#1, %[[C_INDEX1]] : index1897// CHECK: %[[DOLOOP0:.*]] = fir.do_loop %[[ITER0:.*]] = %[[C_INDEX0]] to %[[EXTENT1]] step %[[C_INDEX1]] iter_args(%[[MIN0:.*]] = %[[MAX]]) -> (i32) {1898// CHECK: %[[DOLOOP1:.*]] = fir.do_loop %[[ITER1:.*]] = %[[C_INDEX0]] to %[[EXTENT0]] step %[[C_INDEX1]] iter_args(%[[MIN1:.*]] = %[[MIN0]]) -> (i32) {1899// CHECK: %[[FLAG_SET2:.*]] = arith.constant 1 : i641900// CHECK: %[[ISFIRST:.*]] = fir.load %[[FLAG_ALLOC]] : !fir.ref<i64>1901// CHECK: %[[INARR_ITEM:.*]] = fir.coordinate_of %[[BOX_INARR]], %[[ITER1]], %[[ITER0]] : (!fir.box<!fir.array<?x?xi32>>, index, index) -> !fir.ref<i32>1902// CHECK: %[[INARR_ITEMVAL:.*]] = fir.load %[[INARR_ITEM]] : !fir.ref<i32>1903// CHECK: %[[NEW_MIN:.*]] = arith.cmpi slt, %[[INARR_ITEMVAL]], %[[MIN1]] : i321904// CHECK: %[[ISFIRSTL:.*]] = fir.convert %[[ISFIRST]] : (i64) -> i11905// CHECK: %[[ISFIRSTNOT:.*]] = arith.xori %[[ISFIRSTL]], %true : i11906// CHECK: %[[ORCOND:.*]] = arith.ori %[[NEW_MIN]], %[[ISFIRSTNOT]] : i11907// CHECK: %[[IF_NEW_MIN:.*]] = fir.if %[[ORCOND]] -> (i32) {1908// CHECK: fir.store %[[FLAG_SET2]] to %[[FLAG_ALLOC]] : !fir.ref<i64>1909// CHECK: %[[ONE:.*]] = arith.constant 1 : i641910// CHECK: %[[OUTARR_IDX0:.*]] = arith.constant 0 : index1911// CHECK: %[[OUTARR_ITEM0:.*]] = fir.coordinate_of %[[BOX_OUTARR]], %[[OUTARR_IDX0]] : (!fir.box<!fir.heap<!fir.array<2xi64>>>, index) -> !fir.ref<i64>1912// CHECK: %[[ITER1_I64:.*]] = fir.convert %[[ITER1]] : (index) -> i641913// CHECK: %[[FORTRAN_IDX1:.*]] = arith.addi %[[ITER1_I64]], %[[ONE]] : i641914// CHECK: fir.store %[[FORTRAN_IDX1]] to %[[OUTARR_ITEM0]] : !fir.ref<i64>1915// CHECK: %[[OUTARR_IDX1:.*]] = arith.constant 1 : index1916// CHECK: %[[OUTARR_ITEM1:.*]] = fir.coordinate_of %[[BOX_OUTARR]], %[[OUTARR_IDX1]] : (!fir.box<!fir.heap<!fir.array<2xi64>>>, index) -> !fir.ref<i64>1917// CHECK: %[[ITER0_I64:.*]] = fir.convert %[[ITER0]] : (index) -> i641918// CHECK: %[[FORTRAN_IDX0:.*]] = arith.addi %[[ITER0_I64]], %[[ONE]] : i641919// CHECK: fir.store %[[FORTRAN_IDX0]] to %[[OUTARR_ITEM1]] : !fir.ref<i64>1920// CHECK: fir.result %[[INARR_ITEMVAL]] : i321921// CHECK: } else {1922// CHECK: fir.result %[[MIN1]] : i321923// CHECK: }1924// CHECK: fir.result %[[IF_NEW_MIN:.*]] : i321925// CHECK: }1926// CHECK: fir.result %[[DOLOOP1:.*]] : i321927// CHECK: }1928// CHECK: %[[REF_BOX_OUTARR:.*]] = fir.convert %[[REF_BOX_OUTARR_NONE]] : (!fir.ref<!fir.box<none>>) -> !fir.ref<!fir.box<!fir.heap<!fir.array<2xi64>>>>1929// CHECK: fir.store %[[BOX_OUTARR]] to %[[REF_BOX_OUTARR]] : !fir.ref<!fir.box<!fir.heap<!fir.array<2xi64>>>>1930// CHECK: return1931// CHECK: }1932 1933// -----1934// Check Minloc simplifies correctly for 1D case with scalar mask and f64 input1935 1936func.func @_QPtestminloc_works1d_scalarmask_f64(%arg0: !fir.ref<!fir.array<10xf64>> {fir.bindc_name = "a"}, %arg1: !fir.ref<!fir.logical<4>> {fir.bindc_name = "b"}) -> !fir.array<1xi32> {1937 %0 = fir.alloca !fir.box<!fir.heap<!fir.array<?xi32>>>1938 %c10 = arith.constant 10 : index1939 %c1 = arith.constant 1 : index1940 %1 = fir.alloca !fir.array<1xi32> {bindc_name = "testminloc_works1d_scalarmask_f64", uniq_name = "_QFtestminloc_works1d_scalarmask_f64Etestminloc_works1d_scalarmask_f64"}1941 %2 = fir.shape %c1 : (index) -> !fir.shape<1>1942 %3 = fir.array_load %1(%2) : (!fir.ref<!fir.array<1xi32>>, !fir.shape<1>) -> !fir.array<1xi32>1943 %4 = fir.shape %c10 : (index) -> !fir.shape<1>1944 %5 = fir.embox %arg0(%4) : (!fir.ref<!fir.array<10xf64>>, !fir.shape<1>) -> !fir.box<!fir.array<10xf64>>1945 %6 = fir.embox %arg1 : (!fir.ref<!fir.logical<4>>) -> !fir.box<!fir.logical<4>>1946 %c4 = arith.constant 4 : index1947 %false = arith.constant false1948 %7 = fir.zero_bits !fir.heap<!fir.array<?xi32>>1949 %c0 = arith.constant 0 : index1950 %8 = fir.shape %c0 : (index) -> !fir.shape<1>1951 %9 = fir.embox %7(%8) : (!fir.heap<!fir.array<?xi32>>, !fir.shape<1>) -> !fir.box<!fir.heap<!fir.array<?xi32>>>1952 fir.store %9 to %0 : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>1953 %10 = fir.address_of(@_QQclX66951c28c5b8bab5cdb25c1ac762b978) : !fir.ref<!fir.char<1,65>>1954 %c6_i32 = arith.constant 6 : i321955 %11 = fir.convert %0 : (!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>) -> !fir.ref<!fir.box<none>>1956 %12 = fir.convert %5 : (!fir.box<!fir.array<10xf64>>) -> !fir.box<none>1957 %13 = fir.convert %c4 : (index) -> i321958 %14 = fir.convert %10 : (!fir.ref<!fir.char<1,65>>) -> !fir.ref<i8>1959 %15 = fir.convert %6 : (!fir.box<!fir.logical<4>>) -> !fir.box<none>1960 fir.call @_FortranAMinlocReal8(%11, %12, %13, %14, %c6_i32, %15, %false) fastmath<contract> : (!fir.ref<!fir.box<none>>, !fir.box<none>, i32, !fir.ref<i8>, i32, !fir.box<none>, i1) -> ()1961 %17 = fir.load %0 : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>1962 %c0_0 = arith.constant 0 : index1963 %18:3 = fir.box_dims %17, %c0_0 : (!fir.box<!fir.heap<!fir.array<?xi32>>>, index) -> (index, index, index)1964 %19 = fir.box_addr %17 : (!fir.box<!fir.heap<!fir.array<?xi32>>>) -> !fir.heap<!fir.array<?xi32>>1965 %20 = fir.shape_shift %18#0, %18#1 : (index, index) -> !fir.shapeshift<1>1966 %21 = fir.array_load %19(%20) : (!fir.heap<!fir.array<?xi32>>, !fir.shapeshift<1>) -> !fir.array<?xi32>1967 %c1_1 = arith.constant 1 : index1968 %c0_2 = arith.constant 0 : index1969 %22 = arith.subi %c1, %c1_1 : index1970 %23 = fir.do_loop %arg2 = %c0_2 to %22 step %c1_1 unordered iter_args(%arg3 = %3) -> (!fir.array<1xi32>) {1971 %25 = fir.array_fetch %21, %arg2 : (!fir.array<?xi32>, index) -> i321972 %26 = fir.array_update %arg3, %25, %arg2 : (!fir.array<1xi32>, i32, index) -> !fir.array<1xi32>1973 fir.result %26 : !fir.array<1xi32>1974 }1975 fir.array_merge_store %3, %23 to %1 : !fir.array<1xi32>, !fir.array<1xi32>, !fir.ref<!fir.array<1xi32>>1976 fir.freemem %19 : !fir.heap<!fir.array<?xi32>>1977 %24 = fir.load %1 : !fir.ref<!fir.array<1xi32>>1978 return %24 : !fir.array<1xi32>1979}1980 1981// CHECK-LABEL: func.func @_QPtestminloc_works1d_scalarmask_f64(1982// CHECK-SAME: %[[INARR:.*]]: !fir.ref<!fir.array<10xf64>> {fir.bindc_name = "a"},1983// CHECK-SAME: %[[MASK:.*]]: !fir.ref<!fir.logical<4>> {fir.bindc_name = "b"}) -> !fir.array<1xi32> {1984// CHECK: fir.call @_FortranAMinlocReal8x1_Logical4x0_i32_contract_simplified({{.*}}, {{.*}}, {{.*}}) fastmath<contract> : (!fir.ref<!fir.box<none>>, !fir.box<none>, !fir.box<none>) -> ()1985 1986// CHECK-LABEL: func.func private @_FortranAMinlocReal8x1_Logical4x0_i32_contract_simplified(1987// CHECK-SAME: %[[REF_BOX_OUTARR_NONE:.*]]: !fir.ref<!fir.box<none>>,1988// CHECK-SAME: %[[BOX_INARR_NONE:.*]]: !fir.box<none>,1989// CHECK-SAME: %[[BOX_MASK_NONE:.*]]: !fir.box<none>) attributes {llvm.linkage = #llvm.linkage<linkonce_odr>} {1990// CHECK: %[[FLAG_ALLOC:.*]] = fir.alloca i321991// CHECK: %[[INIT_OUT_IDX:.*]] = arith.constant 0 : i321992// CHECK: %[[OUTARR_SIZE:.*]] = arith.constant 1 : index1993// CHECK: %[[OUTARR:.*]] = fir.allocmem !fir.array<1xi32>1994// CHECK: %[[OUTARR_SHAPE:.*]] = fir.shape %[[OUTARR_SIZE]] : (index) -> !fir.shape<1>1995// CHECK: %[[BOX_OUTARR:.*]] = fir.embox %[[OUTARR]](%[[OUTARR_SHAPE]]) : (!fir.heap<!fir.array<1xi32>>, !fir.shape<1>) -> !fir.box<!fir.heap<!fir.array<1xi32>>>1996// CHECK: %[[OUTARR_IDX0:.*]] = arith.constant 0 : index1997// CHECK: %[[OUTARR_ITEM0:.*]] = fir.coordinate_of %[[BOX_OUTARR]], %[[OUTARR_IDX0]] : (!fir.box<!fir.heap<!fir.array<1xi32>>>, index) -> !fir.ref<i32>1998// CHECK: fir.store %[[INIT_OUT_IDX]] to %[[OUTARR_ITEM0]] : !fir.ref<i32>1999// CHECK: %[[MASK_ADDR:.*]] = fir.box_addr %[[BOX_MASK_NONE]] : (!fir.box<none>) -> !fir.ref<!fir.logical<4>>2000// CHECK: %[[MASK_LOGICAL:.*]] = fir.load %[[MASK_ADDR]] : !fir.ref<!fir.logical<4>>2001// CHECK: %[[MASK:.*]] = fir.convert %[[MASK_LOGICAL]] : (!fir.logical<4>) -> i12002// CHECK: %[[INIT_RES:.*]] = fir.if %[[MASK]] -> (f64) {2003// CHECK: %[[C_INDEX0:.*]] = arith.constant 0 : index2004// CHECK: %[[BOX_INARR:.*]] = fir.convert %[[BOX_INARR_NONE]] : (!fir.box<none>) -> !fir.box<!fir.array<?xf64>>2005// CHECK: %[[FLAG_SET:.*]] = arith.constant 1 : i322006// CHECK: %[[FLAG_EMPTY:.*]] = arith.constant 0 : i322007// CHECK: fir.store %[[FLAG_EMPTY]] to %[[FLAG_ALLOC]] : !fir.ref<i32>2008// CHECK: %[[MAX:.*]] = arith.constant 0x7FF0000000000000 : f642009// CHECK: %[[C_INDEX1:.*]] = arith.constant 1 : index2010// CHECK: %[[DIM_INDEX:.*]] = arith.constant 0 : index2011// CHECK: %[[DIMS:.*]]:3 = fir.box_dims %[[BOX_INARR]], %[[DIM_INDEX]] : (!fir.box<!fir.array<?xf64>>, index) -> (index, index, index)2012// CHECK: %[[EXTENT:.*]] = arith.subi %[[DIMS]]#1, %[[C_INDEX1]] : index2013// CHECK: %[[DOLOOP:.*]] = fir.do_loop %[[ITER:.*]] = %[[C_INDEX0]] to %[[EXTENT]] step %[[C_INDEX1]] iter_args(%[[MIN:.*]] = %[[MAX]]) -> (f64) {2014// CHECK: %[[FLAG_SET2:.*]] = arith.constant 1 : i322015// CHECK: %[[ISFIRST:.*]] = fir.load %[[FLAG_ALLOC]] : !fir.ref<i32>2016// CHECK: %[[INARR_ITEM:.*]] = fir.coordinate_of %[[BOX_INARR]], %[[ITER]] : (!fir.box<!fir.array<?xf64>>, index) -> !fir.ref<f64>2017// CHECK: %[[INARR_ITEMVAL:.*]] = fir.load %[[INARR_ITEM]] : !fir.ref<f64>2018// CHECK: %[[NEW_MIN:.*]] = arith.cmpf olt, %[[INARR_ITEMVAL]], %arg4 fastmath<contract> : f642019// CHECK: %[[CONDRED:.*]] = arith.cmpf une, %arg4, %arg4 fastmath<contract> : f642020// CHECK: %[[CONDELEM:.*]] = arith.cmpf oeq, %[[INARR_ITEMVAL]], %[[INARR_ITEMVAL]] fastmath<contract> : f642021// CHECK: %[[ANDCOND:.*]] = arith.andi %[[CONDRED]], %[[CONDELEM]] : i12022// CHECK: %[[NEW_MIN2:.*]] = arith.ori %[[NEW_MIN]], %[[ANDCOND]] : i12023// CHECK: %[[ISFIRSTL:.*]] = fir.convert %[[ISFIRST]] : (i32) -> i12024// CHECK: %[[ISFIRSTNOT:.*]] = arith.xori %[[ISFIRSTL]], %true : i12025// CHECK: %[[ORCOND:.*]] = arith.ori %[[NEW_MIN2]], %[[ISFIRSTNOT]] : i12026// CHECK: %[[IF_NEW_MIN:.*]] = fir.if %[[ORCOND]] -> (f64) {2027// CHECK: %[[ONE:.*]] = arith.constant 1 : i322028// CHECK: %[[OUTARR_IDX:.*]] = arith.constant 0 : index2029// CHECK: %[[OUTARR_ITEM:.*]] = fir.coordinate_of %[[BOX_OUTARR]], %[[OUTARR_IDX]] : (!fir.box<!fir.heap<!fir.array<1xi32>>>, index) -> !fir.ref<i32>2030// CHECK: %[[ITER_I32:.*]] = fir.convert %[[ITER]] : (index) -> i322031// CHECK: %[[FORTRAN_IDX:.*]] = arith.addi %[[ITER_I32]], %[[ONE]] : i322032// CHECK: fir.store %[[FORTRAN_IDX]] to %[[OUTARR_ITEM]] : !fir.ref<i32>2033// CHECK: fir.result %[[INARR_ITEMVAL]] : f642034// CHECK: } else {2035// CHECK: fir.result %[[MIN]] : f642036// CHECK: }2037// CHECK: fir.result %[[IF_NEW_MIN:.*]] : f642038// CHECK: }2039// CHECK: }2040// CHECK: %[[REF_BOX_OUTARR:.*]] = fir.convert %[[VAL_0]] : (!fir.ref<!fir.box<none>>) -> !fir.ref<!fir.box<!fir.heap<!fir.array<1xi32>>>>2041// CHECK: fir.store %[[BOX_OUTARR]] to %[[REF_BOX_OUTARR]] : !fir.ref<!fir.box<!fir.heap<!fir.array<1xi32>>>>2042// CHECK: return2043// CHECK: }2044 2045// -----2046// Check Minloc is not simplified when BACK arg is set2047 2048func.func @_QPtestminloc_doesntwork1d_back(%arg0: !fir.ref<!fir.array<10xi32>> {fir.bindc_name = "a"}) -> !fir.array<1xi32> {2049 %0 = fir.alloca !fir.box<!fir.heap<!fir.array<?xi32>>>2050 %c10 = arith.constant 10 : index2051 %c1 = arith.constant 1 : index2052 %1 = fir.alloca !fir.array<1xi32> {bindc_name = "testminloc_doesntwork1d_back", uniq_name = "_QFtestminloc_doesntwork1d_backEtestminloc_doesntwork1d_back"}2053 %2 = fir.shape %c1 : (index) -> !fir.shape<1>2054 %3 = fir.array_load %1(%2) : (!fir.ref<!fir.array<1xi32>>, !fir.shape<1>) -> !fir.array<1xi32>2055 %4 = fir.shape %c10 : (index) -> !fir.shape<1>2056 %5 = fir.embox %arg0(%4) : (!fir.ref<!fir.array<10xi32>>, !fir.shape<1>) -> !fir.box<!fir.array<10xi32>>2057 %true = arith.constant true2058 %6 = fir.absent !fir.box<i1>2059 %c4 = arith.constant 4 : index2060 %7 = fir.zero_bits !fir.heap<!fir.array<?xi32>>2061 %c0 = arith.constant 0 : index2062 %8 = fir.shape %c0 : (index) -> !fir.shape<1>2063 %9 = fir.embox %7(%8) : (!fir.heap<!fir.array<?xi32>>, !fir.shape<1>) -> !fir.box<!fir.heap<!fir.array<?xi32>>>2064 fir.store %9 to %0 : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>2065 %10 = fir.address_of(@_QQclX3791f01d699716ba5914ae524c6a8dee) : !fir.ref<!fir.char<1,62>>2066 %c4_i32 = arith.constant 4 : i322067 %11 = fir.convert %0 : (!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>) -> !fir.ref<!fir.box<none>>2068 %12 = fir.convert %5 : (!fir.box<!fir.array<10xi32>>) -> !fir.box<none>2069 %13 = fir.convert %c4 : (index) -> i322070 %14 = fir.convert %10 : (!fir.ref<!fir.char<1,62>>) -> !fir.ref<i8>2071 %15 = fir.convert %6 : (!fir.box<i1>) -> !fir.box<none>2072 fir.call @_FortranAMinlocInteger4(%11, %12, %13, %14, %c4_i32, %15, %true) fastmath<contract> : (!fir.ref<!fir.box<none>>, !fir.box<none>, i32, !fir.ref<i8>, i32, !fir.box<none>, i1) -> ()2073 %17 = fir.load %0 : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>2074 %c0_0 = arith.constant 0 : index2075 %18:3 = fir.box_dims %17, %c0_0 : (!fir.box<!fir.heap<!fir.array<?xi32>>>, index) -> (index, index, index)2076 %19 = fir.box_addr %17 : (!fir.box<!fir.heap<!fir.array<?xi32>>>) -> !fir.heap<!fir.array<?xi32>>2077 %20 = fir.shape_shift %18#0, %18#1 : (index, index) -> !fir.shapeshift<1>2078 %21 = fir.array_load %19(%20) : (!fir.heap<!fir.array<?xi32>>, !fir.shapeshift<1>) -> !fir.array<?xi32>2079 %c1_1 = arith.constant 1 : index2080 %c0_2 = arith.constant 0 : index2081 %22 = arith.subi %c1, %c1_1 : index2082 %23 = fir.do_loop %arg1 = %c0_2 to %22 step %c1_1 unordered iter_args(%arg2 = %3) -> (!fir.array<1xi32>) {2083 %25 = fir.array_fetch %21, %arg1 : (!fir.array<?xi32>, index) -> i322084 %26 = fir.array_update %arg2, %25, %arg1 : (!fir.array<1xi32>, i32, index) -> !fir.array<1xi32>2085 fir.result %26 : !fir.array<1xi32>2086 }2087 fir.array_merge_store %3, %23 to %1 : !fir.array<1xi32>, !fir.array<1xi32>, !fir.ref<!fir.array<1xi32>>2088 fir.freemem %19 : !fir.heap<!fir.array<?xi32>>2089 %24 = fir.load %1 : !fir.ref<!fir.array<1xi32>>2090 return %24 : !fir.array<1xi32>2091}2092 2093// CHECK-LABEL: func.func @_QPtestminloc_doesntwork1d_back(2094// CHECK-SAME: %[[ARR:.*]]: !fir.ref<!fir.array<10xi32>> {fir.bindc_name = "a"}) -> !fir.array<1xi32> {2095// CHECK-NOT: fir.call @_FortranAMinlocInteger4x1_i32_contract_simplified({{.*}}) fastmath<contract> : (!fir.ref<!fir.box<none>>, !fir.box<none>, !fir.box<none>) -> ()2096// CHECK: fir.call @_FortranAMinlocInteger4({{.*}}) fastmath<contract> : (!fir.ref<!fir.box<none>>, !fir.box<none>, i32, !fir.ref<i8>, i32, !fir.box<none>, i1) -> ()2097// CHECK-NOT: fir.call @_FortranAMinlocInteger4x1_i32_contract_simplified({{.*}}) fastmath<contract> : (!fir.ref<!fir.box<none>>, !fir.box<none>, !fir.box<none>) -> ()2098 2099// -----2100// Check Minloc is simplified when DIM arg is set so long as the result is scalar2101 2102func.func @_QPtestminloc_1d_dim(%arg0: !fir.ref<!fir.array<10xi32>> {fir.bindc_name = "a"}) -> !fir.array<1xi32> {2103 %0 = fir.alloca !fir.box<!fir.heap<i32>>2104 %c10 = arith.constant 10 : index2105 %c1 = arith.constant 1 : index2106 %1 = fir.alloca !fir.array<1xi32> {bindc_name = "testminloc_1d_dim", uniq_name = "_QFtestminloc_1d_dimEtestminloc_1d_dim"}2107 %2 = fir.shape %c1 : (index) -> !fir.shape<1>2108 %3 = fir.array_load %1(%2) : (!fir.ref<!fir.array<1xi32>>, !fir.shape<1>) -> !fir.array<1xi32>2109 %4 = fir.shape %c10 : (index) -> !fir.shape<1>2110 %5 = fir.embox %arg0(%4) : (!fir.ref<!fir.array<10xi32>>, !fir.shape<1>) -> !fir.box<!fir.array<10xi32>>2111 %c1_i32 = arith.constant 1 : i322112 %6 = fir.absent !fir.box<i1>2113 %c4 = arith.constant 4 : index2114 %false = arith.constant false2115 %7 = fir.zero_bits !fir.heap<i32>2116 %8 = fir.embox %7 : (!fir.heap<i32>) -> !fir.box<!fir.heap<i32>>2117 fir.store %8 to %0 : !fir.ref<!fir.box<!fir.heap<i32>>>2118 %9 = fir.address_of(@_QQclXcfcf4329f25d06a4b02a0c8f532ee9df) : !fir.ref<!fir.char<1,61>>2119 %c4_i32 = arith.constant 4 : i322120 %10 = fir.convert %0 : (!fir.ref<!fir.box<!fir.heap<i32>>>) -> !fir.ref<!fir.box<none>>2121 %11 = fir.convert %5 : (!fir.box<!fir.array<10xi32>>) -> !fir.box<none>2122 %12 = fir.convert %c4 : (index) -> i322123 %13 = fir.convert %9 : (!fir.ref<!fir.char<1,61>>) -> !fir.ref<i8>2124 %14 = fir.convert %6 : (!fir.box<i1>) -> !fir.box<none>2125 fir.call @_FortranAMinlocDim(%10, %11, %12, %c1_i32, %13, %c4_i32, %14, %false) fastmath<contract> : (!fir.ref<!fir.box<none>>, !fir.box<none>, i32, i32, !fir.ref<i8>, i32, !fir.box<none>, i1) -> ()2126 %16 = fir.load %0 : !fir.ref<!fir.box<!fir.heap<i32>>>2127 %17 = fir.box_addr %16 : (!fir.box<!fir.heap<i32>>) -> !fir.heap<i32>2128 %18 = fir.load %17 : !fir.heap<i32>2129 fir.freemem %17 : !fir.heap<i32>2130 %c1_0 = arith.constant 1 : index2131 %c0 = arith.constant 0 : index2132 %19 = arith.subi %c1, %c1_0 : index2133 %20 = fir.do_loop %arg1 = %c0 to %19 step %c1_0 unordered iter_args(%arg2 = %3) -> (!fir.array<1xi32>) {2134 %22 = fir.array_update %arg2, %18, %arg1 : (!fir.array<1xi32>, i32, index) -> !fir.array<1xi32>2135 fir.result %22 : !fir.array<1xi32>2136 }2137 fir.array_merge_store %3, %20 to %1 : !fir.array<1xi32>, !fir.array<1xi32>, !fir.ref<!fir.array<1xi32>>2138 %21 = fir.load %1 : !fir.ref<!fir.array<1xi32>>2139 return %21 : !fir.array<1xi32>2140}2141// CHECK-LABEL: func.func @_QPtestminloc_1d_dim(2142// CHECK-SAME: %[[ARR:.*]]: !fir.ref<!fir.array<10xi32>> {fir.bindc_name = "a"}) -> !fir.array<1xi32> {2143// CHECK: fir.call @_FortranAMinlocDimx1_i32_i32_contract_simplified({{.*}}) fastmath<contract> : (!fir.ref<!fir.box<none>>, !fir.box<none>, !fir.box<none>) -> ()2144 2145// CHECK-LABEL: func.func private @_FortranAMinlocDimx1_i32_i32_contract_simplified(%arg0: !fir.ref<!fir.box<none>>, %arg1: !fir.box<none>, %arg2: !fir.box<none>) attributes {llvm.linkage = #llvm.linkage<linkonce_odr>} {2146// CHECK-NEXT: %[[V0:.*]] = fir.alloca i322147// CHECK-NEXT: %c0_i32 = arith.constant 0 : i322148// CHECK-NEXT: %c1 = arith.constant 1 : index2149// CHECK-NEXT: %[[V1:.*]] = fir.allocmem !fir.array<1xi32>2150// CHECK-NEXT: %[[V2:.*]] = fir.shape %c1 : (index) -> !fir.shape<1>2151// CHECK-NEXT: %[[V3:.*]] = fir.embox %[[V1]](%[[V2]]) : (!fir.heap<!fir.array<1xi32>>, !fir.shape<1>) -> !fir.box<!fir.heap<!fir.array<1xi32>>>2152// CHECK-NEXT: %c0 = arith.constant 0 : index2153// CHECK-NEXT: %[[V4:.*]] = fir.coordinate_of %[[V3]], %c0 : (!fir.box<!fir.heap<!fir.array<1xi32>>>, index) -> !fir.ref<i32>2154// CHECK-NEXT: fir.store %c0_i32 to %[[V4]] : !fir.ref<i32>2155// CHECK-NEXT: %c0_0 = arith.constant 0 : index2156// CHECK-NEXT: %[[V5:.*]] = fir.convert %arg1 : (!fir.box<none>) -> !fir.box<!fir.array<?xi32>>2157// CHECK-NEXT: %c1_i32 = arith.constant 1 : i322158// CHECK-NEXT: %c0_i32_1 = arith.constant 0 : i322159// CHECK-NEXT: fir.store %c0_i32_1 to %[[V0]] : !fir.ref<i32>2160// CHECK-NEXT: %c2147483647_i32 = arith.constant 2147483647 : i322161// CHECK-NEXT: %c1_2 = arith.constant 1 : index2162// CHECK-NEXT: %c0_3 = arith.constant 0 : index2163// CHECK-NEXT: %[[V6:.*]]:3 = fir.box_dims %[[V5]], %c0_3 : (!fir.box<!fir.array<?xi32>>, index) -> (index, index, index)2164// CHECK-NEXT: %[[V7:.*]] = arith.subi %[[V6]]#1, %c1_2 : index2165// CHECK-NEXT: %[[V8:.*]] = fir.do_loop %arg3 = %c0_0 to %[[V7]] step %c1_2 iter_args(%arg4 = %c2147483647_i32) -> (i32) {2166// CHECK-NEXT: %c1_i32_4 = arith.constant 1 : i322167// CHECK-NEXT: %[[ISFIRST:.*]] = fir.load %[[FLAG_ALLOC]] : !fir.ref<i32>2168// CHECK-NEXT: %[[V12:.*]] = fir.coordinate_of %[[V5]], %arg3 : (!fir.box<!fir.array<?xi32>>, index) -> !fir.ref<i32>2169// CHECK-NEXT: %[[V13:.*]] = fir.load %[[V12]] : !fir.ref<i32>2170// CHECK-NEXT: %[[V14:.*]] = arith.cmpi slt, %[[V13]], %arg4 : i322171// CHECK-NEXT: %[[ISFIRSTL:.*]] = fir.convert %[[ISFIRST]] : (i32) -> i12172// CHECK-NEXT: %true = arith.constant true2173// CHECK-NEXT: %[[ISFIRSTNOT:.*]] = arith.xori %[[ISFIRSTL]], %true : i12174// CHECK-NEXT: %[[ORCOND:.*]] = arith.ori %[[V14]], %[[ISFIRSTNOT]] : i12175// CHECK-NEXT: %[[V15:.*]] = fir.if %[[ORCOND]] -> (i32) {2176// CHECK-NEXT: fir.store %c1_i32_4 to %[[V0]] : !fir.ref<i32>2177// CHECK-NEXT: %c1_i32_5 = arith.constant 1 : i322178// CHECK-NEXT: %c0_6 = arith.constant 0 : index2179// CHECK-NEXT: %[[V16:.*]] = fir.coordinate_of %[[V3]], %c0_6 : (!fir.box<!fir.heap<!fir.array<1xi32>>>, index) -> !fir.ref<i32>2180// CHECK-NEXT: %[[V17:.*]] = fir.convert %arg3 : (index) -> i322181// CHECK-NEXT: %[[V18:.*]] = arith.addi %[[V17]], %c1_i32_5 : i322182// CHECK-NEXT: fir.store %[[V18]] to %[[V16]] : !fir.ref<i32>2183// CHECK-NEXT: fir.result %[[V13]] : i322184// CHECK-NEXT: } else {2185// CHECK-NEXT: fir.result %arg4 : i322186// CHECK-NEXT: }2187// CHECK-NEXT: fir.result %[[V15]] : i322188// CHECK-NEXT: }2189// CHECK-NEXT: %[[V11:.*]] = fir.convert %arg0 : (!fir.ref<!fir.box<none>>) -> !fir.ref<!fir.box<!fir.heap<i32>>>2190// CHECK-NEXT: %[[V12:.*]] = fir.convert %[[V1]] : (!fir.heap<!fir.array<1xi32>>) -> !fir.heap<i32>2191// CHECK-NEXT: %[[V13:.*]] = fir.embox %[[V12]] : (!fir.heap<i32>) -> !fir.box<!fir.heap<i32>>2192// CHECK-NEXT: fir.store %[[V13]] to %[[V11]] : !fir.ref<!fir.box<!fir.heap<i32>>>2193// CHECK-NEXT: return2194// CHECK-NEXT: }2195 2196 2197 2198// -----2199// Check Minloc is not simplified when dimension of inputArr is unknown2200 2201func.func @_QPtestminloc_doesntwork1d_unknownsize(%arg0: !fir.box<!fir.array<?xi32>> {fir.bindc_name = "a"}) -> !fir.array<1xi32> {2202 %0 = fir.alloca !fir.box<!fir.heap<!fir.array<?xi32>>>2203 %c1 = arith.constant 1 : index2204 %1 = fir.alloca !fir.array<1xi32> {bindc_name = "testminloc_doesntwork1d_unknownsize", uniq_name = "_QFtestminloc_doesntwork1d_unknownsizeEtestminloc_doesntwork1d_unknownsize"}2205 %2 = fir.shape %c1 : (index) -> !fir.shape<1>2206 %3 = fir.array_load %1(%2) : (!fir.ref<!fir.array<1xi32>>, !fir.shape<1>) -> !fir.array<1xi32>2207 %4 = fir.absent !fir.box<i1>2208 %c4 = arith.constant 4 : index2209 %false = arith.constant false2210 %5 = fir.zero_bits !fir.heap<!fir.array<?xi32>>2211 %c0 = arith.constant 0 : index2212 %6 = fir.shape %c0 : (index) -> !fir.shape<1>2213 %7 = fir.embox %5(%6) : (!fir.heap<!fir.array<?xi32>>, !fir.shape<1>) -> !fir.box<!fir.heap<!fir.array<?xi32>>>2214 fir.store %7 to %0 : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>2215 %8 = fir.address_of(@_QQclX2064f5e9298c2127417d52b69eac898e) : !fir.ref<!fir.char<1,69>>2216 %c4_i32 = arith.constant 4 : i322217 %9 = fir.convert %0 : (!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>) -> !fir.ref<!fir.box<none>>2218 %10 = fir.convert %arg0 : (!fir.box<!fir.array<?xi32>>) -> !fir.box<none>2219 %11 = fir.convert %c4 : (index) -> i322220 %12 = fir.convert %8 : (!fir.ref<!fir.char<1,69>>) -> !fir.ref<i8>2221 %13 = fir.convert %4 : (!fir.box<i1>) -> !fir.box<none>2222 fir.call @_FortranAMinlocInteger4(%9, %10, %11, %12, %c4_i32, %13, %false) fastmath<contract> : (!fir.ref<!fir.box<none>>, !fir.box<none>, i32, !fir.ref<i8>, i32, !fir.box<none>, i1) -> ()2223 %15 = fir.load %0 : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>2224 %c0_0 = arith.constant 0 : index2225 %16:3 = fir.box_dims %15, %c0_0 : (!fir.box<!fir.heap<!fir.array<?xi32>>>, index) -> (index, index, index)2226 %17 = fir.box_addr %15 : (!fir.box<!fir.heap<!fir.array<?xi32>>>) -> !fir.heap<!fir.array<?xi32>>2227 %18 = fir.shape_shift %16#0, %16#1 : (index, index) -> !fir.shapeshift<1>2228 %19 = fir.array_load %17(%18) : (!fir.heap<!fir.array<?xi32>>, !fir.shapeshift<1>) -> !fir.array<?xi32>2229 %c1_1 = arith.constant 1 : index2230 %c0_2 = arith.constant 0 : index2231 %20 = arith.subi %c1, %c1_1 : index2232 %21 = fir.do_loop %arg1 = %c0_2 to %20 step %c1_1 unordered iter_args(%arg2 = %3) -> (!fir.array<1xi32>) {2233 %23 = fir.array_fetch %19, %arg1 : (!fir.array<?xi32>, index) -> i322234 %24 = fir.array_update %arg2, %23, %arg1 : (!fir.array<1xi32>, i32, index) -> !fir.array<1xi32>2235 fir.result %24 : !fir.array<1xi32>2236 }2237 fir.array_merge_store %3, %21 to %1 : !fir.array<1xi32>, !fir.array<1xi32>, !fir.ref<!fir.array<1xi32>>2238 fir.freemem %17 : !fir.heap<!fir.array<?xi32>>2239 %22 = fir.load %1 : !fir.ref<!fir.array<1xi32>>2240 return %22 : !fir.array<1xi32>2241}2242// CHECK-LABEL: func.func @_QPtestminloc_doesntwork1d_unknownsize(2243// CHECK-SAME: %[[ARR:.*]]: !fir.box<!fir.array<?xi32>> {fir.bindc_name = "a"}) -> !fir.array<1xi32> {2244// CHECK-NOT: fir.call @_FortranAMinlocInteger4x1_i32_contract_simplified({{.*}}) fastmath<contract> : (!fir.ref<!fir.box<none>>, !fir.box<none>, !fir.box<none>) -> ()2245// CHECK: fir.call @_FortranAMinlocInteger4({{.*}}) fastmath<contract> : (!fir.ref<!fir.box<none>>, !fir.box<none>, i32, !fir.ref<i8>, i32, !fir.box<none>, i1) -> ()2246// CHECK-NOT: fir.call @_FortranAMinlocInteger4x1_i32_contract_simplified({{.*}}) fastmath<contract> : (!fir.ref<!fir.box<none>>, !fir.box<none>, !fir.box<none>) -> ()2247 2248// -----2249// Check Minloc is not simplified when inputArr is characterType2250 2251func.func @_QPtestminloc_doesntwork1d_chars(%arg0: !fir.boxchar<1> {fir.bindc_name = "a"}) -> !fir.array<1xi32> {2252 %0 = fir.alloca !fir.box<!fir.heap<!fir.array<?xi32>>>2253 %1:2 = fir.unboxchar %arg0 : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1,?>>, index)2254 %2 = fir.convert %1#0 : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<!fir.array<10x!fir.char<1>>>2255 %c10 = arith.constant 10 : index2256 %c1 = arith.constant 1 : index2257 %3 = fir.alloca !fir.array<1xi32> {bindc_name = "testminloc_doesntwork1d_chars", uniq_name = "_QFtestminloc_doesntwork1d_charsEtestminloc_doesntwork1d_chars"}2258 %4 = fir.shape %c1 : (index) -> !fir.shape<1>2259 %5 = fir.array_load %3(%4) : (!fir.ref<!fir.array<1xi32>>, !fir.shape<1>) -> !fir.array<1xi32>2260 %6 = fir.shape %c10 : (index) -> !fir.shape<1>2261 %7 = fir.embox %2(%6) : (!fir.ref<!fir.array<10x!fir.char<1>>>, !fir.shape<1>) -> !fir.box<!fir.array<10x!fir.char<1>>>2262 %8 = fir.absent !fir.box<i1>2263 %c4 = arith.constant 4 : index2264 %false = arith.constant false2265 %9 = fir.zero_bits !fir.heap<!fir.array<?xi32>>2266 %c0 = arith.constant 0 : index2267 %10 = fir.shape %c0 : (index) -> !fir.shape<1>2268 %11 = fir.embox %9(%10) : (!fir.heap<!fir.array<?xi32>>, !fir.shape<1>) -> !fir.box<!fir.heap<!fir.array<?xi32>>>2269 fir.store %11 to %0 : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>2270 %12 = fir.address_of(@_QQclX74460ff3ef22ea53671c22344e1556b9) : !fir.ref<!fir.char<1,41>>2271 %c4_i32 = arith.constant 4 : i322272 %13 = fir.convert %0 : (!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>) -> !fir.ref<!fir.box<none>>2273 %14 = fir.convert %7 : (!fir.box<!fir.array<10x!fir.char<1>>>) -> !fir.box<none>2274 %15 = fir.convert %c4 : (index) -> i322275 %16 = fir.convert %12 : (!fir.ref<!fir.char<1,41>>) -> !fir.ref<i8>2276 %17 = fir.convert %8 : (!fir.box<i1>) -> !fir.box<none>2277 fir.call @_FortranAMinlocCharacter(%13, %14, %15, %16, %c4_i32, %17, %false) fastmath<contract> : (!fir.ref<!fir.box<none>>, !fir.box<none>, i32, !fir.ref<i8>, i32, !fir.box<none>, i1) -> ()2278 %19 = fir.load %0 : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>2279 %c0_0 = arith.constant 0 : index2280 %20:3 = fir.box_dims %19, %c0_0 : (!fir.box<!fir.heap<!fir.array<?xi32>>>, index) -> (index, index, index)2281 %21 = fir.box_addr %19 : (!fir.box<!fir.heap<!fir.array<?xi32>>>) -> !fir.heap<!fir.array<?xi32>>2282 %22 = fir.shape_shift %20#0, %20#1 : (index, index) -> !fir.shapeshift<1>2283 %23 = fir.array_load %21(%22) : (!fir.heap<!fir.array<?xi32>>, !fir.shapeshift<1>) -> !fir.array<?xi32>2284 %c1_1 = arith.constant 1 : index2285 %c0_2 = arith.constant 0 : index2286 %24 = arith.subi %c1, %c1_1 : index2287 %25 = fir.do_loop %arg1 = %c0_2 to %24 step %c1_1 unordered iter_args(%arg2 = %5) -> (!fir.array<1xi32>) {2288 %27 = fir.array_fetch %23, %arg1 : (!fir.array<?xi32>, index) -> i322289 %28 = fir.array_update %arg2, %27, %arg1 : (!fir.array<1xi32>, i32, index) -> !fir.array<1xi32>2290 fir.result %28 : !fir.array<1xi32>2291 }2292 fir.array_merge_store %5, %25 to %3 : !fir.array<1xi32>, !fir.array<1xi32>, !fir.ref<!fir.array<1xi32>>2293 fir.freemem %21 : !fir.heap<!fir.array<?xi32>>2294 %26 = fir.load %3 : !fir.ref<!fir.array<1xi32>>2295 return %26 : !fir.array<1xi32>2296}2297 2298// CHECK-LABEL: func.func @_QPtestminloc_doesntwork1d_chars(2299// CHECK-SAME: %[[ARR:.*]]: !fir.boxchar<1> {fir.bindc_name = "a"}) -> !fir.array<1xi32> {2300// CHECK-NOT: fir.call @_FortranAMinlocCharacterx1_i32_contract_simplified({{.*}}) fastmath<contract> : (!fir.ref<!fir.box<none>>, !fir.box<none>, !fir.box<none>) -> ()2301// CHECK: fir.call @_FortranAMinlocCharacter({{.*}}) fastmath<contract> : (!fir.ref<!fir.box<none>>, !fir.box<none>, i32, !fir.ref<i8>, i32, !fir.box<none>, i1) -> ()2302// CHECK-NOT: fir.call @_FortranAMinlocCharacterx1_i32_contract_simplified({{.*}}) fastmath<contract> : (!fir.ref<!fir.box<none>>, !fir.box<none>, !fir.box<none>) -> ()2303 2304// -----2305// Check Minloc is not simplified when mask is unknown rank2306 2307func.func @_QPtestminloc_doesntwork1d_unknownmask(%arg0: !fir.ref<!fir.array<10xi32>> {fir.bindc_name = "a"}) -> !fir.array<1xi32> {2308 %0 = fir.alloca !fir.box<!fir.heap<!fir.array<?xi32>>>2309 %c10 = arith.constant 10 : index2310 %1 = fir.alloca i32 {bindc_name = "b", uniq_name = "_QFtestminloc_doesntwork1d_unknownmaskEb"}2311 %2 = fir.alloca !fir.box<!fir.heap<!fir.array<?x!fir.logical<4>>>> {bindc_name = "mask", uniq_name = "_QFtestminloc_doesntwork1d_unknownmaskEmask"}2312 %3 = fir.alloca !fir.heap<!fir.array<?x!fir.logical<4>>> {uniq_name = "_QFtestminloc_doesntwork1d_unknownmaskEmask.addr"}2313 %4 = fir.alloca index {uniq_name = "_QFtestminloc_doesntwork1d_unknownmaskEmask.lb0"}2314 %5 = fir.alloca index {uniq_name = "_QFtestminloc_doesntwork1d_unknownmaskEmask.ext0"}2315 %6 = fir.zero_bits !fir.heap<!fir.array<?x!fir.logical<4>>>2316 fir.store %6 to %3 : !fir.ref<!fir.heap<!fir.array<?x!fir.logical<4>>>>2317 %c1 = arith.constant 1 : index2318 %7 = fir.alloca !fir.array<1xi32> {bindc_name = "testminloc_doesntwork1d_unknownmask", uniq_name = "_QFtestminloc_doesntwork1d_unknownmaskEtestminloc_doesntwork1d_unknownmask"}2319 %8 = fir.load %1 : !fir.ref<i32>2320 %9 = fir.convert %8 : (i32) -> index2321 %c0 = arith.constant 0 : index2322 %10 = arith.cmpi sgt, %9, %c0 : index2323 %11 = arith.select %10, %9, %c0 : index2324 %12 = fir.allocmem !fir.array<?x!fir.logical<4>>, %11 {fir.must_be_heap = true, uniq_name = "_QFtestminloc_doesntwork1d_unknownmaskEmask.alloc"}2325 fir.store %12 to %3 : !fir.ref<!fir.heap<!fir.array<?x!fir.logical<4>>>>2326 fir.store %11 to %5 : !fir.ref<index>2327 %c1_0 = arith.constant 1 : index2328 fir.store %c1_0 to %4 : !fir.ref<index>2329 %13 = fir.shape %c1 : (index) -> !fir.shape<1>2330 %14 = fir.array_load %7(%13) : (!fir.ref<!fir.array<1xi32>>, !fir.shape<1>) -> !fir.array<1xi32>2331 %15 = fir.shape %c10 : (index) -> !fir.shape<1>2332 %16 = fir.embox %arg0(%15) : (!fir.ref<!fir.array<10xi32>>, !fir.shape<1>) -> !fir.box<!fir.array<10xi32>>2333 %17 = fir.load %3 : !fir.ref<!fir.heap<!fir.array<?x!fir.logical<4>>>>2334 %18 = fir.convert %17 : (!fir.heap<!fir.array<?x!fir.logical<4>>>) -> i642335 %c0_i64 = arith.constant 0 : i642336 %19 = arith.cmpi ne, %18, %c0_i64 : i642337 %20 = fir.load %4 : !fir.ref<index>2338 %21 = fir.load %5 : !fir.ref<index>2339 %22 = fir.load %3 : !fir.ref<!fir.heap<!fir.array<?x!fir.logical<4>>>>2340 %23 = fir.shape_shift %20, %21 : (index, index) -> !fir.shapeshift<1>2341 %24 = fir.embox %22(%23) : (!fir.heap<!fir.array<?x!fir.logical<4>>>, !fir.shapeshift<1>) -> !fir.box<!fir.array<?x!fir.logical<4>>>2342 %25 = fir.absent !fir.box<!fir.array<?x!fir.logical<4>>>2343 %26 = arith.select %19, %24, %25 : !fir.box<!fir.array<?x!fir.logical<4>>>2344 %c4 = arith.constant 4 : index2345 %false = arith.constant false2346 %27 = fir.zero_bits !fir.heap<!fir.array<?xi32>>2347 %c0_1 = arith.constant 0 : index2348 %28 = fir.shape %c0_1 : (index) -> !fir.shape<1>2349 %29 = fir.embox %27(%28) : (!fir.heap<!fir.array<?xi32>>, !fir.shape<1>) -> !fir.box<!fir.heap<!fir.array<?xi32>>>2350 fir.store %29 to %0 : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>2351 %30 = fir.address_of(@_QQclX74460ff3ef22ea53671c22344e1556b9) : !fir.ref<!fir.char<1,41>>2352 %c7_i32 = arith.constant 7 : i322353 %31 = fir.convert %0 : (!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>) -> !fir.ref<!fir.box<none>>2354 %32 = fir.convert %16 : (!fir.box<!fir.array<10xi32>>) -> !fir.box<none>2355 %33 = fir.convert %c4 : (index) -> i322356 %34 = fir.convert %30 : (!fir.ref<!fir.char<1,41>>) -> !fir.ref<i8>2357 %35 = fir.convert %26 : (!fir.box<!fir.array<?x!fir.logical<4>>>) -> !fir.box<none>2358 fir.call @_FortranAMinlocInteger4(%31, %32, %33, %34, %c7_i32, %35, %false) fastmath<contract> : (!fir.ref<!fir.box<none>>, !fir.box<none>, i32, !fir.ref<i8>, i32, !fir.box<none>, i1) -> ()2359 %37 = fir.load %0 : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>2360 %c0_2 = arith.constant 0 : index2361 %38:3 = fir.box_dims %37, %c0_2 : (!fir.box<!fir.heap<!fir.array<?xi32>>>, index) -> (index, index, index)2362 %39 = fir.box_addr %37 : (!fir.box<!fir.heap<!fir.array<?xi32>>>) -> !fir.heap<!fir.array<?xi32>>2363 %40 = fir.shape_shift %38#0, %38#1 : (index, index) -> !fir.shapeshift<1>2364 %41 = fir.array_load %39(%40) : (!fir.heap<!fir.array<?xi32>>, !fir.shapeshift<1>) -> !fir.array<?xi32>2365 %c1_3 = arith.constant 1 : index2366 %c0_4 = arith.constant 0 : index2367 %42 = arith.subi %c1, %c1_3 : index2368 %43 = fir.do_loop %arg1 = %c0_4 to %42 step %c1_3 unordered iter_args(%arg2 = %14) -> (!fir.array<1xi32>) {2369 %45 = fir.array_fetch %41, %arg1 : (!fir.array<?xi32>, index) -> i322370 %46 = fir.array_update %arg2, %45, %arg1 : (!fir.array<1xi32>, i32, index) -> !fir.array<1xi32>2371 fir.result %46 : !fir.array<1xi32>2372 }2373 fir.array_merge_store %14, %43 to %7 : !fir.array<1xi32>, !fir.array<1xi32>, !fir.ref<!fir.array<1xi32>>2374 fir.freemem %39 : !fir.heap<!fir.array<?xi32>>2375 %44 = fir.load %7 : !fir.ref<!fir.array<1xi32>>2376 return %44 : !fir.array<1xi32>2377}2378 2379// CHECK-LABEL: func.func @_QPtestminloc_doesntwork1d_unknownmask(2380// CHECK-SAME: %[[ARR:.*]]: !fir.ref<!fir.array<10xi32>> {fir.bindc_name = "a"}) -> !fir.array<1xi32> {2381// CHECK-NOT: fir.call @_FortranAMinlocInteger4x1_i32_contract_simplified({{.*}}) fastmath<contract> : (!fir.ref<!fir.box<none>>, !fir.box<none>, !fir.box<none>) -> ()2382// CHECK: fir.call @_FortranAMinlocInteger4({{.*}}) fastmath<contract> : (!fir.ref<!fir.box<none>>, !fir.box<none>, i32, !fir.ref<i8>, i32, !fir.box<none>, i1) -> ()2383// CHECK-NOT: fir.call @_FortranAMinlocInteger4x1_i32_contract_simplified({{.*}}) fastmath<contract> : (!fir.ref<!fir.box<none>>, !fir.box<none>, !fir.box<none>) -> ()2384 2385// -----2386// Check Maxloc simplifies similarly to minloc2387func.func @_QPtestmaxloc_works1d(%arg0: !fir.ref<!fir.array<10xi32>> {fir.bindc_name = "a"}, %arg1: !fir.ref<!fir.array<10x!fir.logical<4>>> {fir.bindc_name = "b"}) -> !fir.array<1xi32> {2388 %0 = fir.alloca !fir.box<!fir.heap<!fir.array<?xi32>>>2389 %c10 = arith.constant 10 : index2390 %c10_0 = arith.constant 10 : index2391 %c1 = arith.constant 1 : index2392 %1 = fir.alloca !fir.array<1xi32> {bindc_name = "testmaxloc_works1d", uniq_name = "_QFtestmaxloc_works1dEtestmaxloc_works1d"}2393 %2 = fir.shape %c1 : (index) -> !fir.shape<1>2394 %3 = fir.array_load %1(%2) : (!fir.ref<!fir.array<1xi32>>, !fir.shape<1>) -> !fir.array<1xi32>2395 %4 = fir.shape %c10 : (index) -> !fir.shape<1>2396 %5 = fir.embox %arg0(%4) : (!fir.ref<!fir.array<10xi32>>, !fir.shape<1>) -> !fir.box<!fir.array<10xi32>>2397 %6 = fir.shape %c10_0 : (index) -> !fir.shape<1>2398 %7 = fir.embox %arg1(%6) : (!fir.ref<!fir.array<10x!fir.logical<4>>>, !fir.shape<1>) -> !fir.box<!fir.array<10x!fir.logical<4>>>2399 %c4 = arith.constant 4 : index2400 %false = arith.constant false2401 %8 = fir.zero_bits !fir.heap<!fir.array<?xi32>>2402 %c0 = arith.constant 0 : index2403 %9 = fir.shape %c0 : (index) -> !fir.shape<1>2404 %10 = fir.embox %8(%9) : (!fir.heap<!fir.array<?xi32>>, !fir.shape<1>) -> !fir.box<!fir.heap<!fir.array<?xi32>>>2405 fir.store %10 to %0 : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>2406 %11 = fir.address_of(@_QQclXea5bcf7f706678e1796661f8916f3379) : !fir.ref<!fir.char<1,55>>2407 %c5_i32 = arith.constant 5 : i322408 %12 = fir.convert %0 : (!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>) -> !fir.ref<!fir.box<none>>2409 %13 = fir.convert %5 : (!fir.box<!fir.array<10xi32>>) -> !fir.box<none>2410 %14 = fir.convert %c4 : (index) -> i322411 %15 = fir.convert %11 : (!fir.ref<!fir.char<1,55>>) -> !fir.ref<i8>2412 %16 = fir.convert %7 : (!fir.box<!fir.array<10x!fir.logical<4>>>) -> !fir.box<none>2413 fir.call @_FortranAMaxlocInteger4(%12, %13, %14, %15, %c5_i32, %16, %false) fastmath<contract> : (!fir.ref<!fir.box<none>>, !fir.box<none>, i32, !fir.ref<i8>, i32, !fir.box<none>, i1) -> ()2414 %18 = fir.load %0 : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>2415 %c0_1 = arith.constant 0 : index2416 %19:3 = fir.box_dims %18, %c0_1 : (!fir.box<!fir.heap<!fir.array<?xi32>>>, index) -> (index, index, index)2417 %20 = fir.box_addr %18 : (!fir.box<!fir.heap<!fir.array<?xi32>>>) -> !fir.heap<!fir.array<?xi32>>2418 %21 = fir.shape_shift %19#0, %19#1 : (index, index) -> !fir.shapeshift<1>2419 %22 = fir.array_load %20(%21) : (!fir.heap<!fir.array<?xi32>>, !fir.shapeshift<1>) -> !fir.array<?xi32>2420 %c1_2 = arith.constant 1 : index2421 %c0_3 = arith.constant 0 : index2422 %23 = arith.subi %c1, %c1_2 : index2423 %24 = fir.do_loop %arg2 = %c0_3 to %23 step %c1_2 unordered iter_args(%arg3 = %3) -> (!fir.array<1xi32>) {2424 %26 = fir.array_fetch %22, %arg2 : (!fir.array<?xi32>, index) -> i322425 %27 = fir.array_update %arg3, %26, %arg2 : (!fir.array<1xi32>, i32, index) -> !fir.array<1xi32>2426 fir.result %27 : !fir.array<1xi32>2427 }2428 fir.array_merge_store %3, %24 to %1 : !fir.array<1xi32>, !fir.array<1xi32>, !fir.ref<!fir.array<1xi32>>2429 fir.freemem %20 : !fir.heap<!fir.array<?xi32>>2430 %25 = fir.load %1 : !fir.ref<!fir.array<1xi32>>2431 return %25 : !fir.array<1xi32>2432}2433 2434// CHECK-LABEL: func.func @_QPtestmaxloc_works1d(2435// CHECK-SAME: %[[INARR:.*]]: !fir.ref<!fir.array<10xi32>> {fir.bindc_name = "a"},2436// CHECK-SAME: %[[MASK:.*]]: !fir.ref<!fir.array<10x!fir.logical<4>>> {fir.bindc_name = "b"}) -> !fir.array<1xi32> {2437// CHECK: %[[OUTARR:.*]] = fir.alloca !fir.box<!fir.heap<!fir.array<?xi32>>>2438// CHECK: %[[SIZE10_0:.*]] = arith.constant 10 : index2439// CHECK: %[[SIZE10_1:.*]] = arith.constant 10 : index2440// CHECK: %[[INARR_SHAPE:.*]] = fir.shape %[[SIZE10_0]] : (index) -> !fir.shape<1>2441// CHECK: %[[BOX_INARR:.*]] = fir.embox %[[INARR]](%[[INARR_SHAPE]]) : (!fir.ref<!fir.array<10xi32>>, !fir.shape<1>) -> !fir.box<!fir.array<10xi32>>2442// CHECK: %[[MASK_SHAPE:.*]] = fir.shape %[[SIZE10_1]] : (index) -> !fir.shape<1>2443// CHECK: %[[BOX_MASK:.*]] = fir.embox %[[MASK]](%[[MASK_SHAPE]]) : (!fir.ref<!fir.array<10x!fir.logical<4>>>, !fir.shape<1>) -> !fir.box<!fir.array<10x!fir.logical<4>>>2444// CHECK: %[[REF_BOX_OUTARR_NONE:.*]] = fir.convert %[[OUTARR]] : (!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>) -> !fir.ref<!fir.box<none>>2445// CHECK: %[[BOX_INARR_NONE:.*]] = fir.convert %[[BOX_INARR]] : (!fir.box<!fir.array<10xi32>>) -> !fir.box<none>2446// CHECK: %[[BOX_MASK_NONE:.*]] = fir.convert %[[BOX_MASK]] : (!fir.box<!fir.array<10x!fir.logical<4>>>) -> !fir.box<none>2447// CHECK: fir.call @_FortranAMaxlocInteger4x1_Logical4x1_i32_contract_simplified(%[[REF_BOX_OUTARR_NONE]], %[[BOX_INARR_NONE]], %[[BOX_MASK_NONE]]) fastmath<contract> : (!fir.ref<!fir.box<none>>, !fir.box<none>, !fir.box<none>) -> ()2448 2449// CHECK-LABEL: func.func private @_FortranAMaxlocInteger4x1_Logical4x1_i32_contract_simplified(2450// CHECK-SAME: %[[REF_BOX_OUTARR_NONE:.*]]: !fir.ref<!fir.box<none>>,2451// CHECK-SAME: %[[BOX_INARR_NONE:.*]]: !fir.box<none>,2452// CHECK-SAME: %[[BOX_MASK_NONE:.*]]: !fir.box<none>) attributes {llvm.linkage = #llvm.linkage<linkonce_odr>} {2453// CHECK: %[[FLAG_ALLOC:.*]] = fir.alloca i322454// CHECK: %[[INIT_OUT_IDX:.*]] = arith.constant 0 : i322455// CHECK: %[[OUTARR_SIZE:.*]] = arith.constant 1 : index2456// CHECK: %[[OUTARR:.*]] = fir.allocmem !fir.array<1xi32>2457// CHECK: %[[OUTARR_SHAPE:.*]] = fir.shape %[[OUTARR_SIZE]] : (index) -> !fir.shape<1>2458// CHECK: %[[BOX_OUTARR:.*]] = fir.embox %[[OUTARR]](%[[OUTARR_SHAPE]]) : (!fir.heap<!fir.array<1xi32>>, !fir.shape<1>) -> !fir.box<!fir.heap<!fir.array<1xi32>>>2459// CHECK: %[[BOX_MASK:.*]] = fir.convert %[[BOX_MASK_NONE]] : (!fir.box<none>) -> !fir.box<!fir.array<?x!fir.logical<4>>>2460// CHECK: %[[OUTARR_IDX0:.*]] = arith.constant 0 : index2461// CHECK: %[[OUTARR_ITEM0:.*]] = fir.coordinate_of %[[BOX_OUTARR]], %[[OUTARR_IDX0]] : (!fir.box<!fir.heap<!fir.array<1xi32>>>, index) -> !fir.ref<i32>2462// CHECK: fir.store %[[INIT_OUT_IDX]] to %[[OUTARR_ITEM0]] : !fir.ref<i32>2463// CHECK: %[[CINDEX_0:.*]] = arith.constant 0 : index2464// CHECK: %[[BOX_INARR:.*]] = fir.convert %[[BOX_INARR_NONE]] : (!fir.box<none>) -> !fir.box<!fir.array<?xi32>>2465// CHECK: %[[FLAG_SET:.*]] = arith.constant 1 : i322466// CHECK: %[[FLAG_EMPTY:.*]] = arith.constant 0 : i322467// CHECK: fir.store %[[FLAG_EMPTY]] to %[[FLAG_ALLOC]] : !fir.ref<i32>2468// CHECK: %[[MAX:.*]] = arith.constant -2147483648 : i322469// CHECK: %[[CINDEX_1:.*]] = arith.constant 1 : index2470// CHECK: %[[DIM_INDEX0:.*]] = arith.constant 0 : index2471// CHECK: %[[DIMS:.*]]:3 = fir.box_dims %[[BOX_INARR]], %[[DIM_INDEX0]] : (!fir.box<!fir.array<?xi32>>, index) -> (index, index, index)2472// CHECK: %[[EXTENT:.*]] = arith.subi %[[DIMS]]#1, %[[CINDEX_1]] : index2473// CHECK: %[[DOLOOP:.*]] = fir.do_loop %[[ITER:.*]] = %[[CINDEX_0]] to %[[EXTENT]] step %[[CINDEX_1]] iter_args(%[[MIN:.*]] = %[[MAX]]) -> (i32) {2474// CHECK: %[[MASK_ITEM:.*]] = fir.coordinate_of %[[BOX_MASK]], %[[ITER]] : (!fir.box<!fir.array<?x!fir.logical<4>>>, index) -> !fir.ref<!fir.logical<4>>2475// CHECK: %[[MASK_ITEMVAL:.*]] = fir.load %[[MASK_ITEM]] : !fir.ref<!fir.logical<4>>2476// CHECK: %[[MASK_IF_ITEM:.*]] = fir.convert %[[MASK_ITEMVAL]] : (!fir.logical<4>) -> i12477// CHECK: %[[IF_MASK:.*]] = fir.if %[[MASK_IF_ITEM]] -> (i32) {2478// CHECK: %[[FLAG_SET2:.*]] = arith.constant 1 : i322479// CHECK: %[[ISFIRST:.*]] = fir.load %[[FLAG_ALLOC]] : !fir.ref<i32>2480// CHECK: %[[INARR_ITEM:.*]] = fir.coordinate_of %[[BOX_INARR]], %[[ITER]] : (!fir.box<!fir.array<?xi32>>, index) -> !fir.ref<i32>2481// CHECK: %[[INARR_ITEMVAL:.*]] = fir.load %[[INARR_ITEM]] : !fir.ref<i32>2482// CHECK: %[[NEW_MIN:.*]] = arith.cmpi sgt, %[[INARR_ITEMVAL]], %[[MIN]] : i322483// CHECK: %[[ISFIRSTL:.*]] = fir.convert %[[ISFIRST]] : (i32) -> i12484// CHECK: %[[ISFIRSTNOT:.*]] = arith.xori %[[ISFIRSTL]], %true : i12485// CHECK: %[[ORCOND:.*]] = arith.ori %[[NEW_MIN]], %[[ISFIRSTNOT]] : i12486// CHECK: %[[IF_NEW_MIN:.*]] = fir.if %[[ORCOND]] -> (i32) {2487// CHECK: fir.store %[[FLAG_SET2]] to %[[FLAG_ALLOC]] : !fir.ref<i32>2488// CHECK: %[[ONE:.*]] = arith.constant 1 : i322489// CHECK: %[[OUTARR_IDX:.*]] = arith.constant 0 : index2490// CHECK: %[[OUTARR_ITEM:.*]] = fir.coordinate_of %[[BOX_OUTARR]], %[[OUTARR_IDX]] : (!fir.box<!fir.heap<!fir.array<1xi32>>>, index) -> !fir.ref<i32>2491// CHECK: %[[ITER_I32:.*]] = fir.convert %[[ITER]] : (index) -> i322492// CHECK: %[[FORTRAN_IDX:.*]] = arith.addi %[[ITER_I32]], %[[ONE]] : i322493// CHECK: fir.store %[[FORTRAN_IDX]] to %[[OUTARR_ITEM]] : !fir.ref<i32>2494// CHECK: fir.result %[[INARR_ITEMVAL]] : i322495// CHECK: } else {2496// CHECK: fir.result %[[MIN]] : i322497// CHECK: }2498// CHECK: fir.result %[[IF_NEW_MIN:.*]] : i322499// CHECK: } else {2500// CHECK: fir.result %[[MIN]] : i322501// CHECK: }2502// CHECK: fir.result %[[IF_MASK:.*]] : i322503// CHECK: }2504// CHECK: %[[REF_BOX_OUTARR:.*]] = fir.convert %[[REF_BOX_OUTARR_NONE]] : (!fir.ref<!fir.box<none>>) -> !fir.ref<!fir.box<!fir.heap<!fir.array<1xi32>>>>2505// CHECK: fir.store %[[BOX_OUTARR]] to %[[REF_BOX_OUTARR]] : !fir.ref<!fir.box<!fir.heap<!fir.array<1xi32>>>>2506// CHECK: return2507// CHECK: }2508 2509// -----2510// Check Maxloc simplifies correctly for 1D case with scalar mask and f64 input2511 2512func.func @_QPtestmaxloc_works1d_scalarmask_f64(%arg0: !fir.ref<!fir.array<10xf64>> {fir.bindc_name = "a"}, %arg1: !fir.ref<!fir.logical<4>> {fir.bindc_name = "b"}) -> !fir.array<1xi32> {2513 %0 = fir.alloca !fir.box<!fir.heap<!fir.array<?xi32>>>2514 %c10 = arith.constant 10 : index2515 %c1 = arith.constant 1 : index2516 %1 = fir.alloca !fir.array<1xi32> {bindc_name = "testmaxloc_works1d_scalarmask_f64", uniq_name = "_QFtestmaxloc_works1d_scalarmask_f64Etestminloc_works1d_scalarmask_f64"}2517 %2 = fir.shape %c1 : (index) -> !fir.shape<1>2518 %3 = fir.array_load %1(%2) : (!fir.ref<!fir.array<1xi32>>, !fir.shape<1>) -> !fir.array<1xi32>2519 %4 = fir.shape %c10 : (index) -> !fir.shape<1>2520 %5 = fir.embox %arg0(%4) : (!fir.ref<!fir.array<10xf64>>, !fir.shape<1>) -> !fir.box<!fir.array<10xf64>>2521 %6 = fir.embox %arg1 : (!fir.ref<!fir.logical<4>>) -> !fir.box<!fir.logical<4>>2522 %c4 = arith.constant 4 : index2523 %false = arith.constant false2524 %7 = fir.zero_bits !fir.heap<!fir.array<?xi32>>2525 %c0 = arith.constant 0 : index2526 %8 = fir.shape %c0 : (index) -> !fir.shape<1>2527 %9 = fir.embox %7(%8) : (!fir.heap<!fir.array<?xi32>>, !fir.shape<1>) -> !fir.box<!fir.heap<!fir.array<?xi32>>>2528 fir.store %9 to %0 : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>2529 %10 = fir.address_of(@_QQclX66951c28c5b8bab5cdb25c1ac762b978) : !fir.ref<!fir.char<1,65>>2530 %c6_i32 = arith.constant 6 : i322531 %11 = fir.convert %0 : (!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>) -> !fir.ref<!fir.box<none>>2532 %12 = fir.convert %5 : (!fir.box<!fir.array<10xf64>>) -> !fir.box<none>2533 %13 = fir.convert %c4 : (index) -> i322534 %14 = fir.convert %10 : (!fir.ref<!fir.char<1,65>>) -> !fir.ref<i8>2535 %15 = fir.convert %6 : (!fir.box<!fir.logical<4>>) -> !fir.box<none>2536 fir.call @_FortranAMaxlocReal8(%11, %12, %13, %14, %c6_i32, %15, %false) fastmath<contract> : (!fir.ref<!fir.box<none>>, !fir.box<none>, i32, !fir.ref<i8>, i32, !fir.box<none>, i1) -> ()2537 %17 = fir.load %0 : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>2538 %c0_0 = arith.constant 0 : index2539 %18:3 = fir.box_dims %17, %c0_0 : (!fir.box<!fir.heap<!fir.array<?xi32>>>, index) -> (index, index, index)2540 %19 = fir.box_addr %17 : (!fir.box<!fir.heap<!fir.array<?xi32>>>) -> !fir.heap<!fir.array<?xi32>>2541 %20 = fir.shape_shift %18#0, %18#1 : (index, index) -> !fir.shapeshift<1>2542 %21 = fir.array_load %19(%20) : (!fir.heap<!fir.array<?xi32>>, !fir.shapeshift<1>) -> !fir.array<?xi32>2543 %c1_1 = arith.constant 1 : index2544 %c0_2 = arith.constant 0 : index2545 %22 = arith.subi %c1, %c1_1 : index2546 %23 = fir.do_loop %arg2 = %c0_2 to %22 step %c1_1 unordered iter_args(%arg3 = %3) -> (!fir.array<1xi32>) {2547 %25 = fir.array_fetch %21, %arg2 : (!fir.array<?xi32>, index) -> i322548 %26 = fir.array_update %arg3, %25, %arg2 : (!fir.array<1xi32>, i32, index) -> !fir.array<1xi32>2549 fir.result %26 : !fir.array<1xi32>2550 }2551 fir.array_merge_store %3, %23 to %1 : !fir.array<1xi32>, !fir.array<1xi32>, !fir.ref<!fir.array<1xi32>>2552 fir.freemem %19 : !fir.heap<!fir.array<?xi32>>2553 %24 = fir.load %1 : !fir.ref<!fir.array<1xi32>>2554 return %24 : !fir.array<1xi32>2555}2556 2557// CHECK-LABEL: func.func @_QPtestmaxloc_works1d_scalarmask_f64(2558// CHECK-SAME: %[[INARR:.*]]: !fir.ref<!fir.array<10xf64>> {fir.bindc_name = "a"},2559// CHECK-SAME: %[[MASK:.*]]: !fir.ref<!fir.logical<4>> {fir.bindc_name = "b"}) -> !fir.array<1xi32> {2560// CHECK: fir.call @_FortranAMaxlocReal8x1_Logical4x0_i32_contract_simplified({{.*}}, {{.*}}, {{.*}}) fastmath<contract> : (!fir.ref<!fir.box<none>>, !fir.box<none>, !fir.box<none>) -> ()2561 2562// CHECK-LABEL: func.func private @_FortranAMaxlocReal8x1_Logical4x0_i32_contract_simplified(2563// CHECK-SAME: %[[REF_BOX_OUTARR_NONE:.*]]: !fir.ref<!fir.box<none>>,2564// CHECK-SAME: %[[BOX_INARR_NONE:.*]]: !fir.box<none>,2565// CHECK-SAME: %[[BOX_MASK_NONE:.*]]: !fir.box<none>) attributes {llvm.linkage = #llvm.linkage<linkonce_odr>} {2566// CHECK: %[[FLAG_ALLOC:.*]] = fir.alloca i322567// CHECK: %[[INIT_OUT_IDX:.*]] = arith.constant 0 : i322568// CHECK: %[[OUTARR_SIZE:.*]] = arith.constant 1 : index2569// CHECK: %[[OUTARR:.*]] = fir.allocmem !fir.array<1xi32>2570// CHECK: %[[OUTARR_SHAPE:.*]] = fir.shape %[[OUTARR_SIZE]] : (index) -> !fir.shape<1>2571// CHECK: %[[BOX_OUTARR:.*]] = fir.embox %[[OUTARR]](%[[OUTARR_SHAPE]]) : (!fir.heap<!fir.array<1xi32>>, !fir.shape<1>) -> !fir.box<!fir.heap<!fir.array<1xi32>>>2572// CHECK: %[[OUTARR_IDX0:.*]] = arith.constant 0 : index2573// CHECK: %[[OUTARR_ITEM0:.*]] = fir.coordinate_of %[[BOX_OUTARR]], %[[OUTARR_IDX0]] : (!fir.box<!fir.heap<!fir.array<1xi32>>>, index) -> !fir.ref<i32>2574// CHECK: fir.store %[[INIT_OUT_IDX]] to %[[OUTARR_ITEM0]] : !fir.ref<i32>2575// CHECK: %[[MASK_ADDR:.*]] = fir.box_addr %[[BOX_MASK_NONE]] : (!fir.box<none>) -> !fir.ref<!fir.logical<4>>2576// CHECK: %[[MASK_LOGICAL:.*]] = fir.load %[[MASK_ADDR]] : !fir.ref<!fir.logical<4>>2577// CHECK: %[[MASK:.*]] = fir.convert %[[MASK_LOGICAL]] : (!fir.logical<4>) -> i12578// CHECK: %[[INIT_RES:.*]] = fir.if %[[MASK]] -> (f64) {2579// CHECK: %[[C_INDEX0:.*]] = arith.constant 0 : index2580// CHECK: %[[BOX_INARR:.*]] = fir.convert %[[BOX_INARR_NONE]] : (!fir.box<none>) -> !fir.box<!fir.array<?xf64>>2581// CHECK: %[[FLAG_SET:.*]] = arith.constant 1 : i322582// CHECK: %[[FLAG_EMPTY:.*]] = arith.constant 0 : i322583// CHECK: fir.store %[[FLAG_EMPTY]] to %[[FLAG_ALLOC]] : !fir.ref<i32>2584// CHECK: %[[MAX:.*]] = arith.constant 0xFFF0000000000000 : f642585// CHECK: %[[C_INDEX1:.*]] = arith.constant 1 : index2586// CHECK: %[[DIM_INDEX:.*]] = arith.constant 0 : index2587// CHECK: %[[DIMS:.*]]:3 = fir.box_dims %[[BOX_INARR]], %[[DIM_INDEX]] : (!fir.box<!fir.array<?xf64>>, index) -> (index, index, index)2588// CHECK: %[[EXTENT:.*]] = arith.subi %[[DIMS]]#1, %[[C_INDEX1]] : index2589// CHECK: %[[DOLOOP:.*]] = fir.do_loop %[[ITER:.*]] = %[[C_INDEX0]] to %[[EXTENT]] step %[[C_INDEX1]] iter_args(%[[MIN:.*]] = %[[MAX]]) -> (f64) {2590// CHECK: %[[FLAG_SET2:.*]] = arith.constant 1 : i322591// CHECK: %[[ISFIRST:.*]] = fir.load %[[FLAG_ALLOC]] : !fir.ref<i32>2592// CHECK: %[[INARR_ITEM:.*]] = fir.coordinate_of %[[BOX_INARR]], %[[ITER]] : (!fir.box<!fir.array<?xf64>>, index) -> !fir.ref<f64>2593// CHECK: %[[INARR_ITEMVAL:.*]] = fir.load %[[INARR_ITEM]] : !fir.ref<f64>2594// CHECK: %[[NEW_MIN:.*]] = arith.cmpf ogt, %[[INARR_ITEMVAL]], %arg4 fastmath<contract> : f642595// CHECK: %[[CONDRED:.*]] = arith.cmpf une, %arg4, %arg4 fastmath<contract> : f642596// CHECK: %[[CONDELEM:.*]] = arith.cmpf oeq, %[[INARR_ITEMVAL]], %[[INARR_ITEMVAL]] fastmath<contract> : f642597// CHECK: %[[ANDCOND:.*]] = arith.andi %[[CONDRED]], %[[CONDELEM]] : i12598// CHECK: %[[NEW_MIN2:.*]] = arith.ori %[[NEW_MIN]], %[[ANDCOND]] : i12599// CHECK: %[[ISFIRSTL:.*]] = fir.convert %[[ISFIRST]] : (i32) -> i12600// CHECK: %[[ISFIRSTNOT:.*]] = arith.xori %[[ISFIRSTL]], %true : i12601// CHECK: %[[ORCOND:.*]] = arith.ori %[[NEW_MIN2]], %[[ISFIRSTNOT]] : i12602// CHECK: %[[IF_NEW_MIN:.*]] = fir.if %[[ORCOND]] -> (f64) {2603// CHECK: %[[ONE:.*]] = arith.constant 1 : i322604// CHECK: %[[OUTARR_IDX:.*]] = arith.constant 0 : index2605// CHECK: %[[OUTARR_ITEM:.*]] = fir.coordinate_of %[[BOX_OUTARR]], %[[OUTARR_IDX]] : (!fir.box<!fir.heap<!fir.array<1xi32>>>, index) -> !fir.ref<i32>2606// CHECK: %[[ITER_I32:.*]] = fir.convert %[[ITER]] : (index) -> i322607// CHECK: %[[FORTRAN_IDX:.*]] = arith.addi %[[ITER_I32]], %[[ONE]] : i322608// CHECK: fir.store %[[FORTRAN_IDX]] to %[[OUTARR_ITEM]] : !fir.ref<i32>2609// CHECK: fir.result %[[INARR_ITEMVAL]] : f642610// CHECK: } else {2611// CHECK: fir.result %[[MIN]] : f642612// CHECK: }2613// CHECK: fir.result %[[IF_NEW_MIN:.*]] : f642614// CHECK: }2615// CHECK: }2616// CHECK: %[[REF_BOX_OUTARR:.*]] = fir.convert %[[VAL_0]] : (!fir.ref<!fir.box<none>>) -> !fir.ref<!fir.box<!fir.heap<!fir.array<1xi32>>>>2617// CHECK: fir.store %[[BOX_OUTARR]] to %[[REF_BOX_OUTARR]] : !fir.ref<!fir.box<!fir.heap<!fir.array<1xi32>>>>2618// CHECK: return2619// CHECK: }2620