1// RUN: fir-opt --split-input-file --simplify-intrinsics %s | FileCheck %s 2 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 : index 7 %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 : index 12 %4 = fir.address_of(@_QQclX2E2F6973756D5F322E66393000) : !fir.ref<!fir.char<1,13>> 13 %c5_i32 = arith.constant 5 : i32 14 %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) -> i32 17 %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>) -> i32 19 fir.store %9 to %0 : !fir.ref<i32> 20 %10 = fir.load %0 : !fir.ref<i32> 21 return %10 : i32 22 } 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>) -> i32 38// CHECK-NOT: fir.call @_FortranASumInteger4({{.*}}) 39// CHECK: return %{{.*}} : i32 40// 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 : index 46// CHECK: %[[ARR_BOX_I32:.*]] = fir.convert %[[ARR]] : (!fir.box<none>) -> !fir.box<!fir.array<?xi32>> 47// CHECK: %[[CI32_0:.*]] = arith.constant 0 : i32 48// CHECK: %[[CINDEX_1:.*]] = arith.constant 1 : index 49// CHECK: %[[DIMIDX_0:.*]] = arith.constant 0 : index 50// 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]] : index 52// 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]] : i32 56// CHECK: fir.result %[[NEW_SUM]] : i32 57// CHECK: } 58// CHECK: return %[[RES]] : i32 59// 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 : index 67 %c10_0 = arith.constant 10 : index 68 %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 : index 73 %4 = fir.address_of(@_QQclX2E2F6973756D5F332E66393000) : !fir.ref<!fir.char<1,13>> 74 %c5_i32 = arith.constant 5 : i32 75 %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) -> i32 78 %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>) -> i32 80 fir.store %9 to %0 : !fir.ref<i32> 81 %10 = fir.load %0 : !fir.ref<i32> 82 return %10 : i32 83 } 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>) -> i32 97// CHECK-NOT: fir.call @_FortranASumInteger4({{.*}}) 98// CHECK: return %{{.*}} : i32 99// 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 : index 105// CHECK: %[[ARR_BOX_I32:.*]] = fir.convert %[[ARR]] : (!fir.box<none>) -> !fir.box<!fir.array<?x?xi32>> 106// CHECK: %[[CI32_0:.*]] = arith.constant 0 : i32 107// CHECK: %[[CINDEX_1:.*]] = arith.constant 1 : index 108// CHECK: %[[DIMIDX_0:.*]] = arith.constant 0 : index 109// 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]] : index 111// CHECK: %[[DIMIDX_1:.*]] = arith.constant 1 : index 112// 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]] : index 114// 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]] : i32 119// CHECK: fir.result %[[NEW_SUM]] : i32 120// CHECK: } 121// CHECK: fir.result %[[RES_0]] 122// CHECK: } 123// CHECK: return %[[RES_1]] : i32 124// 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 : index 132 %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 : index 137 %4 = fir.address_of(@_QQclX2E2F6973756D5F352E66393000) : !fir.ref<!fir.char<1,13>> 138 %c5_i32 = arith.constant 5 : i32 139 %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) -> i32 142 %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>) -> f64 144 fir.store %9 to %0 : !fir.ref<f64> 145 %10 = fir.load %0 : !fir.ref<f64> 146 return %10 : f64 147 } 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 : index 159// 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>) -> f64 164// CHECK-NOT: fir.call @_FortranASumReal8({{.*}}) 165// CHECK: return %{{.*}} : f64 166// 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 : index 171// CHECK: %[[ARR_BOX_F64:.*]] = fir.convert %[[ARR]] : (!fir.box<none>) -> !fir.box<!fir.array<?xf64>> 172// CHECK: %[[ZERO:.*]] = arith.constant 0.000000e+00 : f64 173// CHECK: %[[CINDEX_1:.*]] = arith.constant 1 : index 174// CHECK: %[[DIMIDX_0:.*]] = arith.constant 0 : index 175// 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]] : index 177// 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]] : f64 181// CHECK: fir.result %[[NEW_SUM]] : f64 182// CHECK: } 183// CHECK: return %[[RES]] : f64 184// 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 : index 192 %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 : index 197 %4 = fir.address_of(@_QQclX2E2F6973756D5F352E66393000) : !fir.ref<!fir.char<1,13>> 198 %c5_i32 = arith.constant 5 : i32 199 %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) -> i32 202 %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>) -> f32 204 fir.store %9 to %0 : !fir.ref<f32> 205 %10 = fir.load %0 : !fir.ref<f32> 206 return %10 : f32 207 } 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 : index 219// 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>) -> f32 224// CHECK-NOT: fir.call @_FortranASumReal4({{.*}}) 225// CHECK: return %{{.*}} : f32 226// 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 : index 231// CHECK: %[[ARR_BOX_F32:.*]] = fir.convert %[[ARR]] : (!fir.box<none>) -> !fir.box<!fir.array<?xf32>> 232// CHECK: %[[ZERO:.*]] = arith.constant 0.000000e+00 : f32 233// CHECK: %[[CINDEX_1:.*]] = arith.constant 1 : index 234// CHECK: %[[DIMIDX_0:.*]] = arith.constant 0 : index 235// 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]] : index 237// 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]] : f32 241// CHECK: fir.result %[[NEW_SUM]] : f32 242// CHECK: } 243// CHECK: return %[[RES]] : f32 244// 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 : index 253 %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 : index 258 %5 = fir.address_of(@_QQclX2E2F6973756D5F362E66393000) : !fir.ref<!fir.char<1,13>> 259 %c5_i32 = arith.constant 5 : i32 260 %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) -> i32 264 %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 function 286// generates only ONE function declaration (and that both 287// 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 : index 291 %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 : index 296 %4 = fir.address_of(@_QQclX2E2F6973756D5F372E66393000) : !fir.ref<!fir.char<1,13>> 297 %c5_i32 = arith.constant 5 : i32 298 %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) -> i32 301 %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>) -> i32 303 fir.store %9 to %0 : !fir.ref<i32> 304 %10 = fir.load %0 : !fir.ref<i32> 305 return %10 : i32 306 } 307 func.func @sum_1d_callb(%arg0: !fir.ref<!fir.array<20xi32>> {fir.bindc_name = "a"}) -> i32 { 308 %c20 = arith.constant 20 : index 309 %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 : index 314 %4 = fir.address_of(@_QQclX2E2F6973756D5F372E66393000) : !fir.ref<!fir.char<1,13>> 315 %c12_i32 = arith.constant 12 : i32 316 %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) -> i32 319 %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>) -> i32 321 fir.store %9 to %0 : !fir.ref<i32> 322 %10 = fir.load %0 : !fir.ref<i32> 323 return %10 : i32 324 } 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 %{{.*}} : i32 346// 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 : index 354 %0 = fir.alloca i32 {bindc_name = "sum_1d_stride", uniq_name = "_QFsum_1d_strideEsum_1d_stride"} 355 %c1 = arith.constant 1 : index 356 %c2_i64 = arith.constant 2 : i64 357 %1 = fir.convert %c2_i64 : (i64) -> index 358 %2 = arith.addi %c1, %c20 : index 359 %3 = arith.subi %2, %c1 : index 360 %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 : index 365 %8 = fir.address_of(@_QQclX2E2F6973756D5F382E66393000) : !fir.ref<!fir.char<1,13>> 366 %c5_i32 = arith.constant 5 : i32 367 %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) -> i32 370 %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>) -> i32 372 fir.store %13 to %0 : !fir.ref<i32> 373 %14 = fir.load %0 : !fir.ref<i32> 374 return %14 : i32 375 } 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 : i64 385// CHECK: %[[CINDEX_2:.*]] = fir.convert %[[CI64_2]] : (i64) -> index 386// 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>) -> i32 391// CHECK: return %{{.*}} : i32 392// 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 : index 397// 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]] : index 399// 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]] : i32 403// 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 : index 413 %c1 = arith.constant 1 : index 414 %c1_i32 = arith.constant 1 : i32 415 %lineno = arith.constant 12 : i32 416 %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.return 427 } 428} 429 430// Just check that SOMETHING is being output. 431// CHECK-LABEL @sum_dim() { 432// CHECK: return 433 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 : index 443 %2 = fir.address_of(@_QQclX2E2F696D61785F312E66393000) : !fir.ref<!fir.char<1,13>> 444 %c5_i32 = arith.constant 5 : i32 445 %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) -> i32 448 %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>) -> i32 450 fir.store %7 to %0 : !fir.ref<i32> 451 %8 = fir.load %0 : !fir.ref<i32> 452 return %8 : i32 453 } 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: return 464 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 : i32 471 %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) -> f32 475 fir.store %5 to %0 : !fir.ref<f32> 476 %6 = fir.load %0 : !fir.ref<f32> 477 return %6 : f32 478} 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>) -> f32 486// CHECK: fir.store %[[RES]] to %[[RESLOC]] : !fir.ref<f32> 487// CHECK: %[[RET:.*]] = fir.load %[[RESLOC]] : !fir.ref<f32> 488// CHECK: return %[[RET]] : f32 489// 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 : f32 495// CHECK: %[[IZERO:.*]] = arith.constant 0 : index 496// 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 : index 500// CHECK: %[[LEN:.*]] = arith.subi %[[DIMS]]#1, %[[IONE]] : index 501// 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) -> f32 505// 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) -> f32 508// CHECK: %[[MUL:.*]] = arith.mulf %[[AVALCAST]], %[[BVALCAST]] : f32 509// CHECK: %[[NEWSUM:.*]] = arith.addf %[[MUL]], %[[SUM]] : f32 510// CHECK: fir.result %[[NEWSUM]] : f32 511// CHECK: } 512// CHECK: return %[[RES]] : f32 513// 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 : i32 521 %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) -> f64 525 fir.store %5 to %0 : !fir.ref<f64> 526 %6 = fir.load %0 : !fir.ref<f64> 527 return %6 : f64 528} 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 no 536// 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 : i32 548 %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) -> f80 552 fir.store %5 to %0 : !fir.ref<f80> 553 %6 = fir.load %0 : !fir.ref<f80> 554 return %6 : f80 555} 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 no 563// 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 : i32 575 %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) -> f128 579 fir.store %5 to %0 : !fir.ref<f128> 580 %6 = fir.load %0 : !fir.ref<f128> 581 return %6 : f128 582} 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 no 590// 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 : i32 602 %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) -> i32 606 fir.store %5 to %0 : !fir.ref<i32> 607 %6 = fir.load %0 : !fir.ref<i32> 608 return %6 : i32 609} 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>) -> i32 623// CHECK: fir.store %[[RES]] to %[[RESLOC]] : !fir.ref<i32> 624// CHECK: %[[RET:.*]] = fir.load %[[RESLOC]] : !fir.ref<i32> 625// CHECK: return %[[RET]] : i32 626// 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 : i32 632// CHECK: %[[IZERO:.*]] = arith.constant 0 : index 633// 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 : index 637// CHECK: %[[LEN:.*]] = arith.subi %[[DIMS]]#1, %[[IONE]] : index 638// 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) -> i32 642// 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) -> i32 645// CHECK: %[[MUL:.*]] = arith.muli %[[AVALCAST]], %[[BVALCAST]] : i32 646// CHECK: %[[NEWSUM:.*]] = arith.addi %[[MUL]], %[[SUM]] : i32 647// CHECK: fir.result %[[NEWSUM]] : i32 648// CHECK: } 649// CHECK: return %[[RES]] : i32 650// 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 : i32 658 %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) -> i8 662 fir.store %5 to %0 : !fir.ref<i8> 663 %6 = fir.load %0 : !fir.ref<i8> 664 return %6 : i8 665} 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 no 673// 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 : i32 685 %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) -> i16 689 fir.store %5 to %0 : !fir.ref<i16> 690 %6 = fir.load %0 : !fir.ref<i16> 691 return %6 : i16 692} 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 no 700// 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 : i32 712 %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) -> i64 716 fir.store %5 to %0 : !fir.ref<i64> 717 %6 = fir.load %0 : !fir.ref<i64> 718 return %6 : i64 719} 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 no 727// 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 called 736// with <?xf64> and <?xf32> arguments. The loaded elements must be converted 737// 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 : i32 743 %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) -> f64 747 fir.store %5 to %0 : !fir.ref<f64> 748 %6 = fir.load %0 : !fir.ref<f64> 749 return %6 : f64 750} 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>) -> f64 764// CHECK: fir.store %[[RES]] to %[[RESLOC]] : !fir.ref<f64> 765// CHECK: %[[RET:.*]] = fir.load %[[RESLOC]] : !fir.ref<f64> 766// CHECK: return %[[RET]] : f64 767// 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 : f64 773// CHECK: %[[IZERO:.*]] = arith.constant 0 : index 774// 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 : index 778// CHECK: %[[LEN:.*]] = arith.subi %[[DIMS]]#1, %[[IONE]] : index 779// 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) -> f64 783// 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) -> f64 786// CHECK: %[[MUL:.*]] = arith.mulf %[[AVALCAST]], %[[BVALCAST]] : f64 787// CHECK: %[[NEWSUM:.*]] = arith.addf %[[MUL]], %[[SUM]] : f64 788// CHECK: fir.result %[[NEWSUM]] : f64 789// CHECK: } 790// CHECK: return %[[RES]] : f64 791// 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 : index 800 %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 : index 805 %4 = fir.address_of(@_QQclX2E2F696D61785F322E66393000) : !fir.ref<!fir.char<1,13>> 806 %c5_i32 = arith.constant 5 : i32 807 %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) -> i32 810 %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>) -> i32 812 fir.store %9 to %0 : !fir.ref<i32> 813 %10 = fir.load %0 : !fir.ref<i32> 814 return %10 : i32 815 } 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>) -> i32 829// CHECK: return %{{.*}} : i32 830// 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 : index 835// CHECK: %[[ARR_BOX_I32:.*]] = fir.convert %[[ARR]] : (!fir.box<none>) -> !fir.box<!fir.array<?xi32>> 836// CHECK: %[[CI32_MININT:.*]] = arith.constant -2147483648 : i32 837// CHECK: %[[CINDEX_1:.*]] = arith.constant 1 : index 838// CHECK: %[[DIMIDX_0:.*]] = arith.constant 0 : index 839// 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]] : index 841// 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]] : i32 845// CHECK: fir.result %[[NEW_MAX]] : i32 846// CHECK: } 847// CHECK: return %[[RES]] : i32 848// 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 : index 856 %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 : index 861 %4 = fir.address_of(@_QQclX2E2F6973756D5F352E66393000) : !fir.ref<!fir.char<1,13>> 862 %c5_i32 = arith.constant 5 : i32 863 %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) -> i32 866 %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>) -> f64 868 fir.store %9 to %0 : !fir.ref<f64> 869 %10 = fir.load %0 : !fir.ref<f64> 870 return %10 : f64 871 } 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 : index 883// 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>) -> f64 887// CHECK: return %{{.*}} : f64 888// 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 : index 893// 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 : f64 895// CHECK: %[[CINDEX_1:.*]] = arith.constant 1 : index 896// CHECK: %[[DIMIDX_0:.*]] = arith.constant 0 : index 897// 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]] : index 899// 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]] : f64 903// CHECK: %[[NEW_MAX:.*]] = arith.select %[[CMP]], %[[ITEM_VAL]], %[[MAX]] : f64 904// CHECK: fir.result %[[NEW_MAX]] : f64 905// CHECK: } 906// CHECK: return %[[RES]] : f64 907// CHECK: } 908 909// ----- 910 911// SUM reduction of sliced explicit-shape array is replaced with 912// 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 : index 915 %c10_0 = arith.constant 10 : index 916 %c10_1 = arith.constant 10 : index 917 %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 : index 920 %c1_i64 = arith.constant 1 : i64 921 %2 = fir.convert %c1_i64 : (i64) -> index 922 %3 = arith.addi %c1, %c10 : index 923 %4 = arith.subi %3, %c1 : index 924 %c1_i64_2 = arith.constant 1 : i64 925 %5 = fir.convert %c1_i64_2 : (i64) -> index 926 %6 = arith.addi %c1, %c10_0 : index 927 %7 = arith.subi %6, %c1 : index 928 %c1_i64_3 = arith.constant 1 : i64 929 %8 = fir.undefined index 930 %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 : index 935 %13 = fir.address_of(@_QQclX2E2F746573742E66393000) : !fir.ref<!fir.char<1,11>> 936 %c3_i32 = arith.constant 3 : i32 937 %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) -> i32 940 %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>) -> i64 942 fir.store %18 to %1 : !fir.ref<i64> 943 %19 = fir.load %0 : !fir.ref<f32> 944 return %19 : f32 945} 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 with 959// 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 : index 964 %c1_i64 = arith.constant 1 : i64 965 %2 = fir.convert %c1_i64 : (i64) -> index 966 %c0 = arith.constant 0 : index 967 %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 : index 969 %5 = arith.subi %4, %c1 : index 970 %c1_i64_0 = arith.constant 1 : i64 971 %6 = fir.convert %c1_i64_0 : (i64) -> index 972 %c1_1 = arith.constant 1 : index 973 %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 : index 975 %9 = arith.subi %8, %c1 : index 976 %c1_i64_2 = arith.constant 1 : i64 977 %10 = fir.undefined index 978 %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 : index 982 %14 = fir.address_of(@_QQclX2E2F746573742E66393000) : !fir.ref<!fir.char<1,11>> 983 %c8_i32 = arith.constant 8 : i32 984 %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) -> i32 987 %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>) -> i64 989 fir.store %19 to %0 : !fir.ref<i64> 990 %20 = fir.load %1 : !fir.ref<f32> 991 return %20 : f32 992} 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 : i32 1009 %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) -> f32 1013 fir.store %5 to %0 : !fir.ref<f32> 1014 %6 = fir.load %0 : !fir.ref<f32> 1015 return %6 : f32 1016} 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 : i32 1022 %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) -> f32 1026 fir.store %5 to %0 : !fir.ref<f32> 1027 %6 = fir.load %0 : !fir.ref<f32> 1028 return %6 : f32 1029} 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_reassoc 1038// CHECK: fir.call @_FortranADotProductReal4_reassoc_contract_f32_f32_simplified(%2, %3) fastmath<reassoc,contract> 1039// CHECK-LABEL: @dot_f32_fast 1040// CHECK: fir.call @_FortranADotProductReal4_fast_f32_f32_simplified(%2, %3) fastmath<fast> 1041// CHECK-LABEL: func.func private @_FortranADotProductReal4_reassoc_contract_f32_f32_simplified 1042// CHECK: arith.mulf %{{.*}}, %{{.*}} fastmath<reassoc,contract> : f32 1043// CHECK: arith.addf %{{.*}}, %{{.*}} fastmath<reassoc,contract> : f32 1044// CHECK-LABEL: func.func private @_FortranADotProductReal4_fast_f32_f32_simplified 1045// CHECK: arith.mulf %{{.*}}, %{{.*}} fastmath<fast> : f32 1046// CHECK: arith.addf %{{.*}}, %{{.*}} fastmath<fast> : f32 1047 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 : index 1052 %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 : index 1057 %4 = fir.address_of(@_QQclX2E2F6973756D5F352E66393000) : !fir.ref<!fir.char<1,13>> 1058 %c5_i32 = arith.constant 5 : i32 1059 %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) -> i32 1062 %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>) -> f64 1064 fir.store %9 to %0 : !fir.ref<f64> 1065 %10 = fir.load %0 : !fir.ref<f64> 1066 return %10 : f64 1067} 1068 1069func.func @sum_1d_real_fast(%arg0: !fir.ref<!fir.array<10xf64>> {fir.bindc_name = "a"}) -> f64 { 1070 %c10 = arith.constant 10 : index 1071 %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 : index 1076 %4 = fir.address_of(@_QQclX2E2F6973756D5F352E66393000) : !fir.ref<!fir.char<1,13>> 1077 %c5_i32 = arith.constant 5 : i32 1078 %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) -> i32 1081 %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>) -> f64 1083 fir.store %9 to %0 : !fir.ref<f64> 1084 %10 = fir.load %0 : !fir.ref<f64> 1085 return %10 : f64 1086} 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_reassoc 1095// CHECK: fir.call @_FortranASumReal8x1_reassoc_contract_simplified(%5) fastmath<reassoc,contract> 1096// CHECK-LABEL: @sum_1d_real_fast 1097// CHECK: fir.call @_FortranASumReal8x1_fast_simplified(%5) fastmath<fast> 1098// CHECK-LABEL: func.func private @_FortranASumReal8x1_reassoc_contract_simplified 1099// CHECK: arith.addf %{{.*}}, %{{.*}} fastmath<reassoc,contract> : f64 1100// CHECK-LABEL: func.func private @_FortranASumReal8x1_fast_simplified 1101// CHECK: arith.addf %{{.*}}, %{{.*}} fastmath<fast> : f64 1102 1103// ----- 1104// Ensure count is simplified in valid case 1105 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 : index 1109 %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 : index 1113 %4 = fir.address_of(@_QQclX2E2F746573746661696C2E66393000) : !fir.ref<!fir.char<1,15>> 1114 %c10_i32 = arith.constant 10 : i32 1115 %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) -> i32 1118 %8 = fir.call @_FortranACount(%5, %6, %c10_i32, %7) fastmath<contract> : (!fir.box<none>, !fir.ref<i8>, i32, i32) -> i64 1119 %9 = fir.convert %8 : (i64) -> i32 1120 fir.store %9 to %0 : !fir.ref<i32> 1121 %10 = fir.load %0 : !fir.ref<i32> 1122 return %10 : i32 1123} 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>) -> i64 1137// CHECK-NOT: fir.call @_FortranACount({{.*}}) 1138// CHECK: return %{{.*}} : i32 1139// 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 : index 1145// CHECK: %[[ARR_BOX_I32:.*]] = fir.convert %[[ARR]] : (!fir.box<none>) -> !fir.box<!fir.array<?xi32>> 1146// CHECK: %[[IZERO:.*]] = arith.constant 0 : i64 1147// CHECK: %[[C_INDEX1:.*]] = arith.constant 1 : index 1148// CHECK: %[[DIMIDX_0:.*]] = arith.constant 0 : index 1149// 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]] : index 1151// 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 : i32 1155// CHECK: %[[I64_0:.*]] = arith.constant 0 : i64 1156// CHECK: %[[I64_1:.*]] = arith.constant 1 : i64 1157// CHECK: %[[CMP:.*]] = arith.cmpi eq, %[[ITEM_VAL]], %[[I32_0]] : i32 1158// CHECK: %[[SELECT:.*]] = arith.select %[[CMP]], %[[I64_0]], %[[I64_1]] : i64 1159// CHECK: %[[NEW_COUNT:.*]] = arith.addi %[[SELECT]], %[[COUNT]] : i64 1160// CHECK: fir.result %[[NEW_COUNT]] : i64 1161// CHECK: } 1162// CHECK: return %[[RES:.*]] : i64 1163// CHECK: } 1164 1165// ----- 1166// Ensure count is properly simplified for different mask kind 1167 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 : index 1171 %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 : index 1174 %3 = fir.address_of(@_QQclX916d74b25894ddf7881ff7f913a677f5) : !fir.ref<!fir.char<1,52>> 1175 %c5_i32 = arith.constant 5 : i32 1176 %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) -> i32 1179 %7 = fir.call @_FortranACount(%4, %5, %c5_i32, %6) fastmath<contract> : (!fir.box<none>, !fir.ref<i8>, i32, i32) -> i64 1180 %8 = fir.convert %7 : (i64) -> i32 1181 fir.store %8 to %0 : !fir.ref<i32> 1182 %9 = fir.load %0 : !fir.ref<i32> 1183 return %9 : i32 1184} 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>) -> i64 1189 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 : index 1193// CHECK: %[[ARR_BOX_I16:.*]] = fir.convert %[[ARR]] : (!fir.box<none>) -> !fir.box<!fir.array<?xi16>> 1194// CHECK: %[[IZERO:.*]] = arith.constant 0 : i64 1195// CHECK: %[[C_INDEX1:.*]] = arith.constant 1 : index 1196// CHECK: %[[DIMIDX_0:.*]] = arith.constant 0 : index 1197// 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]] : index 1199// 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 : i16 1203// CHECK: %[[I64_0:.*]] = arith.constant 0 : i64 1204// CHECK: %[[I64_1:.*]] = arith.constant 1 : i64 1205// CHECK: %[[CMP:.*]] = arith.cmpi eq, %[[ITEM_VAL]], %[[I16_0]] : i16 1206// CHECK: %[[SELECT:.*]] = arith.select %[[CMP]], %[[I64_0]], %[[I64_1]] : i64 1207// CHECK: %[[NEW_COUNT:.*]] = arith.addi %[[SELECT]], %[[COUNT]] : i64 1208// CHECK: fir.result %[[NEW_COUNT]] : i64 1209// CHECK: } 1210// CHECK: return %[[RES:.*]] : i64 1211// CHECK: } 1212 1213// ----- 1214// Ensure count isn't simplified when given dim argument 1215 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 : index 1219 %c10_0 = arith.constant 10 : index 1220 %c10_1 = arith.constant 10 : index 1221 %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 : i32 1225 %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 : index 1228 %6 = fir.zero_bits !fir.heap<!fir.array<?xi32>> 1229 %c0 = arith.constant 0 : index 1230 %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 : i32 1235 %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) -> i32 1238 %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 : index 1242 %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 : index 1247 %c0_3 = arith.constant 0 : index 1248 %20 = arith.subi %c10_1, %c1 : index 1249 %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) -> i32 1251 %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 arrays 1269 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 : index 1273 %1 = fir.address_of(@_QQclX95529933117f47914fc21e220c1a0896) : !fir.ref<!fir.char<1,58>> 1274 %c3_i32 = arith.constant 3 : i32 1275 %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) -> i32 1278 %5 = fir.call @_FortranACount(%2, %3, %c3_i32, %4) fastmath<contract> : (!fir.box<none>, !fir.ref<i8>, i32, i32) -> i64 1279 %6 = fir.convert %5 : (i64) -> i32 1280 fir.store %6 to %0 : !fir.ref<i32> 1281 %7 = fir.load %0 : !fir.ref<i32> 1282 return %7 : i32 1283} 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) -> i64 1290// CHECK-NOT fir.call @_FortranACountLogical4_simplified({{.*}}) 1291 1292// ----- 1293// Ensure Any is simplified in correct usage 1294 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 : index 1297 %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 : index 1301 %3 = fir.address_of(@_QQclX04ab56883945fd2c21a3b6d132f0bb37) : !fir.ref<!fir.char<1,48>> 1302 %c3_i32 = arith.constant 3 : i32 1303 %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) -> i32 1306 %7 = fir.call @_FortranAAny(%4, %5, %c3_i32, %6) fastmath<contract> : (!fir.box<none>, !fir.ref<i8>, i32, i32) -> i1 1307 %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 : index 1317// 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>) -> i1 1321// 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 true 1326// CHECK: %[[C_INDEX0:.*]] = arith.constant 0 : index 1327// CHECK: %[[A_BOX_I32:.*]] = fir.convert %[[ARR]] : (!fir.box<none>) -> !fir.box<!fir.array<?xi32>> 1328// CHECK: %[[FALSE:.*]] = arith.constant false 1329// CHECK: %[[C_INDEX1:.*]] = arith.constant 1 : index 1330// CHECK: %[[DIM_IDX0:.*]] = arith.constant 0 : index 1331// 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]] : index 1333// 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 : i32 1337// CHECK: %[[CMP:.*]] = arith.cmpi ne, %[[ITEM_VAL]], %[[I32_0]] : i32 1338// CHECK: %[[I1_1:.*]] = arith.constant true 1339// CHECK: %[[CONTINUE:.*]] = arith.xori %[[CMP]], %[[I1_1]] : i1 1340// CHECK: fir.result %[[CONTINUE]], %[[CMP]] : i1, i1 1341// CHECK: } 1342// CHECK: return %[[RES:.*]]#1 : i1 1343// CHECK: } 1344 1345// ----- 1346// Ensure Any is simpified correctly for different kind logical 1347 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 : index 1350 %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 : index 1354 %3 = fir.address_of(@_QQclX04ab56883945fd2c21a3b6d132f0bb37) : !fir.ref<!fir.char<1,48>> 1355 %c3_i32 = arith.constant 3 : i32 1356 %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) -> i32 1359 %7 = fir.call @_FortranAAny(%4, %5, %c3_i32, %6) fastmath<contract> : (!fir.box<none>, !fir.ref<i8>, i32, i32) -> i1 1360 %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 : index 1370// 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>) -> i1 1374// 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 true 1379// CHECK: %[[C_INDEX0:.*]] = arith.constant 0 : index 1380// CHECK: %[[A_BOX_I64:.*]] = fir.convert %[[ARR]] : (!fir.box<none>) -> !fir.box<!fir.array<?xi64>> 1381// CHECK: %[[FALSE:.*]] = arith.constant false 1382// CHECK: %[[C_INDEX1:.*]] = arith.constant 1 : index 1383// CHECK: %[[DIM_IDX0:.*]] = arith.constant 0 : index 1384// 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]] : index 1386// 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 : i64 1390// CHECK: %[[CMP:.*]] = arith.cmpi ne, %[[ITEM_VAL]], %[[I64_0]] : i64 1391// CHECK: %[[I1_1:.*]] = arith.constant true 1392// CHECK: %[[CONTINUE:.*]] = arith.xori %[[CMP]], %[[I1_1]] : i1 1393// CHECK: fir.result %[[CONTINUE]], %[[CMP]] : i1, i1 1394// CHECK: } 1395// CHECK: return %[[RES:.*]]#1 : i1 1396// 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 : index 1404 %c10_0 = arith.constant 10 : index 1405 %c10_1 = arith.constant 10 : index 1406 %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 : i32 1410 %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 : index 1414 %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 : i32 1419 %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 : index 1425 %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 : index 1430 %c0_3 = arith.constant 0 : index 1431 %19 = arith.subi %c10_1, %c1 : index 1432 %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 arrays 1452 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 : index 1456 %1 = fir.address_of(@_QQclX04ab56883945fd2c21a3b6d132f0bb37) : !fir.ref<!fir.char<1,48>> 1457 %c3_i32 = arith.constant 3 : i32 1458 %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) -> i32 1461 %5 = fir.call @_FortranAAny(%2, %3, %c3_i32, %4) fastmath<contract> : (!fir.box<none>, !fir.ref<i8>, i32, i32) -> i1 1462 %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) -> i1 1473// CHECK-NOT fir.call @_FortranAAnyLogical4x1_simplified({{.*}}) 1474 1475// ----- 1476// Check that multi-rank Any cases are properly simplified 1477 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 : index 1480 %c0 = arith.constant 0 : index 1481 %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 : index 1485 %3 = fir.address_of(@_QQclX04ab56883945fd2c21a3b6d132f0bb37) : !fir.ref<!fir.char<1,48>> 1486 %c3_i32 = arith.constant 3 : i32 1487 %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) -> i32 1490 %7 = fir.call @_FortranAAny(%4, %5, %c3_i32, %6) fastmath<contract> : (!fir.box<none>, !fir.ref<i8>, i32, i32) -> i1 1491 %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 : index 1500// CHECK: %[[SIZE_0:.*]] = arith.constant 0 : index 1501// 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>) -> i1 1505 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 true 1509// CHECK: %[[CINDEX_0:.*]] = arith.constant 0 : index 1510// CHECK: %[[A_BOX_I32:.*]] = fir.convert %[[VAL_0]] : (!fir.box<none>) -> !fir.box<!fir.array<?x?xi32>> 1511// CHECK: %[[FALSE:.*]] = arith.constant false 1512// CHECK: %[[CINDEX_1:.*]] = arith.constant 1 : index 1513// CHECK: %[[DIMINDEX_0:.*]] = arith.constant 0 : index 1514// 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]] : index 1516// CHECK: %[[DIMINDEX_1:.*]] = arith.constant 1 : index 1517// 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]] : index 1519// 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 : i32 1524// CHECK: %[[NEXT_ANY:.*]] = arith.cmpi ne, %[[ITEMVAL]], %[[I32_0]] : i32 1525// CHECK: %[[I1_1:.*]] = arith.constant true 1526// CHECK: %[[CONTINUE:.*]] = arith.xori %[[NEXT_ANY]], %[[I1_1]] : i1 1527// CHECK: fir.result %[[CONTINUE]], %[[NEXT_ANY]] : i1, i1 1528// CHECK: } 1529// CHECK: fir.result %[[RETURN_VALS:.*]]#0, %[[RETURN_VALS]]#1 : i1, i1 1530// CHECK: } 1531// CHECK: return %[[RETURN_VAL:.*]]#1 : i1 1532// CHECK: } 1533 1534// ----- 1535// Ensure All is simplified in correct usage 1536 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 : index 1539 %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 : index 1543 %3 = fir.address_of(@_QQclX04ab56883945fd2c21a3b6d132f0bb37) : !fir.ref<!fir.char<1,48>> 1544 %c3_i32 = arith.constant 3 : i32 1545 %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) -> i32 1548 %7 = fir.call @_FortranAAll(%4, %5, %c3_i32, %6) fastmath<contract> : (!fir.box<none>, !fir.ref<i8>, i32, i32) -> i1 1549 %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 : index 1559// 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>) -> i1 1563// 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 true 1568// CHECK: %[[C_INDEX0:.*]] = arith.constant 0 : index 1569// CHECK: %[[A_BOX_I32:.*]] = fir.convert %[[ARR]] : (!fir.box<none>) -> !fir.box<!fir.array<?xi32>> 1570// CHECK: %[[TRUE:.*]] = arith.constant true 1571// CHECK: %[[C_INDEX1:.*]] = arith.constant 1 : index 1572// CHECK: %[[DIM_INDEX0:.*]] = arith.constant 0 : index 1573// 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]] : index 1575// 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 : i32 1579// CHECK: %[[CMP_AND_CONTINUE:.*]] = arith.cmpi ne, %[[ITEM_VAL]], %[[I32_0]] : i32 1580// CHECK: fir.result %[[CMP_AND_CONTINUE]], %[[CMP_AND_CONTINUE]] : i1, i1 1581// CHECK: } 1582// CHECK: return %[[RES:.*]]#1 : i1 1583// CHECK: } 1584 1585// ----- 1586// Ensure All is correctly simplified for different kind logical 1587 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 : index 1590 %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 : index 1594 %3 = fir.address_of(@_QQclX04ab56883945fd2c21a3b6d132f0bb37) : !fir.ref<!fir.char<1,48>> 1595 %c3_i32 = arith.constant 3 : i32 1596 %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) -> i32 1599 %7 = fir.call @_FortranAAll(%4, %5, %c3_i32, %6) fastmath<contract> : (!fir.box<none>, !fir.ref<i8>, i32, i32) -> i1 1600 %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 : index 1610// 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>) -> i1 1614// 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 true 1619// CHECK: %[[C_INDEX0:.*]] = arith.constant 0 : index 1620// CHECK: %[[A_BOX_I8:.*]] = fir.convert %[[ARR]] : (!fir.box<none>) -> !fir.box<!fir.array<?xi8>> 1621// CHECK: %[[TRUE:.*]] = arith.constant true 1622// CHECK: %[[C_INDEX1:.*]] = arith.constant 1 : index 1623// CHECK: %[[DIM_INDEX0:.*]] = arith.constant 0 : index 1624// 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]] : index 1626// 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 : i8 1630// CHECK: %[[CMP_AND_CONTINUE:.*]] = arith.cmpi ne, %[[ITEM_VAL]], %[[I8_0]] : i8 1631// CHECK: fir.result %[[CMP_AND_CONTINUE]], %[[CMP_AND_CONTINUE]] : i1, i1 1632// CHECK: } 1633// CHECK: return %[[RES:.*]]#1 : i1 1634// 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 : index 1643 %c10_0 = arith.constant 10 : index 1644 %c10_1 = arith.constant 10 : index 1645 %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 : i32 1649 %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 : index 1653 %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 : i32 1658 %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 : index 1664 %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 : index 1669 %c0_3 = arith.constant 0 : index 1670 %19 = arith.subi %c10_1, %c1 : index 1671 %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 input 1691func.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 : index 1694 %c10_0 = arith.constant 10 : index 1695 %c1 = arith.constant 1 : index 1696 %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 : index 1704 %false = arith.constant false 1705 %8 = fir.zero_bits !fir.heap<!fir.array<?xi32>> 1706 %c0 = arith.constant 0 : index 1707 %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 : i32 1712 %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) -> i32 1715 %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 : index 1720 %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 : index 1725 %c0_3 = arith.constant 0 : index 1726 %23 = arith.subi %c1, %c1_2 : index 1727 %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) -> i32 1729 %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 : index 1743// CHECK: %[[SIZE10_1:.*]] = arith.constant 10 : index 1744// 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 i32 1758// CHECK: %[[INIT_OUT_IDX:.*]] = arith.constant 0 : i32 1759// CHECK: %[[OUTARR_SIZE:.*]] = arith.constant 1 : index 1760// 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 : index 1765// 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 : index 1768// CHECK: %[[BOX_INARR:.*]] = fir.convert %[[BOX_INARR_NONE]] : (!fir.box<none>) -> !fir.box<!fir.array<?xi32>> 1769// CHECK: %[[FLAG_SET:.*]] = arith.constant 1 : i32 1770// CHECK: %[[FLAG_EMPTY:.*]] = arith.constant 0 : i32 1771// CHECK: fir.store %[[FLAG_EMPTY]] to %[[FLAG_ALLOC]] : !fir.ref<i32> 1772// CHECK: %[[MAX:.*]] = arith.constant 2147483647 : i32 1773// CHECK: %[[CINDEX_1:.*]] = arith.constant 1 : index 1774// CHECK: %[[DIM_INDEX0:.*]] = arith.constant 0 : index 1775// 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]] : index 1777// 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>) -> i1 1781// CHECK: %[[IF_MASK:.*]] = fir.if %[[MASK_IF_ITEM]] -> (i32) { 1782// CHECK: %[[FLAG_SET2:.*]] = arith.constant 1 : i32 1783// 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]] : i32 1787// CHECK: %[[ISFIRSTL:.*]] = fir.convert %[[ISFIRST]] : (i32) -> i1 1788// CHECK: %[[ISFIRSTNOT:.*]] = arith.xori %[[ISFIRSTL]], %true : i1 1789// CHECK: %[[ORCOND:.*]] = arith.ori %[[NEW_MIN]], %[[ISFIRSTNOT]] : i1 1790// 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 : i32 1793// CHECK: %[[OUTARR_IDX:.*]] = arith.constant 0 : index 1794// 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) -> i32 1796// CHECK: %[[FORTRAN_IDX:.*]] = arith.addi %[[ITER_I32]], %[[ONE]] : i32 1797// CHECK: fir.store %[[FORTRAN_IDX]] to %[[OUTARR_ITEM]] : !fir.ref<i32> 1798// CHECK: fir.result %[[INARR_ITEMVAL]] : i32 1799// CHECK: } else { 1800// CHECK: fir.result %[[MIN]] : i32 1801// CHECK: } 1802// CHECK: fir.result %[[IF_NEW_MIN:.*]] : i32 1803// CHECK: } else { 1804// CHECK: fir.result %[[MIN]] : i32 1805// CHECK: } 1806// CHECK: fir.result %[[IF_MASK:.*]] : i32 1807// 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: return 1811// CHECK: } 1812 1813// ----- 1814// Check Minloc simplifies correctly for 2D case with no mask and I64 Int as result 1815 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 : index 1819 %c10_0 = arith.constant 10 : index 1820 %c2 = arith.constant 2 : index 1821 %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 : i32 1827 %6 = fir.absent !fir.box<i1> 1828 %false = arith.constant false 1829 %7 = fir.zero_bits !fir.heap<!fir.array<?xi64>> 1830 %c0 = arith.constant 0 : index 1831 %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 : i32 1836 %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 : index 1843 %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 : index 1848 %c0_2 = arith.constant 0 : index 1849 %21 = arith.subi %c2, %c1 : index 1850 %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) -> i64 1852 %25 = fir.convert %24 : (i64) -> i32 1853 %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 i64 1873// CHECK: %[[INIT_OUT_IDX:.*]] = arith.constant 0 : i64 1874// CHECK: %[[OUTARR_SIZE:.*]] = arith.constant 2 : index 1875// 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 : index 1879// 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 : index 1882// 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 : index 1885// CHECK: %[[BOX_INARR:.*]] = fir.convert %[[BOX_INARR_NONE]] : (!fir.box<none>) -> !fir.box<!fir.array<?x?xi32>> 1886// CHECK: %[[FLAG_SET:.*]] = arith.constant 1 : i64 1887// CHECK: %[[FLAG_EMPTY:.*]] = arith.constant 0 : i64 1888// CHECK: fir.store %[[FLAG_EMPTY]] to %[[FLAG_ALLOC]] : !fir.ref<i64> 1889// CHECK: %[[MAX:.*]] = arith.constant 2147483647 : i32 1890// CHECK: %[[C_INDEX1:.*]] = arith.constant 1 : index 1891// CHECK: %[[DIM_INDEX0:.*]] = arith.constant 0 : index 1892// 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]] : index 1894// CHECK: %[[DIM_INDEX1:.*]] = arith.constant 1 : index 1895// 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]] : index 1897// 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 : i64 1900// 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]] : i32 1904// CHECK: %[[ISFIRSTL:.*]] = fir.convert %[[ISFIRST]] : (i64) -> i1 1905// CHECK: %[[ISFIRSTNOT:.*]] = arith.xori %[[ISFIRSTL]], %true : i1 1906// CHECK: %[[ORCOND:.*]] = arith.ori %[[NEW_MIN]], %[[ISFIRSTNOT]] : i1 1907// 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 : i64 1910// CHECK: %[[OUTARR_IDX0:.*]] = arith.constant 0 : index 1911// 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) -> i64 1913// CHECK: %[[FORTRAN_IDX1:.*]] = arith.addi %[[ITER1_I64]], %[[ONE]] : i64 1914// CHECK: fir.store %[[FORTRAN_IDX1]] to %[[OUTARR_ITEM0]] : !fir.ref<i64> 1915// CHECK: %[[OUTARR_IDX1:.*]] = arith.constant 1 : index 1916// 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) -> i64 1918// CHECK: %[[FORTRAN_IDX0:.*]] = arith.addi %[[ITER0_I64]], %[[ONE]] : i64 1919// CHECK: fir.store %[[FORTRAN_IDX0]] to %[[OUTARR_ITEM1]] : !fir.ref<i64> 1920// CHECK: fir.result %[[INARR_ITEMVAL]] : i32 1921// CHECK: } else { 1922// CHECK: fir.result %[[MIN1]] : i32 1923// CHECK: } 1924// CHECK: fir.result %[[IF_NEW_MIN:.*]] : i32 1925// CHECK: } 1926// CHECK: fir.result %[[DOLOOP1:.*]] : i32 1927// 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: return 1931// CHECK: } 1932 1933// ----- 1934// Check Minloc simplifies correctly for 1D case with scalar mask and f64 input 1935 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 : index 1939 %c1 = arith.constant 1 : index 1940 %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 : index 1947 %false = arith.constant false 1948 %7 = fir.zero_bits !fir.heap<!fir.array<?xi32>> 1949 %c0 = arith.constant 0 : index 1950 %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 : i32 1955 %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) -> i32 1958 %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 : index 1963 %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 : index 1968 %c0_2 = arith.constant 0 : index 1969 %22 = arith.subi %c1, %c1_1 : index 1970 %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) -> i32 1972 %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 i32 1991// CHECK: %[[INIT_OUT_IDX:.*]] = arith.constant 0 : i32 1992// CHECK: %[[OUTARR_SIZE:.*]] = arith.constant 1 : index 1993// 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 : index 1997// 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: %[[BOX_MASK:.*]] = fir.convert %[[BOX_MASK_NONE]] : (!fir.box<none>) -> !fir.box<!fir.array<1xi1>> 2000// CHECK: %[[MASK_IDX0:.*]] = arith.constant 0 : index 2001// CHECK: %[[MASK_ITEM:.*]] = fir.coordinate_of %[[BOX_MASK]], %[[MASK_IDX0]] : (!fir.box<!fir.array<1xi1>>, index) -> !fir.ref<i1> 2002// CHECK: %[[MASK:.*]] = fir.load %[[MASK_ITEM]] : !fir.ref<i1> 2003// CHECK: %[[INIT_RES:.*]] = fir.if %[[MASK]] -> (f64) { 2004// CHECK: %[[C_INDEX0:.*]] = arith.constant 0 : index 2005// CHECK: %[[BOX_INARR:.*]] = fir.convert %[[BOX_INARR_NONE]] : (!fir.box<none>) -> !fir.box<!fir.array<?xf64>> 2006// CHECK: %[[FLAG_SET:.*]] = arith.constant 1 : i32 2007// CHECK: %[[FLAG_EMPTY:.*]] = arith.constant 0 : i32 2008// CHECK: fir.store %[[FLAG_EMPTY]] to %[[FLAG_ALLOC]] : !fir.ref<i32> 2009// CHECK: %[[MAX:.*]] = arith.constant 0x7FF0000000000000 : f64 2010// CHECK: %[[C_INDEX1:.*]] = arith.constant 1 : index 2011// CHECK: %[[DIM_INDEX:.*]] = arith.constant 0 : index 2012// CHECK: %[[DIMS:.*]]:3 = fir.box_dims %[[BOX_INARR]], %[[DIM_INDEX]] : (!fir.box<!fir.array<?xf64>>, index) -> (index, index, index) 2013// CHECK: %[[EXTENT:.*]] = arith.subi %[[DIMS]]#1, %[[C_INDEX1]] : index 2014// CHECK: %[[DOLOOP:.*]] = fir.do_loop %[[ITER:.*]] = %[[C_INDEX0]] to %[[EXTENT]] step %[[C_INDEX1]] iter_args(%[[MIN:.*]] = %[[MAX]]) -> (f64) { 2015// CHECK: %[[FLAG_SET2:.*]] = arith.constant 1 : i32 2016// CHECK: %[[ISFIRST:.*]] = fir.load %[[FLAG_ALLOC]] : !fir.ref<i32> 2017// CHECK: %[[INARR_ITEM:.*]] = fir.coordinate_of %[[BOX_INARR]], %[[ITER]] : (!fir.box<!fir.array<?xf64>>, index) -> !fir.ref<f64> 2018// CHECK: %[[INARR_ITEMVAL:.*]] = fir.load %[[INARR_ITEM]] : !fir.ref<f64> 2019// CHECK: %[[NEW_MIN:.*]] = arith.cmpf olt, %[[INARR_ITEMVAL]], %arg4 fastmath<contract> : f64 2020// CHECK: %[[CONDRED:.*]] = arith.cmpf une, %arg4, %arg4 fastmath<contract> : f64 2021// CHECK: %[[CONDELEM:.*]] = arith.cmpf oeq, %[[INARR_ITEMVAL]], %[[INARR_ITEMVAL]] fastmath<contract> : f64 2022// CHECK: %[[ANDCOND:.*]] = arith.andi %[[CONDRED]], %[[CONDELEM]] : i1 2023// CHECK: %[[NEW_MIN2:.*]] = arith.ori %[[NEW_MIN]], %[[ANDCOND]] : i1 2024// CHECK: %[[ISFIRSTL:.*]] = fir.convert %[[ISFIRST]] : (i32) -> i1 2025// CHECK: %[[ISFIRSTNOT:.*]] = arith.xori %[[ISFIRSTL]], %true : i1 2026// CHECK: %[[ORCOND:.*]] = arith.ori %[[NEW_MIN2]], %[[ISFIRSTNOT]] : i1 2027// CHECK: %[[IF_NEW_MIN:.*]] = fir.if %[[ORCOND]] -> (f64) { 2028// CHECK: %[[ONE:.*]] = arith.constant 1 : i32 2029// CHECK: %[[OUTARR_IDX:.*]] = arith.constant 0 : index 2030// CHECK: %[[OUTARR_ITEM:.*]] = fir.coordinate_of %[[BOX_OUTARR]], %[[OUTARR_IDX]] : (!fir.box<!fir.heap<!fir.array<1xi32>>>, index) -> !fir.ref<i32> 2031// CHECK: %[[ITER_I32:.*]] = fir.convert %[[ITER]] : (index) -> i32 2032// CHECK: %[[FORTRAN_IDX:.*]] = arith.addi %[[ITER_I32]], %[[ONE]] : i32 2033// CHECK: fir.store %[[FORTRAN_IDX]] to %[[OUTARR_ITEM]] : !fir.ref<i32> 2034// CHECK: fir.result %[[INARR_ITEMVAL]] : f64 2035// CHECK: } else { 2036// CHECK: fir.result %[[MIN]] : f64 2037// CHECK: } 2038// CHECK: fir.result %[[IF_NEW_MIN:.*]] : f64 2039// CHECK: } 2040// CHECK: } 2041// CHECK: %[[REF_BOX_OUTARR:.*]] = fir.convert %[[VAL_0]] : (!fir.ref<!fir.box<none>>) -> !fir.ref<!fir.box<!fir.heap<!fir.array<1xi32>>>> 2042// CHECK: fir.store %[[BOX_OUTARR]] to %[[REF_BOX_OUTARR]] : !fir.ref<!fir.box<!fir.heap<!fir.array<1xi32>>>> 2043// CHECK: return 2044// CHECK: } 2045 2046// ----- 2047// Check Minloc is not simplified when BACK arg is set 2048 2049func.func @_QPtestminloc_doesntwork1d_back(%arg0: !fir.ref<!fir.array<10xi32>> {fir.bindc_name = "a"}) -> !fir.array<1xi32> { 2050 %0 = fir.alloca !fir.box<!fir.heap<!fir.array<?xi32>>> 2051 %c10 = arith.constant 10 : index 2052 %c1 = arith.constant 1 : index 2053 %1 = fir.alloca !fir.array<1xi32> {bindc_name = "testminloc_doesntwork1d_back", uniq_name = "_QFtestminloc_doesntwork1d_backEtestminloc_doesntwork1d_back"} 2054 %2 = fir.shape %c1 : (index) -> !fir.shape<1> 2055 %3 = fir.array_load %1(%2) : (!fir.ref<!fir.array<1xi32>>, !fir.shape<1>) -> !fir.array<1xi32> 2056 %4 = fir.shape %c10 : (index) -> !fir.shape<1> 2057 %5 = fir.embox %arg0(%4) : (!fir.ref<!fir.array<10xi32>>, !fir.shape<1>) -> !fir.box<!fir.array<10xi32>> 2058 %true = arith.constant true 2059 %6 = fir.absent !fir.box<i1> 2060 %c4 = arith.constant 4 : index 2061 %7 = fir.zero_bits !fir.heap<!fir.array<?xi32>> 2062 %c0 = arith.constant 0 : index 2063 %8 = fir.shape %c0 : (index) -> !fir.shape<1> 2064 %9 = fir.embox %7(%8) : (!fir.heap<!fir.array<?xi32>>, !fir.shape<1>) -> !fir.box<!fir.heap<!fir.array<?xi32>>> 2065 fir.store %9 to %0 : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>> 2066 %10 = fir.address_of(@_QQclX3791f01d699716ba5914ae524c6a8dee) : !fir.ref<!fir.char<1,62>> 2067 %c4_i32 = arith.constant 4 : i32 2068 %11 = fir.convert %0 : (!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>) -> !fir.ref<!fir.box<none>> 2069 %12 = fir.convert %5 : (!fir.box<!fir.array<10xi32>>) -> !fir.box<none> 2070 %13 = fir.convert %c4 : (index) -> i32 2071 %14 = fir.convert %10 : (!fir.ref<!fir.char<1,62>>) -> !fir.ref<i8> 2072 %15 = fir.convert %6 : (!fir.box<i1>) -> !fir.box<none> 2073 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) -> () 2074 %17 = fir.load %0 : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>> 2075 %c0_0 = arith.constant 0 : index 2076 %18:3 = fir.box_dims %17, %c0_0 : (!fir.box<!fir.heap<!fir.array<?xi32>>>, index) -> (index, index, index) 2077 %19 = fir.box_addr %17 : (!fir.box<!fir.heap<!fir.array<?xi32>>>) -> !fir.heap<!fir.array<?xi32>> 2078 %20 = fir.shape_shift %18#0, %18#1 : (index, index) -> !fir.shapeshift<1> 2079 %21 = fir.array_load %19(%20) : (!fir.heap<!fir.array<?xi32>>, !fir.shapeshift<1>) -> !fir.array<?xi32> 2080 %c1_1 = arith.constant 1 : index 2081 %c0_2 = arith.constant 0 : index 2082 %22 = arith.subi %c1, %c1_1 : index 2083 %23 = fir.do_loop %arg1 = %c0_2 to %22 step %c1_1 unordered iter_args(%arg2 = %3) -> (!fir.array<1xi32>) { 2084 %25 = fir.array_fetch %21, %arg1 : (!fir.array<?xi32>, index) -> i32 2085 %26 = fir.array_update %arg2, %25, %arg1 : (!fir.array<1xi32>, i32, index) -> !fir.array<1xi32> 2086 fir.result %26 : !fir.array<1xi32> 2087 } 2088 fir.array_merge_store %3, %23 to %1 : !fir.array<1xi32>, !fir.array<1xi32>, !fir.ref<!fir.array<1xi32>> 2089 fir.freemem %19 : !fir.heap<!fir.array<?xi32>> 2090 %24 = fir.load %1 : !fir.ref<!fir.array<1xi32>> 2091 return %24 : !fir.array<1xi32> 2092} 2093 2094// CHECK-LABEL: func.func @_QPtestminloc_doesntwork1d_back( 2095// CHECK-SAME: %[[ARR:.*]]: !fir.ref<!fir.array<10xi32>> {fir.bindc_name = "a"}) -> !fir.array<1xi32> { 2096// CHECK-NOT: fir.call @_FortranAMinlocInteger4x1_i32_contract_simplified({{.*}}) fastmath<contract> : (!fir.ref<!fir.box<none>>, !fir.box<none>, !fir.box<none>) -> () 2097// CHECK: fir.call @_FortranAMinlocInteger4({{.*}}) fastmath<contract> : (!fir.ref<!fir.box<none>>, !fir.box<none>, i32, !fir.ref<i8>, i32, !fir.box<none>, i1) -> () 2098// CHECK-NOT: fir.call @_FortranAMinlocInteger4x1_i32_contract_simplified({{.*}}) fastmath<contract> : (!fir.ref<!fir.box<none>>, !fir.box<none>, !fir.box<none>) -> () 2099 2100// ----- 2101// Check Minloc is simplified when DIM arg is set so long as the result is scalar 2102 2103func.func @_QPtestminloc_1d_dim(%arg0: !fir.ref<!fir.array<10xi32>> {fir.bindc_name = "a"}) -> !fir.array<1xi32> { 2104 %0 = fir.alloca !fir.box<!fir.heap<i32>> 2105 %c10 = arith.constant 10 : index 2106 %c1 = arith.constant 1 : index 2107 %1 = fir.alloca !fir.array<1xi32> {bindc_name = "testminloc_1d_dim", uniq_name = "_QFtestminloc_1d_dimEtestminloc_1d_dim"} 2108 %2 = fir.shape %c1 : (index) -> !fir.shape<1> 2109 %3 = fir.array_load %1(%2) : (!fir.ref<!fir.array<1xi32>>, !fir.shape<1>) -> !fir.array<1xi32> 2110 %4 = fir.shape %c10 : (index) -> !fir.shape<1> 2111 %5 = fir.embox %arg0(%4) : (!fir.ref<!fir.array<10xi32>>, !fir.shape<1>) -> !fir.box<!fir.array<10xi32>> 2112 %c1_i32 = arith.constant 1 : i32 2113 %6 = fir.absent !fir.box<i1> 2114 %c4 = arith.constant 4 : index 2115 %false = arith.constant false 2116 %7 = fir.zero_bits !fir.heap<i32> 2117 %8 = fir.embox %7 : (!fir.heap<i32>) -> !fir.box<!fir.heap<i32>> 2118 fir.store %8 to %0 : !fir.ref<!fir.box<!fir.heap<i32>>> 2119 %9 = fir.address_of(@_QQclXcfcf4329f25d06a4b02a0c8f532ee9df) : !fir.ref<!fir.char<1,61>> 2120 %c4_i32 = arith.constant 4 : i32 2121 %10 = fir.convert %0 : (!fir.ref<!fir.box<!fir.heap<i32>>>) -> !fir.ref<!fir.box<none>> 2122 %11 = fir.convert %5 : (!fir.box<!fir.array<10xi32>>) -> !fir.box<none> 2123 %12 = fir.convert %c4 : (index) -> i32 2124 %13 = fir.convert %9 : (!fir.ref<!fir.char<1,61>>) -> !fir.ref<i8> 2125 %14 = fir.convert %6 : (!fir.box<i1>) -> !fir.box<none> 2126 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) -> () 2127 %16 = fir.load %0 : !fir.ref<!fir.box<!fir.heap<i32>>> 2128 %17 = fir.box_addr %16 : (!fir.box<!fir.heap<i32>>) -> !fir.heap<i32> 2129 %18 = fir.load %17 : !fir.heap<i32> 2130 fir.freemem %17 : !fir.heap<i32> 2131 %c1_0 = arith.constant 1 : index 2132 %c0 = arith.constant 0 : index 2133 %19 = arith.subi %c1, %c1_0 : index 2134 %20 = fir.do_loop %arg1 = %c0 to %19 step %c1_0 unordered iter_args(%arg2 = %3) -> (!fir.array<1xi32>) { 2135 %22 = fir.array_update %arg2, %18, %arg1 : (!fir.array<1xi32>, i32, index) -> !fir.array<1xi32> 2136 fir.result %22 : !fir.array<1xi32> 2137 } 2138 fir.array_merge_store %3, %20 to %1 : !fir.array<1xi32>, !fir.array<1xi32>, !fir.ref<!fir.array<1xi32>> 2139 %21 = fir.load %1 : !fir.ref<!fir.array<1xi32>> 2140 return %21 : !fir.array<1xi32> 2141} 2142// CHECK-LABEL: func.func @_QPtestminloc_1d_dim( 2143// CHECK-SAME: %[[ARR:.*]]: !fir.ref<!fir.array<10xi32>> {fir.bindc_name = "a"}) -> !fir.array<1xi32> { 2144// CHECK: fir.call @_FortranAMinlocDimx1_i32_i32_contract_simplified({{.*}}) fastmath<contract> : (!fir.ref<!fir.box<none>>, !fir.box<none>, !fir.box<none>) -> () 2145 2146// 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>} { 2147// CHECK-NEXT: %[[V0:.*]] = fir.alloca i32 2148// CHECK-NEXT: %c0_i32 = arith.constant 0 : i32 2149// CHECK-NEXT: %c1 = arith.constant 1 : index 2150// CHECK-NEXT: %[[V1:.*]] = fir.allocmem !fir.array<1xi32> 2151// CHECK-NEXT: %[[V2:.*]] = fir.shape %c1 : (index) -> !fir.shape<1> 2152// CHECK-NEXT: %[[V3:.*]] = fir.embox %[[V1]](%[[V2]]) : (!fir.heap<!fir.array<1xi32>>, !fir.shape<1>) -> !fir.box<!fir.heap<!fir.array<1xi32>>> 2153// CHECK-NEXT: %c0 = arith.constant 0 : index 2154// CHECK-NEXT: %[[V4:.*]] = fir.coordinate_of %[[V3]], %c0 : (!fir.box<!fir.heap<!fir.array<1xi32>>>, index) -> !fir.ref<i32> 2155// CHECK-NEXT: fir.store %c0_i32 to %[[V4]] : !fir.ref<i32> 2156// CHECK-NEXT: %c0_0 = arith.constant 0 : index 2157// CHECK-NEXT: %[[V5:.*]] = fir.convert %arg1 : (!fir.box<none>) -> !fir.box<!fir.array<?xi32>> 2158// CHECK-NEXT: %c1_i32 = arith.constant 1 : i32 2159// CHECK-NEXT: %c0_i32_1 = arith.constant 0 : i32 2160// CHECK-NEXT: fir.store %c0_i32_1 to %[[V0]] : !fir.ref<i32> 2161// CHECK-NEXT: %c2147483647_i32 = arith.constant 2147483647 : i32 2162// CHECK-NEXT: %c1_2 = arith.constant 1 : index 2163// CHECK-NEXT: %c0_3 = arith.constant 0 : index 2164// CHECK-NEXT: %[[V6:.*]]:3 = fir.box_dims %[[V5]], %c0_3 : (!fir.box<!fir.array<?xi32>>, index) -> (index, index, index) 2165// CHECK-NEXT: %[[V7:.*]] = arith.subi %[[V6]]#1, %c1_2 : index 2166// CHECK-NEXT: %[[V8:.*]] = fir.do_loop %arg3 = %c0_0 to %[[V7]] step %c1_2 iter_args(%arg4 = %c2147483647_i32) -> (i32) { 2167// CHECK-NEXT: %c1_i32_4 = arith.constant 1 : i32 2168// CHECK-NEXT: %[[ISFIRST:.*]] = fir.load %[[FLAG_ALLOC]] : !fir.ref<i32> 2169// CHECK-NEXT: %[[V12:.*]] = fir.coordinate_of %[[V5]], %arg3 : (!fir.box<!fir.array<?xi32>>, index) -> !fir.ref<i32> 2170// CHECK-NEXT: %[[V13:.*]] = fir.load %[[V12]] : !fir.ref<i32> 2171// CHECK-NEXT: %[[V14:.*]] = arith.cmpi slt, %[[V13]], %arg4 : i32 2172// CHECK-NEXT: %[[ISFIRSTL:.*]] = fir.convert %[[ISFIRST]] : (i32) -> i1 2173// CHECK-NEXT: %true = arith.constant true 2174// CHECK-NEXT: %[[ISFIRSTNOT:.*]] = arith.xori %[[ISFIRSTL]], %true : i1 2175// CHECK-NEXT: %[[ORCOND:.*]] = arith.ori %[[V14]], %[[ISFIRSTNOT]] : i1 2176// CHECK-NEXT: %[[V15:.*]] = fir.if %[[ORCOND]] -> (i32) { 2177// CHECK-NEXT: fir.store %c1_i32_4 to %[[V0]] : !fir.ref<i32> 2178// CHECK-NEXT: %c1_i32_5 = arith.constant 1 : i32 2179// CHECK-NEXT: %c0_6 = arith.constant 0 : index 2180// CHECK-NEXT: %[[V16:.*]] = fir.coordinate_of %[[V3]], %c0_6 : (!fir.box<!fir.heap<!fir.array<1xi32>>>, index) -> !fir.ref<i32> 2181// CHECK-NEXT: %[[V17:.*]] = fir.convert %arg3 : (index) -> i32 2182// CHECK-NEXT: %[[V18:.*]] = arith.addi %[[V17]], %c1_i32_5 : i32 2183// CHECK-NEXT: fir.store %[[V18]] to %[[V16]] : !fir.ref<i32> 2184// CHECK-NEXT: fir.result %[[V13]] : i32 2185// CHECK-NEXT: } else { 2186// CHECK-NEXT: fir.result %arg4 : i32 2187// CHECK-NEXT: } 2188// CHECK-NEXT: fir.result %[[V15]] : i32 2189// CHECK-NEXT: } 2190// CHECK-NEXT: %[[V11:.*]] = fir.convert %arg0 : (!fir.ref<!fir.box<none>>) -> !fir.ref<!fir.box<!fir.heap<i32>>> 2191// CHECK-NEXT: %[[V12:.*]] = fir.convert %[[V1]] : (!fir.heap<!fir.array<1xi32>>) -> !fir.heap<i32> 2192// CHECK-NEXT: %[[V13:.*]] = fir.embox %[[V12]] : (!fir.heap<i32>) -> !fir.box<!fir.heap<i32>> 2193// CHECK-NEXT: fir.store %[[V13]] to %[[V11]] : !fir.ref<!fir.box<!fir.heap<i32>>> 2194// CHECK-NEXT: return 2195// CHECK-NEXT: } 2196 2197 2198 2199// ----- 2200// Check Minloc is not simplified when dimension of inputArr is unknown 2201 2202func.func @_QPtestminloc_doesntwork1d_unknownsize(%arg0: !fir.box<!fir.array<?xi32>> {fir.bindc_name = "a"}) -> !fir.array<1xi32> { 2203 %0 = fir.alloca !fir.box<!fir.heap<!fir.array<?xi32>>> 2204 %c1 = arith.constant 1 : index 2205 %1 = fir.alloca !fir.array<1xi32> {bindc_name = "testminloc_doesntwork1d_unknownsize", uniq_name = "_QFtestminloc_doesntwork1d_unknownsizeEtestminloc_doesntwork1d_unknownsize"} 2206 %2 = fir.shape %c1 : (index) -> !fir.shape<1> 2207 %3 = fir.array_load %1(%2) : (!fir.ref<!fir.array<1xi32>>, !fir.shape<1>) -> !fir.array<1xi32> 2208 %4 = fir.absent !fir.box<i1> 2209 %c4 = arith.constant 4 : index 2210 %false = arith.constant false 2211 %5 = fir.zero_bits !fir.heap<!fir.array<?xi32>> 2212 %c0 = arith.constant 0 : index 2213 %6 = fir.shape %c0 : (index) -> !fir.shape<1> 2214 %7 = fir.embox %5(%6) : (!fir.heap<!fir.array<?xi32>>, !fir.shape<1>) -> !fir.box<!fir.heap<!fir.array<?xi32>>> 2215 fir.store %7 to %0 : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>> 2216 %8 = fir.address_of(@_QQclX2064f5e9298c2127417d52b69eac898e) : !fir.ref<!fir.char<1,69>> 2217 %c4_i32 = arith.constant 4 : i32 2218 %9 = fir.convert %0 : (!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>) -> !fir.ref<!fir.box<none>> 2219 %10 = fir.convert %arg0 : (!fir.box<!fir.array<?xi32>>) -> !fir.box<none> 2220 %11 = fir.convert %c4 : (index) -> i32 2221 %12 = fir.convert %8 : (!fir.ref<!fir.char<1,69>>) -> !fir.ref<i8> 2222 %13 = fir.convert %4 : (!fir.box<i1>) -> !fir.box<none> 2223 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) -> () 2224 %15 = fir.load %0 : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>> 2225 %c0_0 = arith.constant 0 : index 2226 %16:3 = fir.box_dims %15, %c0_0 : (!fir.box<!fir.heap<!fir.array<?xi32>>>, index) -> (index, index, index) 2227 %17 = fir.box_addr %15 : (!fir.box<!fir.heap<!fir.array<?xi32>>>) -> !fir.heap<!fir.array<?xi32>> 2228 %18 = fir.shape_shift %16#0, %16#1 : (index, index) -> !fir.shapeshift<1> 2229 %19 = fir.array_load %17(%18) : (!fir.heap<!fir.array<?xi32>>, !fir.shapeshift<1>) -> !fir.array<?xi32> 2230 %c1_1 = arith.constant 1 : index 2231 %c0_2 = arith.constant 0 : index 2232 %20 = arith.subi %c1, %c1_1 : index 2233 %21 = fir.do_loop %arg1 = %c0_2 to %20 step %c1_1 unordered iter_args(%arg2 = %3) -> (!fir.array<1xi32>) { 2234 %23 = fir.array_fetch %19, %arg1 : (!fir.array<?xi32>, index) -> i32 2235 %24 = fir.array_update %arg2, %23, %arg1 : (!fir.array<1xi32>, i32, index) -> !fir.array<1xi32> 2236 fir.result %24 : !fir.array<1xi32> 2237 } 2238 fir.array_merge_store %3, %21 to %1 : !fir.array<1xi32>, !fir.array<1xi32>, !fir.ref<!fir.array<1xi32>> 2239 fir.freemem %17 : !fir.heap<!fir.array<?xi32>> 2240 %22 = fir.load %1 : !fir.ref<!fir.array<1xi32>> 2241 return %22 : !fir.array<1xi32> 2242} 2243// CHECK-LABEL: func.func @_QPtestminloc_doesntwork1d_unknownsize( 2244// CHECK-SAME: %[[ARR:.*]]: !fir.box<!fir.array<?xi32>> {fir.bindc_name = "a"}) -> !fir.array<1xi32> { 2245// CHECK-NOT: fir.call @_FortranAMinlocInteger4x1_i32_contract_simplified({{.*}}) fastmath<contract> : (!fir.ref<!fir.box<none>>, !fir.box<none>, !fir.box<none>) -> () 2246// CHECK: fir.call @_FortranAMinlocInteger4({{.*}}) fastmath<contract> : (!fir.ref<!fir.box<none>>, !fir.box<none>, i32, !fir.ref<i8>, i32, !fir.box<none>, i1) -> () 2247// CHECK-NOT: fir.call @_FortranAMinlocInteger4x1_i32_contract_simplified({{.*}}) fastmath<contract> : (!fir.ref<!fir.box<none>>, !fir.box<none>, !fir.box<none>) -> () 2248 2249// ----- 2250// Check Minloc is not simplified when inputArr is characterType 2251 2252func.func @_QPtestminloc_doesntwork1d_chars(%arg0: !fir.boxchar<1> {fir.bindc_name = "a"}) -> !fir.array<1xi32> { 2253 %0 = fir.alloca !fir.box<!fir.heap<!fir.array<?xi32>>> 2254 %1:2 = fir.unboxchar %arg0 : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1,?>>, index) 2255 %2 = fir.convert %1#0 : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<!fir.array<10x!fir.char<1>>> 2256 %c10 = arith.constant 10 : index 2257 %c1 = arith.constant 1 : index 2258 %3 = fir.alloca !fir.array<1xi32> {bindc_name = "testminloc_doesntwork1d_chars", uniq_name = "_QFtestminloc_doesntwork1d_charsEtestminloc_doesntwork1d_chars"} 2259 %4 = fir.shape %c1 : (index) -> !fir.shape<1> 2260 %5 = fir.array_load %3(%4) : (!fir.ref<!fir.array<1xi32>>, !fir.shape<1>) -> !fir.array<1xi32> 2261 %6 = fir.shape %c10 : (index) -> !fir.shape<1> 2262 %7 = fir.embox %2(%6) : (!fir.ref<!fir.array<10x!fir.char<1>>>, !fir.shape<1>) -> !fir.box<!fir.array<10x!fir.char<1>>> 2263 %8 = fir.absent !fir.box<i1> 2264 %c4 = arith.constant 4 : index 2265 %false = arith.constant false 2266 %9 = fir.zero_bits !fir.heap<!fir.array<?xi32>> 2267 %c0 = arith.constant 0 : index 2268 %10 = fir.shape %c0 : (index) -> !fir.shape<1> 2269 %11 = fir.embox %9(%10) : (!fir.heap<!fir.array<?xi32>>, !fir.shape<1>) -> !fir.box<!fir.heap<!fir.array<?xi32>>> 2270 fir.store %11 to %0 : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>> 2271 %12 = fir.address_of(@_QQclX74460ff3ef22ea53671c22344e1556b9) : !fir.ref<!fir.char<1,41>> 2272 %c4_i32 = arith.constant 4 : i32 2273 %13 = fir.convert %0 : (!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>) -> !fir.ref<!fir.box<none>> 2274 %14 = fir.convert %7 : (!fir.box<!fir.array<10x!fir.char<1>>>) -> !fir.box<none> 2275 %15 = fir.convert %c4 : (index) -> i32 2276 %16 = fir.convert %12 : (!fir.ref<!fir.char<1,41>>) -> !fir.ref<i8> 2277 %17 = fir.convert %8 : (!fir.box<i1>) -> !fir.box<none> 2278 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) -> () 2279 %19 = fir.load %0 : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>> 2280 %c0_0 = arith.constant 0 : index 2281 %20:3 = fir.box_dims %19, %c0_0 : (!fir.box<!fir.heap<!fir.array<?xi32>>>, index) -> (index, index, index) 2282 %21 = fir.box_addr %19 : (!fir.box<!fir.heap<!fir.array<?xi32>>>) -> !fir.heap<!fir.array<?xi32>> 2283 %22 = fir.shape_shift %20#0, %20#1 : (index, index) -> !fir.shapeshift<1> 2284 %23 = fir.array_load %21(%22) : (!fir.heap<!fir.array<?xi32>>, !fir.shapeshift<1>) -> !fir.array<?xi32> 2285 %c1_1 = arith.constant 1 : index 2286 %c0_2 = arith.constant 0 : index 2287 %24 = arith.subi %c1, %c1_1 : index 2288 %25 = fir.do_loop %arg1 = %c0_2 to %24 step %c1_1 unordered iter_args(%arg2 = %5) -> (!fir.array<1xi32>) { 2289 %27 = fir.array_fetch %23, %arg1 : (!fir.array<?xi32>, index) -> i32 2290 %28 = fir.array_update %arg2, %27, %arg1 : (!fir.array<1xi32>, i32, index) -> !fir.array<1xi32> 2291 fir.result %28 : !fir.array<1xi32> 2292 } 2293 fir.array_merge_store %5, %25 to %3 : !fir.array<1xi32>, !fir.array<1xi32>, !fir.ref<!fir.array<1xi32>> 2294 fir.freemem %21 : !fir.heap<!fir.array<?xi32>> 2295 %26 = fir.load %3 : !fir.ref<!fir.array<1xi32>> 2296 return %26 : !fir.array<1xi32> 2297} 2298 2299// CHECK-LABEL: func.func @_QPtestminloc_doesntwork1d_chars( 2300// CHECK-SAME: %[[ARR:.*]]: !fir.boxchar<1> {fir.bindc_name = "a"}) -> !fir.array<1xi32> { 2301// CHECK-NOT: fir.call @_FortranAMinlocCharacterx1_i32_contract_simplified({{.*}}) fastmath<contract> : (!fir.ref<!fir.box<none>>, !fir.box<none>, !fir.box<none>) -> () 2302// CHECK: fir.call @_FortranAMinlocCharacter({{.*}}) fastmath<contract> : (!fir.ref<!fir.box<none>>, !fir.box<none>, i32, !fir.ref<i8>, i32, !fir.box<none>, i1) -> () 2303// CHECK-NOT: fir.call @_FortranAMinlocCharacterx1_i32_contract_simplified({{.*}}) fastmath<contract> : (!fir.ref<!fir.box<none>>, !fir.box<none>, !fir.box<none>) -> () 2304 2305// ----- 2306// Check Minloc is not simplified when mask is unknown rank 2307 2308func.func @_QPtestminloc_doesntwork1d_unknownmask(%arg0: !fir.ref<!fir.array<10xi32>> {fir.bindc_name = "a"}) -> !fir.array<1xi32> { 2309 %0 = fir.alloca !fir.box<!fir.heap<!fir.array<?xi32>>> 2310 %c10 = arith.constant 10 : index 2311 %1 = fir.alloca i32 {bindc_name = "b", uniq_name = "_QFtestminloc_doesntwork1d_unknownmaskEb"} 2312 %2 = fir.alloca !fir.box<!fir.heap<!fir.array<?x!fir.logical<4>>>> {bindc_name = "mask", uniq_name = "_QFtestminloc_doesntwork1d_unknownmaskEmask"} 2313 %3 = fir.alloca !fir.heap<!fir.array<?x!fir.logical<4>>> {uniq_name = "_QFtestminloc_doesntwork1d_unknownmaskEmask.addr"} 2314 %4 = fir.alloca index {uniq_name = "_QFtestminloc_doesntwork1d_unknownmaskEmask.lb0"} 2315 %5 = fir.alloca index {uniq_name = "_QFtestminloc_doesntwork1d_unknownmaskEmask.ext0"} 2316 %6 = fir.zero_bits !fir.heap<!fir.array<?x!fir.logical<4>>> 2317 fir.store %6 to %3 : !fir.ref<!fir.heap<!fir.array<?x!fir.logical<4>>>> 2318 %c1 = arith.constant 1 : index 2319 %7 = fir.alloca !fir.array<1xi32> {bindc_name = "testminloc_doesntwork1d_unknownmask", uniq_name = "_QFtestminloc_doesntwork1d_unknownmaskEtestminloc_doesntwork1d_unknownmask"} 2320 %8 = fir.load %1 : !fir.ref<i32> 2321 %9 = fir.convert %8 : (i32) -> index 2322 %c0 = arith.constant 0 : index 2323 %10 = arith.cmpi sgt, %9, %c0 : index 2324 %11 = arith.select %10, %9, %c0 : index 2325 %12 = fir.allocmem !fir.array<?x!fir.logical<4>>, %11 {fir.must_be_heap = true, uniq_name = "_QFtestminloc_doesntwork1d_unknownmaskEmask.alloc"} 2326 fir.store %12 to %3 : !fir.ref<!fir.heap<!fir.array<?x!fir.logical<4>>>> 2327 fir.store %11 to %5 : !fir.ref<index> 2328 %c1_0 = arith.constant 1 : index 2329 fir.store %c1_0 to %4 : !fir.ref<index> 2330 %13 = fir.shape %c1 : (index) -> !fir.shape<1> 2331 %14 = fir.array_load %7(%13) : (!fir.ref<!fir.array<1xi32>>, !fir.shape<1>) -> !fir.array<1xi32> 2332 %15 = fir.shape %c10 : (index) -> !fir.shape<1> 2333 %16 = fir.embox %arg0(%15) : (!fir.ref<!fir.array<10xi32>>, !fir.shape<1>) -> !fir.box<!fir.array<10xi32>> 2334 %17 = fir.load %3 : !fir.ref<!fir.heap<!fir.array<?x!fir.logical<4>>>> 2335 %18 = fir.convert %17 : (!fir.heap<!fir.array<?x!fir.logical<4>>>) -> i64 2336 %c0_i64 = arith.constant 0 : i64 2337 %19 = arith.cmpi ne, %18, %c0_i64 : i64 2338 %20 = fir.load %4 : !fir.ref<index> 2339 %21 = fir.load %5 : !fir.ref<index> 2340 %22 = fir.load %3 : !fir.ref<!fir.heap<!fir.array<?x!fir.logical<4>>>> 2341 %23 = fir.shape_shift %20, %21 : (index, index) -> !fir.shapeshift<1> 2342 %24 = fir.embox %22(%23) : (!fir.heap<!fir.array<?x!fir.logical<4>>>, !fir.shapeshift<1>) -> !fir.box<!fir.array<?x!fir.logical<4>>> 2343 %25 = fir.absent !fir.box<!fir.array<?x!fir.logical<4>>> 2344 %26 = arith.select %19, %24, %25 : !fir.box<!fir.array<?x!fir.logical<4>>> 2345 %c4 = arith.constant 4 : index 2346 %false = arith.constant false 2347 %27 = fir.zero_bits !fir.heap<!fir.array<?xi32>> 2348 %c0_1 = arith.constant 0 : index 2349 %28 = fir.shape %c0_1 : (index) -> !fir.shape<1> 2350 %29 = fir.embox %27(%28) : (!fir.heap<!fir.array<?xi32>>, !fir.shape<1>) -> !fir.box<!fir.heap<!fir.array<?xi32>>> 2351 fir.store %29 to %0 : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>> 2352 %30 = fir.address_of(@_QQclX74460ff3ef22ea53671c22344e1556b9) : !fir.ref<!fir.char<1,41>> 2353 %c7_i32 = arith.constant 7 : i32 2354 %31 = fir.convert %0 : (!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>) -> !fir.ref<!fir.box<none>> 2355 %32 = fir.convert %16 : (!fir.box<!fir.array<10xi32>>) -> !fir.box<none> 2356 %33 = fir.convert %c4 : (index) -> i32 2357 %34 = fir.convert %30 : (!fir.ref<!fir.char<1,41>>) -> !fir.ref<i8> 2358 %35 = fir.convert %26 : (!fir.box<!fir.array<?x!fir.logical<4>>>) -> !fir.box<none> 2359 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) -> () 2360 %37 = fir.load %0 : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>> 2361 %c0_2 = arith.constant 0 : index 2362 %38:3 = fir.box_dims %37, %c0_2 : (!fir.box<!fir.heap<!fir.array<?xi32>>>, index) -> (index, index, index) 2363 %39 = fir.box_addr %37 : (!fir.box<!fir.heap<!fir.array<?xi32>>>) -> !fir.heap<!fir.array<?xi32>> 2364 %40 = fir.shape_shift %38#0, %38#1 : (index, index) -> !fir.shapeshift<1> 2365 %41 = fir.array_load %39(%40) : (!fir.heap<!fir.array<?xi32>>, !fir.shapeshift<1>) -> !fir.array<?xi32> 2366 %c1_3 = arith.constant 1 : index 2367 %c0_4 = arith.constant 0 : index 2368 %42 = arith.subi %c1, %c1_3 : index 2369 %43 = fir.do_loop %arg1 = %c0_4 to %42 step %c1_3 unordered iter_args(%arg2 = %14) -> (!fir.array<1xi32>) { 2370 %45 = fir.array_fetch %41, %arg1 : (!fir.array<?xi32>, index) -> i32 2371 %46 = fir.array_update %arg2, %45, %arg1 : (!fir.array<1xi32>, i32, index) -> !fir.array<1xi32> 2372 fir.result %46 : !fir.array<1xi32> 2373 } 2374 fir.array_merge_store %14, %43 to %7 : !fir.array<1xi32>, !fir.array<1xi32>, !fir.ref<!fir.array<1xi32>> 2375 fir.freemem %39 : !fir.heap<!fir.array<?xi32>> 2376 %44 = fir.load %7 : !fir.ref<!fir.array<1xi32>> 2377 return %44 : !fir.array<1xi32> 2378} 2379 2380// CHECK-LABEL: func.func @_QPtestminloc_doesntwork1d_unknownmask( 2381// CHECK-SAME: %[[ARR:.*]]: !fir.ref<!fir.array<10xi32>> {fir.bindc_name = "a"}) -> !fir.array<1xi32> { 2382// CHECK-NOT: fir.call @_FortranAMinlocInteger4x1_i32_contract_simplified({{.*}}) fastmath<contract> : (!fir.ref<!fir.box<none>>, !fir.box<none>, !fir.box<none>) -> () 2383// CHECK: fir.call @_FortranAMinlocInteger4({{.*}}) fastmath<contract> : (!fir.ref<!fir.box<none>>, !fir.box<none>, i32, !fir.ref<i8>, i32, !fir.box<none>, i1) -> () 2384// CHECK-NOT: fir.call @_FortranAMinlocInteger4x1_i32_contract_simplified({{.*}}) fastmath<contract> : (!fir.ref<!fir.box<none>>, !fir.box<none>, !fir.box<none>) -> () 2385 2386// ----- 2387// Check Maxloc simplifies similarly to minloc 2388func.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> { 2389 %0 = fir.alloca !fir.box<!fir.heap<!fir.array<?xi32>>> 2390 %c10 = arith.constant 10 : index 2391 %c10_0 = arith.constant 10 : index 2392 %c1 = arith.constant 1 : index 2393 %1 = fir.alloca !fir.array<1xi32> {bindc_name = "testmaxloc_works1d", uniq_name = "_QFtestmaxloc_works1dEtestmaxloc_works1d"} 2394 %2 = fir.shape %c1 : (index) -> !fir.shape<1> 2395 %3 = fir.array_load %1(%2) : (!fir.ref<!fir.array<1xi32>>, !fir.shape<1>) -> !fir.array<1xi32> 2396 %4 = fir.shape %c10 : (index) -> !fir.shape<1> 2397 %5 = fir.embox %arg0(%4) : (!fir.ref<!fir.array<10xi32>>, !fir.shape<1>) -> !fir.box<!fir.array<10xi32>> 2398 %6 = fir.shape %c10_0 : (index) -> !fir.shape<1> 2399 %7 = fir.embox %arg1(%6) : (!fir.ref<!fir.array<10x!fir.logical<4>>>, !fir.shape<1>) -> !fir.box<!fir.array<10x!fir.logical<4>>> 2400 %c4 = arith.constant 4 : index 2401 %false = arith.constant false 2402 %8 = fir.zero_bits !fir.heap<!fir.array<?xi32>> 2403 %c0 = arith.constant 0 : index 2404 %9 = fir.shape %c0 : (index) -> !fir.shape<1> 2405 %10 = fir.embox %8(%9) : (!fir.heap<!fir.array<?xi32>>, !fir.shape<1>) -> !fir.box<!fir.heap<!fir.array<?xi32>>> 2406 fir.store %10 to %0 : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>> 2407 %11 = fir.address_of(@_QQclXea5bcf7f706678e1796661f8916f3379) : !fir.ref<!fir.char<1,55>> 2408 %c5_i32 = arith.constant 5 : i32 2409 %12 = fir.convert %0 : (!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>) -> !fir.ref<!fir.box<none>> 2410 %13 = fir.convert %5 : (!fir.box<!fir.array<10xi32>>) -> !fir.box<none> 2411 %14 = fir.convert %c4 : (index) -> i32 2412 %15 = fir.convert %11 : (!fir.ref<!fir.char<1,55>>) -> !fir.ref<i8> 2413 %16 = fir.convert %7 : (!fir.box<!fir.array<10x!fir.logical<4>>>) -> !fir.box<none> 2414 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) -> () 2415 %18 = fir.load %0 : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>> 2416 %c0_1 = arith.constant 0 : index 2417 %19:3 = fir.box_dims %18, %c0_1 : (!fir.box<!fir.heap<!fir.array<?xi32>>>, index) -> (index, index, index) 2418 %20 = fir.box_addr %18 : (!fir.box<!fir.heap<!fir.array<?xi32>>>) -> !fir.heap<!fir.array<?xi32>> 2419 %21 = fir.shape_shift %19#0, %19#1 : (index, index) -> !fir.shapeshift<1> 2420 %22 = fir.array_load %20(%21) : (!fir.heap<!fir.array<?xi32>>, !fir.shapeshift<1>) -> !fir.array<?xi32> 2421 %c1_2 = arith.constant 1 : index 2422 %c0_3 = arith.constant 0 : index 2423 %23 = arith.subi %c1, %c1_2 : index 2424 %24 = fir.do_loop %arg2 = %c0_3 to %23 step %c1_2 unordered iter_args(%arg3 = %3) -> (!fir.array<1xi32>) { 2425 %26 = fir.array_fetch %22, %arg2 : (!fir.array<?xi32>, index) -> i32 2426 %27 = fir.array_update %arg3, %26, %arg2 : (!fir.array<1xi32>, i32, index) -> !fir.array<1xi32> 2427 fir.result %27 : !fir.array<1xi32> 2428 } 2429 fir.array_merge_store %3, %24 to %1 : !fir.array<1xi32>, !fir.array<1xi32>, !fir.ref<!fir.array<1xi32>> 2430 fir.freemem %20 : !fir.heap<!fir.array<?xi32>> 2431 %25 = fir.load %1 : !fir.ref<!fir.array<1xi32>> 2432 return %25 : !fir.array<1xi32> 2433} 2434 2435// CHECK-LABEL: func.func @_QPtestmaxloc_works1d( 2436// CHECK-SAME: %[[INARR:.*]]: !fir.ref<!fir.array<10xi32>> {fir.bindc_name = "a"}, 2437// CHECK-SAME: %[[MASK:.*]]: !fir.ref<!fir.array<10x!fir.logical<4>>> {fir.bindc_name = "b"}) -> !fir.array<1xi32> { 2438// CHECK: %[[OUTARR:.*]] = fir.alloca !fir.box<!fir.heap<!fir.array<?xi32>>> 2439// CHECK: %[[SIZE10_0:.*]] = arith.constant 10 : index 2440// CHECK: %[[SIZE10_1:.*]] = arith.constant 10 : index 2441// CHECK: %[[INARR_SHAPE:.*]] = fir.shape %[[SIZE10_0]] : (index) -> !fir.shape<1> 2442// CHECK: %[[BOX_INARR:.*]] = fir.embox %[[INARR]](%[[INARR_SHAPE]]) : (!fir.ref<!fir.array<10xi32>>, !fir.shape<1>) -> !fir.box<!fir.array<10xi32>> 2443// CHECK: %[[MASK_SHAPE:.*]] = fir.shape %[[SIZE10_1]] : (index) -> !fir.shape<1> 2444// 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>>> 2445// CHECK: %[[REF_BOX_OUTARR_NONE:.*]] = fir.convert %[[OUTARR]] : (!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>) -> !fir.ref<!fir.box<none>> 2446// CHECK: %[[BOX_INARR_NONE:.*]] = fir.convert %[[BOX_INARR]] : (!fir.box<!fir.array<10xi32>>) -> !fir.box<none> 2447// CHECK: %[[BOX_MASK_NONE:.*]] = fir.convert %[[BOX_MASK]] : (!fir.box<!fir.array<10x!fir.logical<4>>>) -> !fir.box<none> 2448// 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>) -> () 2449 2450// CHECK-LABEL: func.func private @_FortranAMaxlocInteger4x1_Logical4x1_i32_contract_simplified( 2451// CHECK-SAME: %[[REF_BOX_OUTARR_NONE:.*]]: !fir.ref<!fir.box<none>>, 2452// CHECK-SAME: %[[BOX_INARR_NONE:.*]]: !fir.box<none>, 2453// CHECK-SAME: %[[BOX_MASK_NONE:.*]]: !fir.box<none>) attributes {llvm.linkage = #llvm.linkage<linkonce_odr>} { 2454// CHECK: %[[FLAG_ALLOC:.*]] = fir.alloca i32 2455// CHECK: %[[INIT_OUT_IDX:.*]] = arith.constant 0 : i32 2456// CHECK: %[[OUTARR_SIZE:.*]] = arith.constant 1 : index 2457// CHECK: %[[OUTARR:.*]] = fir.allocmem !fir.array<1xi32> 2458// CHECK: %[[OUTARR_SHAPE:.*]] = fir.shape %[[OUTARR_SIZE]] : (index) -> !fir.shape<1> 2459// CHECK: %[[BOX_OUTARR:.*]] = fir.embox %[[OUTARR]](%[[OUTARR_SHAPE]]) : (!fir.heap<!fir.array<1xi32>>, !fir.shape<1>) -> !fir.box<!fir.heap<!fir.array<1xi32>>> 2460// CHECK: %[[BOX_MASK:.*]] = fir.convert %[[BOX_MASK_NONE]] : (!fir.box<none>) -> !fir.box<!fir.array<?x!fir.logical<4>>> 2461// CHECK: %[[OUTARR_IDX0:.*]] = arith.constant 0 : index 2462// CHECK: %[[OUTARR_ITEM0:.*]] = fir.coordinate_of %[[BOX_OUTARR]], %[[OUTARR_IDX0]] : (!fir.box<!fir.heap<!fir.array<1xi32>>>, index) -> !fir.ref<i32> 2463// CHECK: fir.store %[[INIT_OUT_IDX]] to %[[OUTARR_ITEM0]] : !fir.ref<i32> 2464// CHECK: %[[CINDEX_0:.*]] = arith.constant 0 : index 2465// CHECK: %[[BOX_INARR:.*]] = fir.convert %[[BOX_INARR_NONE]] : (!fir.box<none>) -> !fir.box<!fir.array<?xi32>> 2466// CHECK: %[[FLAG_SET:.*]] = arith.constant 1 : i32 2467// CHECK: %[[FLAG_EMPTY:.*]] = arith.constant 0 : i32 2468// CHECK: fir.store %[[FLAG_EMPTY]] to %[[FLAG_ALLOC]] : !fir.ref<i32> 2469// CHECK: %[[MAX:.*]] = arith.constant -2147483648 : i32 2470// CHECK: %[[CINDEX_1:.*]] = arith.constant 1 : index 2471// CHECK: %[[DIM_INDEX0:.*]] = arith.constant 0 : index 2472// CHECK: %[[DIMS:.*]]:3 = fir.box_dims %[[BOX_INARR]], %[[DIM_INDEX0]] : (!fir.box<!fir.array<?xi32>>, index) -> (index, index, index) 2473// CHECK: %[[EXTENT:.*]] = arith.subi %[[DIMS]]#1, %[[CINDEX_1]] : index 2474// CHECK: %[[DOLOOP:.*]] = fir.do_loop %[[ITER:.*]] = %[[CINDEX_0]] to %[[EXTENT]] step %[[CINDEX_1]] iter_args(%[[MIN:.*]] = %[[MAX]]) -> (i32) { 2475// CHECK: %[[MASK_ITEM:.*]] = fir.coordinate_of %[[BOX_MASK]], %[[ITER]] : (!fir.box<!fir.array<?x!fir.logical<4>>>, index) -> !fir.ref<!fir.logical<4>> 2476// CHECK: %[[MASK_ITEMVAL:.*]] = fir.load %[[MASK_ITEM]] : !fir.ref<!fir.logical<4>> 2477// CHECK: %[[MASK_IF_ITEM:.*]] = fir.convert %[[MASK_ITEMVAL]] : (!fir.logical<4>) -> i1 2478// CHECK: %[[IF_MASK:.*]] = fir.if %[[MASK_IF_ITEM]] -> (i32) { 2479// CHECK: %[[FLAG_SET2:.*]] = arith.constant 1 : i32 2480// CHECK: %[[ISFIRST:.*]] = fir.load %[[FLAG_ALLOC]] : !fir.ref<i32> 2481// CHECK: %[[INARR_ITEM:.*]] = fir.coordinate_of %[[BOX_INARR]], %[[ITER]] : (!fir.box<!fir.array<?xi32>>, index) -> !fir.ref<i32> 2482// CHECK: %[[INARR_ITEMVAL:.*]] = fir.load %[[INARR_ITEM]] : !fir.ref<i32> 2483// CHECK: %[[NEW_MIN:.*]] = arith.cmpi sgt, %[[INARR_ITEMVAL]], %[[MIN]] : i32 2484// CHECK: %[[ISFIRSTL:.*]] = fir.convert %[[ISFIRST]] : (i32) -> i1 2485// CHECK: %[[ISFIRSTNOT:.*]] = arith.xori %[[ISFIRSTL]], %true : i1 2486// CHECK: %[[ORCOND:.*]] = arith.ori %[[NEW_MIN]], %[[ISFIRSTNOT]] : i1 2487// CHECK: %[[IF_NEW_MIN:.*]] = fir.if %[[ORCOND]] -> (i32) { 2488// CHECK: fir.store %[[FLAG_SET2]] to %[[FLAG_ALLOC]] : !fir.ref<i32> 2489// CHECK: %[[ONE:.*]] = arith.constant 1 : i32 2490// CHECK: %[[OUTARR_IDX:.*]] = arith.constant 0 : index 2491// CHECK: %[[OUTARR_ITEM:.*]] = fir.coordinate_of %[[BOX_OUTARR]], %[[OUTARR_IDX]] : (!fir.box<!fir.heap<!fir.array<1xi32>>>, index) -> !fir.ref<i32> 2492// CHECK: %[[ITER_I32:.*]] = fir.convert %[[ITER]] : (index) -> i32 2493// CHECK: %[[FORTRAN_IDX:.*]] = arith.addi %[[ITER_I32]], %[[ONE]] : i32 2494// CHECK: fir.store %[[FORTRAN_IDX]] to %[[OUTARR_ITEM]] : !fir.ref<i32> 2495// CHECK: fir.result %[[INARR_ITEMVAL]] : i32 2496// CHECK: } else { 2497// CHECK: fir.result %[[MIN]] : i32 2498// CHECK: } 2499// CHECK: fir.result %[[IF_NEW_MIN:.*]] : i32 2500// CHECK: } else { 2501// CHECK: fir.result %[[MIN]] : i32 2502// CHECK: } 2503// CHECK: fir.result %[[IF_MASK:.*]] : i32 2504// CHECK: } 2505// CHECK: %[[REF_BOX_OUTARR:.*]] = fir.convert %[[REF_BOX_OUTARR_NONE]] : (!fir.ref<!fir.box<none>>) -> !fir.ref<!fir.box<!fir.heap<!fir.array<1xi32>>>> 2506// CHECK: fir.store %[[BOX_OUTARR]] to %[[REF_BOX_OUTARR]] : !fir.ref<!fir.box<!fir.heap<!fir.array<1xi32>>>> 2507// CHECK: return 2508// CHECK: } 2509 2510// ----- 2511// Check Maxloc simplifies correctly for 1D case with scalar mask and f64 input 2512 2513func.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> { 2514 %0 = fir.alloca !fir.box<!fir.heap<!fir.array<?xi32>>> 2515 %c10 = arith.constant 10 : index 2516 %c1 = arith.constant 1 : index 2517 %1 = fir.alloca !fir.array<1xi32> {bindc_name = "testmaxloc_works1d_scalarmask_f64", uniq_name = "_QFtestmaxloc_works1d_scalarmask_f64Etestminloc_works1d_scalarmask_f64"} 2518 %2 = fir.shape %c1 : (index) -> !fir.shape<1> 2519 %3 = fir.array_load %1(%2) : (!fir.ref<!fir.array<1xi32>>, !fir.shape<1>) -> !fir.array<1xi32> 2520 %4 = fir.shape %c10 : (index) -> !fir.shape<1> 2521 %5 = fir.embox %arg0(%4) : (!fir.ref<!fir.array<10xf64>>, !fir.shape<1>) -> !fir.box<!fir.array<10xf64>> 2522 %6 = fir.embox %arg1 : (!fir.ref<!fir.logical<4>>) -> !fir.box<!fir.logical<4>> 2523 %c4 = arith.constant 4 : index 2524 %false = arith.constant false 2525 %7 = fir.zero_bits !fir.heap<!fir.array<?xi32>> 2526 %c0 = arith.constant 0 : index 2527 %8 = fir.shape %c0 : (index) -> !fir.shape<1> 2528 %9 = fir.embox %7(%8) : (!fir.heap<!fir.array<?xi32>>, !fir.shape<1>) -> !fir.box<!fir.heap<!fir.array<?xi32>>> 2529 fir.store %9 to %0 : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>> 2530 %10 = fir.address_of(@_QQclX66951c28c5b8bab5cdb25c1ac762b978) : !fir.ref<!fir.char<1,65>> 2531 %c6_i32 = arith.constant 6 : i32 2532 %11 = fir.convert %0 : (!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>) -> !fir.ref<!fir.box<none>> 2533 %12 = fir.convert %5 : (!fir.box<!fir.array<10xf64>>) -> !fir.box<none> 2534 %13 = fir.convert %c4 : (index) -> i32 2535 %14 = fir.convert %10 : (!fir.ref<!fir.char<1,65>>) -> !fir.ref<i8> 2536 %15 = fir.convert %6 : (!fir.box<!fir.logical<4>>) -> !fir.box<none> 2537 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) -> () 2538 %17 = fir.load %0 : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>> 2539 %c0_0 = arith.constant 0 : index 2540 %18:3 = fir.box_dims %17, %c0_0 : (!fir.box<!fir.heap<!fir.array<?xi32>>>, index) -> (index, index, index) 2541 %19 = fir.box_addr %17 : (!fir.box<!fir.heap<!fir.array<?xi32>>>) -> !fir.heap<!fir.array<?xi32>> 2542 %20 = fir.shape_shift %18#0, %18#1 : (index, index) -> !fir.shapeshift<1> 2543 %21 = fir.array_load %19(%20) : (!fir.heap<!fir.array<?xi32>>, !fir.shapeshift<1>) -> !fir.array<?xi32> 2544 %c1_1 = arith.constant 1 : index 2545 %c0_2 = arith.constant 0 : index 2546 %22 = arith.subi %c1, %c1_1 : index 2547 %23 = fir.do_loop %arg2 = %c0_2 to %22 step %c1_1 unordered iter_args(%arg3 = %3) -> (!fir.array<1xi32>) { 2548 %25 = fir.array_fetch %21, %arg2 : (!fir.array<?xi32>, index) -> i32 2549 %26 = fir.array_update %arg3, %25, %arg2 : (!fir.array<1xi32>, i32, index) -> !fir.array<1xi32> 2550 fir.result %26 : !fir.array<1xi32> 2551 } 2552 fir.array_merge_store %3, %23 to %1 : !fir.array<1xi32>, !fir.array<1xi32>, !fir.ref<!fir.array<1xi32>> 2553 fir.freemem %19 : !fir.heap<!fir.array<?xi32>> 2554 %24 = fir.load %1 : !fir.ref<!fir.array<1xi32>> 2555 return %24 : !fir.array<1xi32> 2556} 2557 2558// CHECK-LABEL: func.func @_QPtestmaxloc_works1d_scalarmask_f64( 2559// CHECK-SAME: %[[INARR:.*]]: !fir.ref<!fir.array<10xf64>> {fir.bindc_name = "a"}, 2560// CHECK-SAME: %[[MASK:.*]]: !fir.ref<!fir.logical<4>> {fir.bindc_name = "b"}) -> !fir.array<1xi32> { 2561// CHECK: fir.call @_FortranAMaxlocReal8x1_Logical4x0_i32_contract_simplified({{.*}}, {{.*}}, {{.*}}) fastmath<contract> : (!fir.ref<!fir.box<none>>, !fir.box<none>, !fir.box<none>) -> () 2562 2563// CHECK-LABEL: func.func private @_FortranAMaxlocReal8x1_Logical4x0_i32_contract_simplified( 2564// CHECK-SAME: %[[REF_BOX_OUTARR_NONE:.*]]: !fir.ref<!fir.box<none>>, 2565// CHECK-SAME: %[[BOX_INARR_NONE:.*]]: !fir.box<none>, 2566// CHECK-SAME: %[[BOX_MASK_NONE:.*]]: !fir.box<none>) attributes {llvm.linkage = #llvm.linkage<linkonce_odr>} { 2567// CHECK: %[[FLAG_ALLOC:.*]] = fir.alloca i32 2568// CHECK: %[[INIT_OUT_IDX:.*]] = arith.constant 0 : i32 2569// CHECK: %[[OUTARR_SIZE:.*]] = arith.constant 1 : index 2570// CHECK: %[[OUTARR:.*]] = fir.allocmem !fir.array<1xi32> 2571// CHECK: %[[OUTARR_SHAPE:.*]] = fir.shape %[[OUTARR_SIZE]] : (index) -> !fir.shape<1> 2572// CHECK: %[[BOX_OUTARR:.*]] = fir.embox %[[OUTARR]](%[[OUTARR_SHAPE]]) : (!fir.heap<!fir.array<1xi32>>, !fir.shape<1>) -> !fir.box<!fir.heap<!fir.array<1xi32>>> 2573// CHECK: %[[OUTARR_IDX0:.*]] = arith.constant 0 : index 2574// CHECK: %[[OUTARR_ITEM0:.*]] = fir.coordinate_of %[[BOX_OUTARR]], %[[OUTARR_IDX0]] : (!fir.box<!fir.heap<!fir.array<1xi32>>>, index) -> !fir.ref<i32> 2575// CHECK: fir.store %[[INIT_OUT_IDX]] to %[[OUTARR_ITEM0]] : !fir.ref<i32> 2576// CHECK: %[[BOX_MASK:.*]] = fir.convert %[[BOX_MASK_NONE]] : (!fir.box<none>) -> !fir.box<!fir.array<1xi1>> 2577// CHECK: %[[MASK_IDX0:.*]] = arith.constant 0 : index 2578// CHECK: %[[MASK_ITEM:.*]] = fir.coordinate_of %[[BOX_MASK]], %[[MASK_IDX0]] : (!fir.box<!fir.array<1xi1>>, index) -> !fir.ref<i1> 2579// CHECK: %[[MASK:.*]] = fir.load %[[MASK_ITEM]] : !fir.ref<i1> 2580// CHECK: %[[INIT_RES:.*]] = fir.if %[[MASK]] -> (f64) { 2581// CHECK: %[[C_INDEX0:.*]] = arith.constant 0 : index 2582// CHECK: %[[BOX_INARR:.*]] = fir.convert %[[BOX_INARR_NONE]] : (!fir.box<none>) -> !fir.box<!fir.array<?xf64>> 2583// CHECK: %[[FLAG_SET:.*]] = arith.constant 1 : i32 2584// CHECK: %[[FLAG_EMPTY:.*]] = arith.constant 0 : i32 2585// CHECK: fir.store %[[FLAG_EMPTY]] to %[[FLAG_ALLOC]] : !fir.ref<i32> 2586// CHECK: %[[MAX:.*]] = arith.constant 0xFFF0000000000000 : f64 2587// CHECK: %[[C_INDEX1:.*]] = arith.constant 1 : index 2588// CHECK: %[[DIM_INDEX:.*]] = arith.constant 0 : index 2589// CHECK: %[[DIMS:.*]]:3 = fir.box_dims %[[BOX_INARR]], %[[DIM_INDEX]] : (!fir.box<!fir.array<?xf64>>, index) -> (index, index, index) 2590// CHECK: %[[EXTENT:.*]] = arith.subi %[[DIMS]]#1, %[[C_INDEX1]] : index 2591// CHECK: %[[DOLOOP:.*]] = fir.do_loop %[[ITER:.*]] = %[[C_INDEX0]] to %[[EXTENT]] step %[[C_INDEX1]] iter_args(%[[MIN:.*]] = %[[MAX]]) -> (f64) { 2592// CHECK: %[[FLAG_SET2:.*]] = arith.constant 1 : i32 2593// CHECK: %[[ISFIRST:.*]] = fir.load %[[FLAG_ALLOC]] : !fir.ref<i32> 2594// CHECK: %[[INARR_ITEM:.*]] = fir.coordinate_of %[[BOX_INARR]], %[[ITER]] : (!fir.box<!fir.array<?xf64>>, index) -> !fir.ref<f64> 2595// CHECK: %[[INARR_ITEMVAL:.*]] = fir.load %[[INARR_ITEM]] : !fir.ref<f64> 2596// CHECK: %[[NEW_MIN:.*]] = arith.cmpf ogt, %[[INARR_ITEMVAL]], %arg4 fastmath<contract> : f64 2597// CHECK: %[[CONDRED:.*]] = arith.cmpf une, %arg4, %arg4 fastmath<contract> : f64 2598// CHECK: %[[CONDELEM:.*]] = arith.cmpf oeq, %[[INARR_ITEMVAL]], %[[INARR_ITEMVAL]] fastmath<contract> : f64 2599// CHECK: %[[ANDCOND:.*]] = arith.andi %[[CONDRED]], %[[CONDELEM]] : i1 2600// CHECK: %[[NEW_MIN2:.*]] = arith.ori %[[NEW_MIN]], %[[ANDCOND]] : i1 2601// CHECK: %[[ISFIRSTL:.*]] = fir.convert %[[ISFIRST]] : (i32) -> i1 2602// CHECK: %[[ISFIRSTNOT:.*]] = arith.xori %[[ISFIRSTL]], %true : i1 2603// CHECK: %[[ORCOND:.*]] = arith.ori %[[NEW_MIN2]], %[[ISFIRSTNOT]] : i1 2604// CHECK: %[[IF_NEW_MIN:.*]] = fir.if %[[ORCOND]] -> (f64) { 2605// CHECK: %[[ONE:.*]] = arith.constant 1 : i32 2606// CHECK: %[[OUTARR_IDX:.*]] = arith.constant 0 : index 2607// CHECK: %[[OUTARR_ITEM:.*]] = fir.coordinate_of %[[BOX_OUTARR]], %[[OUTARR_IDX]] : (!fir.box<!fir.heap<!fir.array<1xi32>>>, index) -> !fir.ref<i32> 2608// CHECK: %[[ITER_I32:.*]] = fir.convert %[[ITER]] : (index) -> i32 2609// CHECK: %[[FORTRAN_IDX:.*]] = arith.addi %[[ITER_I32]], %[[ONE]] : i32 2610// CHECK: fir.store %[[FORTRAN_IDX]] to %[[OUTARR_ITEM]] : !fir.ref<i32> 2611// CHECK: fir.result %[[INARR_ITEMVAL]] : f64 2612// CHECK: } else { 2613// CHECK: fir.result %[[MIN]] : f64 2614// CHECK: } 2615// CHECK: fir.result %[[IF_NEW_MIN:.*]] : f64 2616// CHECK: } 2617// CHECK: } 2618// CHECK: %[[REF_BOX_OUTARR:.*]] = fir.convert %[[VAL_0]] : (!fir.ref<!fir.box<none>>) -> !fir.ref<!fir.box<!fir.heap<!fir.array<1xi32>>>> 2619// CHECK: fir.store %[[BOX_OUTARR]] to %[[REF_BOX_OUTARR]] : !fir.ref<!fir.box<!fir.heap<!fir.array<1xi32>>>> 2620// CHECK: return 2621// CHECK: } 2622