Debian Codegraph @

flang/test/Transforms/simplifyintrinsics.fir

raw
1 // RUN: fir-opt --split-input-file --simplify-intrinsics %s | FileCheck %s
2
3 // Call to SUM with 1D I32 array is replaced.
4 module 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.
64 module 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.
129 module 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.
189 module 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.
249 module 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)
288 module 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
351 module 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.
408 module 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.
438 module 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
467 func.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
517 func.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 }
529 func.func private @_FortranADotProductReal8(!fir.box<none>, !fir.box<none>, !fir.ref<i8>, i32) -> f64 attributes {fir.runtime}
530 fir.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
544 func.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 }
556 func.func private @_FortranADotProductReal10(!fir.box<none>, !fir.box<none>, !fir.ref<i8>, i32) -> f80 attributes {fir.runtime}
557 fir.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
571 func.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 }
583 func.func private @_FortranADotProductReal16(!fir.box<none>, !fir.box<none>, !fir.ref<i8>, i32) -> f128 attributes {fir.runtime}
584 fir.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
598 func.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 }
610 func.func private @_FortranADotProductInteger4(!fir.box<none>, !fir.box<none>, !fir.ref<i8>, i32) -> i32 attributes {fir.runtime}
611 fir.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
654 func.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 }
666 func.func private @_FortranADotProductInteger1(!fir.box<none>, !fir.box<none>, !fir.ref<i8>, i32) -> i8 attributes {fir.runtime}
667 fir.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
681 func.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 }
693 func.func private @_FortranADotProductInteger2(!fir.box<none>, !fir.box<none>, !fir.ref<i8>, i32) -> i16 attributes {fir.runtime}
694 fir.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
708 func.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 }
720 func.func private @_FortranADotProductInteger8(!fir.box<none>, !fir.box<none>, !fir.ref<i8>, i32) -> i64 attributes {fir.runtime}
721 fir.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
739 func.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 }
751 func.func private @_FortranADotProductReal4(!fir.box<none>, !fir.box<none>, !fir.ref<i8>, i32) -> f32 attributes {fir.runtime}
752 fir.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.
797 module 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.
853 module 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.
913 func.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 }
946 func.func private @_FortranASumInteger8(!fir.box<none>, !fir.ref<i8>, i32, i32, !fir.box<none>) -> i64 attributes {fir.runtime}
947 fir.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.
960 func.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 }
993 func.func private @_FortranASumInteger8(!fir.box<none>, !fir.ref<i8>, i32, i32, !fir.box<none>) -> i64 attributes {fir.runtime}
994 fir.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
1005 func.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
1018 func.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
1031 func.func private @_FortranADotProductReal4(!fir.box<none>, !fir.box<none>, !fir.ref<i8>, i32) -> f32 attributes {fir.runtime}
1032 fir.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
1050 func.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
1069 func.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
1088 func.func private @_FortranASumReal8(!fir.box<none>, !fir.ref<i8>, i32, i32, !fir.box<none>) -> f64 attributes {fir.runtime}
1089 fir.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
1106 func.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 }
1124 func.func private @_FortranACount(!fir.box<none>, !fir.ref<i8>, i32, i32) -> i64 attributes {fir.runtime}
1125 fir.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
1168 func.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
1216 func.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 }
1259 func.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
1270 func.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 }
1284 func.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
1295 func.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 }
1312 func.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
1348 func.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 }
1365 func.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
1401 func.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 }
1442 func.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
1453 func.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 }
1467 func.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
1478 func.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
1537 func.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 }
1554 func.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
1588 func.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 }
1605 func.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
1640 func.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 }
1681 func.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
1691 func.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
1816 func.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
1936 func.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: %[[MASK_ADDR:.*]] = fir.box_addr %[[BOX_MASK_NONE]] : (!fir.box<none>) -> !fir.ref<!fir.logical<4>>
2000 // CHECK: %[[MASK_LOGICAL:.*]] = fir.load %[[MASK_ADDR]] : !fir.ref<!fir.logical<4>>
2001 // CHECK: %[[MASK:.*]] = fir.convert %[[MASK_LOGICAL]] : (!fir.logical<4>) -> i1
2002 // CHECK: %[[INIT_RES:.*]] = fir.if %[[MASK]] -> (f64) {
2003 // CHECK: %[[C_INDEX0:.*]] = arith.constant 0 : index
2004 // CHECK: %[[BOX_INARR:.*]] = fir.convert %[[BOX_INARR_NONE]] : (!fir.box<none>) -> !fir.box<!fir.array<?xf64>>
2005 // CHECK: %[[FLAG_SET:.*]] = arith.constant 1 : i32
2006 // CHECK: %[[FLAG_EMPTY:.*]] = arith.constant 0 : i32
2007 // CHECK: fir.store %[[FLAG_EMPTY]] to %[[FLAG_ALLOC]] : !fir.ref<i32>
2008 // CHECK: %[[MAX:.*]] = arith.constant 0x7FF0000000000000 : f64
2009 // CHECK: %[[C_INDEX1:.*]] = arith.constant 1 : index
2010 // CHECK: %[[DIM_INDEX:.*]] = arith.constant 0 : index
2011 // CHECK: %[[DIMS:.*]]:3 = fir.box_dims %[[BOX_INARR]], %[[DIM_INDEX]] : (!fir.box<!fir.array<?xf64>>, index) -> (index, index, index)
2012 // CHECK: %[[EXTENT:.*]] = arith.subi %[[DIMS]]#1, %[[C_INDEX1]] : index
2013 // CHECK: %[[DOLOOP:.*]] = fir.do_loop %[[ITER:.*]] = %[[C_INDEX0]] to %[[EXTENT]] step %[[C_INDEX1]] iter_args(%[[MIN:.*]] = %[[MAX]]) -> (f64) {
2014 // CHECK: %[[FLAG_SET2:.*]] = arith.constant 1 : i32
2015 // CHECK: %[[ISFIRST:.*]] = fir.load %[[FLAG_ALLOC]] : !fir.ref<i32>
2016 // CHECK: %[[INARR_ITEM:.*]] = fir.coordinate_of %[[BOX_INARR]], %[[ITER]] : (!fir.box<!fir.array<?xf64>>, index) -> !fir.ref<f64>
2017 // CHECK: %[[INARR_ITEMVAL:.*]] = fir.load %[[INARR_ITEM]] : !fir.ref<f64>
2018 // CHECK: %[[NEW_MIN:.*]] = arith.cmpf olt, %[[INARR_ITEMVAL]], %arg4 fastmath<contract> : f64
2019 // CHECK: %[[CONDRED:.*]] = arith.cmpf une, %arg4, %arg4 fastmath<contract> : f64
2020 // CHECK: %[[CONDELEM:.*]] = arith.cmpf oeq, %[[INARR_ITEMVAL]], %[[INARR_ITEMVAL]] fastmath<contract> : f64
2021 // CHECK: %[[ANDCOND:.*]] = arith.andi %[[CONDRED]], %[[CONDELEM]] : i1
2022 // CHECK: %[[NEW_MIN2:.*]] = arith.ori %[[NEW_MIN]], %[[ANDCOND]] : i1
2023 // CHECK: %[[ISFIRSTL:.*]] = fir.convert %[[ISFIRST]] : (i32) -> i1
2024 // CHECK: %[[ISFIRSTNOT:.*]] = arith.xori %[[ISFIRSTL]], %true : i1
2025 // CHECK: %[[ORCOND:.*]] = arith.ori %[[NEW_MIN2]], %[[ISFIRSTNOT]] : i1
2026 // CHECK: %[[IF_NEW_MIN:.*]] = fir.if %[[ORCOND]] -> (f64) {
2027 // CHECK: %[[ONE:.*]] = arith.constant 1 : i32
2028 // CHECK: %[[OUTARR_IDX:.*]] = arith.constant 0 : index
2029 // CHECK: %[[OUTARR_ITEM:.*]] = fir.coordinate_of %[[BOX_OUTARR]], %[[OUTARR_IDX]] : (!fir.box<!fir.heap<!fir.array<1xi32>>>, index) -> !fir.ref<i32>
2030 // CHECK: %[[ITER_I32:.*]] = fir.convert %[[ITER]] : (index) -> i32
2031 // CHECK: %[[FORTRAN_IDX:.*]] = arith.addi %[[ITER_I32]], %[[ONE]] : i32
2032 // CHECK: fir.store %[[FORTRAN_IDX]] to %[[OUTARR_ITEM]] : !fir.ref<i32>
2033 // CHECK: fir.result %[[INARR_ITEMVAL]] : f64
2034 // CHECK: } else {
2035 // CHECK: fir.result %[[MIN]] : f64
2036 // CHECK: }
2037 // CHECK: fir.result %[[IF_NEW_MIN:.*]] : f64
2038 // CHECK: }
2039 // CHECK: }
2040 // CHECK: %[[REF_BOX_OUTARR:.*]] = fir.convert %[[VAL_0]] : (!fir.ref<!fir.box<none>>) -> !fir.ref<!fir.box<!fir.heap<!fir.array<1xi32>>>>
2041 // CHECK: fir.store %[[BOX_OUTARR]] to %[[REF_BOX_OUTARR]] : !fir.ref<!fir.box<!fir.heap<!fir.array<1xi32>>>>
2042 // CHECK: return
2043 // CHECK: }
2044
2045 // -----
2046 // Check Minloc is not simplified when BACK arg is set
2047
2048 func.func @_QPtestminloc_doesntwork1d_back(%arg0: !fir.ref<!fir.array<10xi32>> {fir.bindc_name = "a"}) -> !fir.array<1xi32> {
2049 %0 = fir.alloca !fir.box<!fir.heap<!fir.array<?xi32>>>
2050 %c10 = arith.constant 10 : index
2051 %c1 = arith.constant 1 : index
2052 %1 = fir.alloca !fir.array<1xi32> {bindc_name = "testminloc_doesntwork1d_back", uniq_name = "_QFtestminloc_doesntwork1d_backEtestminloc_doesntwork1d_back"}
2053 %2 = fir.shape %c1 : (index) -> !fir.shape<1>
2054 %3 = fir.array_load %1(%2) : (!fir.ref<!fir.array<1xi32>>, !fir.shape<1>) -> !fir.array<1xi32>
2055 %4 = fir.shape %c10 : (index) -> !fir.shape<1>
2056 %5 = fir.embox %arg0(%4) : (!fir.ref<!fir.array<10xi32>>, !fir.shape<1>) -> !fir.box<!fir.array<10xi32>>
2057 %true = arith.constant true
2058 %6 = fir.absent !fir.box<i1>
2059 %c4 = arith.constant 4 : index
2060 %7 = fir.zero_bits !fir.heap<!fir.array<?xi32>>
2061 %c0 = arith.constant 0 : index
2062 %8 = fir.shape %c0 : (index) -> !fir.shape<1>
2063 %9 = fir.embox %7(%8) : (!fir.heap<!fir.array<?xi32>>, !fir.shape<1>) -> !fir.box<!fir.heap<!fir.array<?xi32>>>
2064 fir.store %9 to %0 : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>
2065 %10 = fir.address_of(@_QQclX3791f01d699716ba5914ae524c6a8dee) : !fir.ref<!fir.char<1,62>>
2066 %c4_i32 = arith.constant 4 : i32
2067 %11 = fir.convert %0 : (!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>) -> !fir.ref<!fir.box<none>>
2068 %12 = fir.convert %5 : (!fir.box<!fir.array<10xi32>>) -> !fir.box<none>
2069 %13 = fir.convert %c4 : (index) -> i32
2070 %14 = fir.convert %10 : (!fir.ref<!fir.char<1,62>>) -> !fir.ref<i8>
2071 %15 = fir.convert %6 : (!fir.box<i1>) -> !fir.box<none>
2072 fir.call @_FortranAMinlocInteger4(%11, %12, %13, %14, %c4_i32, %15, %true) fastmath<contract> : (!fir.ref<!fir.box<none>>, !fir.box<none>, i32, !fir.ref<i8>, i32, !fir.box<none>, i1) -> ()
2073 %17 = fir.load %0 : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>
2074 %c0_0 = arith.constant 0 : index
2075 %18:3 = fir.box_dims %17, %c0_0 : (!fir.box<!fir.heap<!fir.array<?xi32>>>, index) -> (index, index, index)
2076 %19 = fir.box_addr %17 : (!fir.box<!fir.heap<!fir.array<?xi32>>>) -> !fir.heap<!fir.array<?xi32>>
2077 %20 = fir.shape_shift %18#0, %18#1 : (index, index) -> !fir.shapeshift<1>
2078 %21 = fir.array_load %19(%20) : (!fir.heap<!fir.array<?xi32>>, !fir.shapeshift<1>) -> !fir.array<?xi32>
2079 %c1_1 = arith.constant 1 : index
2080 %c0_2 = arith.constant 0 : index
2081 %22 = arith.subi %c1, %c1_1 : index
2082 %23 = fir.do_loop %arg1 = %c0_2 to %22 step %c1_1 unordered iter_args(%arg2 = %3) -> (!fir.array<1xi32>) {
2083 %25 = fir.array_fetch %21, %arg1 : (!fir.array<?xi32>, index) -> i32
2084 %26 = fir.array_update %arg2, %25, %arg1 : (!fir.array<1xi32>, i32, index) -> !fir.array<1xi32>
2085 fir.result %26 : !fir.array<1xi32>
2086 }
2087 fir.array_merge_store %3, %23 to %1 : !fir.array<1xi32>, !fir.array<1xi32>, !fir.ref<!fir.array<1xi32>>
2088 fir.freemem %19 : !fir.heap<!fir.array<?xi32>>
2089 %24 = fir.load %1 : !fir.ref<!fir.array<1xi32>>
2090 return %24 : !fir.array<1xi32>
2091 }
2092
2093 // CHECK-LABEL: func.func @_QPtestminloc_doesntwork1d_back(
2094 // CHECK-SAME: %[[ARR:.*]]: !fir.ref<!fir.array<10xi32>> {fir.bindc_name = "a"}) -> !fir.array<1xi32> {
2095 // CHECK-NOT: fir.call @_FortranAMinlocInteger4x1_i32_contract_simplified({{.*}}) fastmath<contract> : (!fir.ref<!fir.box<none>>, !fir.box<none>, !fir.box<none>) -> ()
2096 // CHECK: fir.call @_FortranAMinlocInteger4({{.*}}) fastmath<contract> : (!fir.ref<!fir.box<none>>, !fir.box<none>, i32, !fir.ref<i8>, i32, !fir.box<none>, i1) -> ()
2097 // CHECK-NOT: fir.call @_FortranAMinlocInteger4x1_i32_contract_simplified({{.*}}) fastmath<contract> : (!fir.ref<!fir.box<none>>, !fir.box<none>, !fir.box<none>) -> ()
2098
2099 // -----
2100 // Check Minloc is simplified when DIM arg is set so long as the result is scalar
2101
2102 func.func @_QPtestminloc_1d_dim(%arg0: !fir.ref<!fir.array<10xi32>> {fir.bindc_name = "a"}) -> !fir.array<1xi32> {
2103 %0 = fir.alloca !fir.box<!fir.heap<i32>>
2104 %c10 = arith.constant 10 : index
2105 %c1 = arith.constant 1 : index
2106 %1 = fir.alloca !fir.array<1xi32> {bindc_name = "testminloc_1d_dim", uniq_name = "_QFtestminloc_1d_dimEtestminloc_1d_dim"}
2107 %2 = fir.shape %c1 : (index) -> !fir.shape<1>
2108 %3 = fir.array_load %1(%2) : (!fir.ref<!fir.array<1xi32>>, !fir.shape<1>) -> !fir.array<1xi32>
2109 %4 = fir.shape %c10 : (index) -> !fir.shape<1>
2110 %5 = fir.embox %arg0(%4) : (!fir.ref<!fir.array<10xi32>>, !fir.shape<1>) -> !fir.box<!fir.array<10xi32>>
2111 %c1_i32 = arith.constant 1 : i32
2112 %6 = fir.absent !fir.box<i1>
2113 %c4 = arith.constant 4 : index
2114 %false = arith.constant false
2115 %7 = fir.zero_bits !fir.heap<i32>
2116 %8 = fir.embox %7 : (!fir.heap<i32>) -> !fir.box<!fir.heap<i32>>
2117 fir.store %8 to %0 : !fir.ref<!fir.box<!fir.heap<i32>>>
2118 %9 = fir.address_of(@_QQclXcfcf4329f25d06a4b02a0c8f532ee9df) : !fir.ref<!fir.char<1,61>>
2119 %c4_i32 = arith.constant 4 : i32
2120 %10 = fir.convert %0 : (!fir.ref<!fir.box<!fir.heap<i32>>>) -> !fir.ref<!fir.box<none>>
2121 %11 = fir.convert %5 : (!fir.box<!fir.array<10xi32>>) -> !fir.box<none>
2122 %12 = fir.convert %c4 : (index) -> i32
2123 %13 = fir.convert %9 : (!fir.ref<!fir.char<1,61>>) -> !fir.ref<i8>
2124 %14 = fir.convert %6 : (!fir.box<i1>) -> !fir.box<none>
2125 fir.call @_FortranAMinlocDim(%10, %11, %12, %c1_i32, %13, %c4_i32, %14, %false) fastmath<contract> : (!fir.ref<!fir.box<none>>, !fir.box<none>, i32, i32, !fir.ref<i8>, i32, !fir.box<none>, i1) -> ()
2126 %16 = fir.load %0 : !fir.ref<!fir.box<!fir.heap<i32>>>
2127 %17 = fir.box_addr %16 : (!fir.box<!fir.heap<i32>>) -> !fir.heap<i32>
2128 %18 = fir.load %17 : !fir.heap<i32>
2129 fir.freemem %17 : !fir.heap<i32>
2130 %c1_0 = arith.constant 1 : index
2131 %c0 = arith.constant 0 : index
2132 %19 = arith.subi %c1, %c1_0 : index
2133 %20 = fir.do_loop %arg1 = %c0 to %19 step %c1_0 unordered iter_args(%arg2 = %3) -> (!fir.array<1xi32>) {
2134 %22 = fir.array_update %arg2, %18, %arg1 : (!fir.array<1xi32>, i32, index) -> !fir.array<1xi32>
2135 fir.result %22 : !fir.array<1xi32>
2136 }
2137 fir.array_merge_store %3, %20 to %1 : !fir.array<1xi32>, !fir.array<1xi32>, !fir.ref<!fir.array<1xi32>>
2138 %21 = fir.load %1 : !fir.ref<!fir.array<1xi32>>
2139 return %21 : !fir.array<1xi32>
2140 }
2141 // CHECK-LABEL: func.func @_QPtestminloc_1d_dim(
2142 // CHECK-SAME: %[[ARR:.*]]: !fir.ref<!fir.array<10xi32>> {fir.bindc_name = "a"}) -> !fir.array<1xi32> {
2143 // CHECK: fir.call @_FortranAMinlocDimx1_i32_i32_contract_simplified({{.*}}) fastmath<contract> : (!fir.ref<!fir.box<none>>, !fir.box<none>, !fir.box<none>) -> ()
2144
2145 // CHECK-LABEL: func.func private @_FortranAMinlocDimx1_i32_i32_contract_simplified(%arg0: !fir.ref<!fir.box<none>>, %arg1: !fir.box<none>, %arg2: !fir.box<none>) attributes {llvm.linkage = #llvm.linkage<linkonce_odr>} {
2146 // CHECK-NEXT: %[[V0:.*]] = fir.alloca i32
2147 // CHECK-NEXT: %c0_i32 = arith.constant 0 : i32
2148 // CHECK-NEXT: %c1 = arith.constant 1 : index
2149 // CHECK-NEXT: %[[V1:.*]] = fir.allocmem !fir.array<1xi32>
2150 // CHECK-NEXT: %[[V2:.*]] = fir.shape %c1 : (index) -> !fir.shape<1>
2151 // CHECK-NEXT: %[[V3:.*]] = fir.embox %[[V1]](%[[V2]]) : (!fir.heap<!fir.array<1xi32>>, !fir.shape<1>) -> !fir.box<!fir.heap<!fir.array<1xi32>>>
2152 // CHECK-NEXT: %c0 = arith.constant 0 : index
2153 // CHECK-NEXT: %[[V4:.*]] = fir.coordinate_of %[[V3]], %c0 : (!fir.box<!fir.heap<!fir.array<1xi32>>>, index) -> !fir.ref<i32>
2154 // CHECK-NEXT: fir.store %c0_i32 to %[[V4]] : !fir.ref<i32>
2155 // CHECK-NEXT: %c0_0 = arith.constant 0 : index
2156 // CHECK-NEXT: %[[V5:.*]] = fir.convert %arg1 : (!fir.box<none>) -> !fir.box<!fir.array<?xi32>>
2157 // CHECK-NEXT: %c1_i32 = arith.constant 1 : i32
2158 // CHECK-NEXT: %c0_i32_1 = arith.constant 0 : i32
2159 // CHECK-NEXT: fir.store %c0_i32_1 to %[[V0]] : !fir.ref<i32>
2160 // CHECK-NEXT: %c2147483647_i32 = arith.constant 2147483647 : i32
2161 // CHECK-NEXT: %c1_2 = arith.constant 1 : index
2162 // CHECK-NEXT: %c0_3 = arith.constant 0 : index
2163 // CHECK-NEXT: %[[V6:.*]]:3 = fir.box_dims %[[V5]], %c0_3 : (!fir.box<!fir.array<?xi32>>, index) -> (index, index, index)
2164 // CHECK-NEXT: %[[V7:.*]] = arith.subi %[[V6]]#1, %c1_2 : index
2165 // CHECK-NEXT: %[[V8:.*]] = fir.do_loop %arg3 = %c0_0 to %[[V7]] step %c1_2 iter_args(%arg4 = %c2147483647_i32) -> (i32) {
2166 // CHECK-NEXT: %c1_i32_4 = arith.constant 1 : i32
2167 // CHECK-NEXT: %[[ISFIRST:.*]] = fir.load %[[FLAG_ALLOC]] : !fir.ref<i32>
2168 // CHECK-NEXT: %[[V12:.*]] = fir.coordinate_of %[[V5]], %arg3 : (!fir.box<!fir.array<?xi32>>, index) -> !fir.ref<i32>
2169 // CHECK-NEXT: %[[V13:.*]] = fir.load %[[V12]] : !fir.ref<i32>
2170 // CHECK-NEXT: %[[V14:.*]] = arith.cmpi slt, %[[V13]], %arg4 : i32
2171 // CHECK-NEXT: %[[ISFIRSTL:.*]] = fir.convert %[[ISFIRST]] : (i32) -> i1
2172 // CHECK-NEXT: %true = arith.constant true
2173 // CHECK-NEXT: %[[ISFIRSTNOT:.*]] = arith.xori %[[ISFIRSTL]], %true : i1
2174 // CHECK-NEXT: %[[ORCOND:.*]] = arith.ori %[[V14]], %[[ISFIRSTNOT]] : i1
2175 // CHECK-NEXT: %[[V15:.*]] = fir.if %[[ORCOND]] -> (i32) {
2176 // CHECK-NEXT: fir.store %c1_i32_4 to %[[V0]] : !fir.ref<i32>
2177 // CHECK-NEXT: %c1_i32_5 = arith.constant 1 : i32
2178 // CHECK-NEXT: %c0_6 = arith.constant 0 : index
2179 // CHECK-NEXT: %[[V16:.*]] = fir.coordinate_of %[[V3]], %c0_6 : (!fir.box<!fir.heap<!fir.array<1xi32>>>, index) -> !fir.ref<i32>
2180 // CHECK-NEXT: %[[V17:.*]] = fir.convert %arg3 : (index) -> i32
2181 // CHECK-NEXT: %[[V18:.*]] = arith.addi %[[V17]], %c1_i32_5 : i32
2182 // CHECK-NEXT: fir.store %[[V18]] to %[[V16]] : !fir.ref<i32>
2183 // CHECK-NEXT: fir.result %[[V13]] : i32
2184 // CHECK-NEXT: } else {
2185 // CHECK-NEXT: fir.result %arg4 : i32
2186 // CHECK-NEXT: }
2187 // CHECK-NEXT: fir.result %[[V15]] : i32
2188 // CHECK-NEXT: }
2189 // CHECK-NEXT: %[[V11:.*]] = fir.convert %arg0 : (!fir.ref<!fir.box<none>>) -> !fir.ref<!fir.box<!fir.heap<i32>>>
2190 // CHECK-NEXT: %[[V12:.*]] = fir.convert %[[V1]] : (!fir.heap<!fir.array<1xi32>>) -> !fir.heap<i32>
2191 // CHECK-NEXT: %[[V13:.*]] = fir.embox %[[V12]] : (!fir.heap<i32>) -> !fir.box<!fir.heap<i32>>
2192 // CHECK-NEXT: fir.store %[[V13]] to %[[V11]] : !fir.ref<!fir.box<!fir.heap<i32>>>
2193 // CHECK-NEXT: return
2194 // CHECK-NEXT: }
2195
2196
2197
2198 // -----
2199 // Check Minloc is not simplified when dimension of inputArr is unknown
2200
2201 func.func @_QPtestminloc_doesntwork1d_unknownsize(%arg0: !fir.box<!fir.array<?xi32>> {fir.bindc_name = "a"}) -> !fir.array<1xi32> {
2202 %0 = fir.alloca !fir.box<!fir.heap<!fir.array<?xi32>>>
2203 %c1 = arith.constant 1 : index
2204 %1 = fir.alloca !fir.array<1xi32> {bindc_name = "testminloc_doesntwork1d_unknownsize", uniq_name = "_QFtestminloc_doesntwork1d_unknownsizeEtestminloc_doesntwork1d_unknownsize"}
2205 %2 = fir.shape %c1 : (index) -> !fir.shape<1>
2206 %3 = fir.array_load %1(%2) : (!fir.ref<!fir.array<1xi32>>, !fir.shape<1>) -> !fir.array<1xi32>
2207 %4 = fir.absent !fir.box<i1>
2208 %c4 = arith.constant 4 : index
2209 %false = arith.constant false
2210 %5 = fir.zero_bits !fir.heap<!fir.array<?xi32>>
2211 %c0 = arith.constant 0 : index
2212 %6 = fir.shape %c0 : (index) -> !fir.shape<1>
2213 %7 = fir.embox %5(%6) : (!fir.heap<!fir.array<?xi32>>, !fir.shape<1>) -> !fir.box<!fir.heap<!fir.array<?xi32>>>
2214 fir.store %7 to %0 : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>
2215 %8 = fir.address_of(@_QQclX2064f5e9298c2127417d52b69eac898e) : !fir.ref<!fir.char<1,69>>
2216 %c4_i32 = arith.constant 4 : i32
2217 %9 = fir.convert %0 : (!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>) -> !fir.ref<!fir.box<none>>
2218 %10 = fir.convert %arg0 : (!fir.box<!fir.array<?xi32>>) -> !fir.box<none>
2219 %11 = fir.convert %c4 : (index) -> i32
2220 %12 = fir.convert %8 : (!fir.ref<!fir.char<1,69>>) -> !fir.ref<i8>
2221 %13 = fir.convert %4 : (!fir.box<i1>) -> !fir.box<none>
2222 fir.call @_FortranAMinlocInteger4(%9, %10, %11, %12, %c4_i32, %13, %false) fastmath<contract> : (!fir.ref<!fir.box<none>>, !fir.box<none>, i32, !fir.ref<i8>, i32, !fir.box<none>, i1) -> ()
2223 %15 = fir.load %0 : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>
2224 %c0_0 = arith.constant 0 : index
2225 %16:3 = fir.box_dims %15, %c0_0 : (!fir.box<!fir.heap<!fir.array<?xi32>>>, index) -> (index, index, index)
2226 %17 = fir.box_addr %15 : (!fir.box<!fir.heap<!fir.array<?xi32>>>) -> !fir.heap<!fir.array<?xi32>>
2227 %18 = fir.shape_shift %16#0, %16#1 : (index, index) -> !fir.shapeshift<1>
2228 %19 = fir.array_load %17(%18) : (!fir.heap<!fir.array<?xi32>>, !fir.shapeshift<1>) -> !fir.array<?xi32>
2229 %c1_1 = arith.constant 1 : index
2230 %c0_2 = arith.constant 0 : index
2231 %20 = arith.subi %c1, %c1_1 : index
2232 %21 = fir.do_loop %arg1 = %c0_2 to %20 step %c1_1 unordered iter_args(%arg2 = %3) -> (!fir.array<1xi32>) {
2233 %23 = fir.array_fetch %19, %arg1 : (!fir.array<?xi32>, index) -> i32
2234 %24 = fir.array_update %arg2, %23, %arg1 : (!fir.array<1xi32>, i32, index) -> !fir.array<1xi32>
2235 fir.result %24 : !fir.array<1xi32>
2236 }
2237 fir.array_merge_store %3, %21 to %1 : !fir.array<1xi32>, !fir.array<1xi32>, !fir.ref<!fir.array<1xi32>>
2238 fir.freemem %17 : !fir.heap<!fir.array<?xi32>>
2239 %22 = fir.load %1 : !fir.ref<!fir.array<1xi32>>
2240 return %22 : !fir.array<1xi32>
2241 }
2242 // CHECK-LABEL: func.func @_QPtestminloc_doesntwork1d_unknownsize(
2243 // CHECK-SAME: %[[ARR:.*]]: !fir.box<!fir.array<?xi32>> {fir.bindc_name = "a"}) -> !fir.array<1xi32> {
2244 // CHECK-NOT: fir.call @_FortranAMinlocInteger4x1_i32_contract_simplified({{.*}}) fastmath<contract> : (!fir.ref<!fir.box<none>>, !fir.box<none>, !fir.box<none>) -> ()
2245 // CHECK: fir.call @_FortranAMinlocInteger4({{.*}}) fastmath<contract> : (!fir.ref<!fir.box<none>>, !fir.box<none>, i32, !fir.ref<i8>, i32, !fir.box<none>, i1) -> ()
2246 // CHECK-NOT: fir.call @_FortranAMinlocInteger4x1_i32_contract_simplified({{.*}}) fastmath<contract> : (!fir.ref<!fir.box<none>>, !fir.box<none>, !fir.box<none>) -> ()
2247
2248 // -----
2249 // Check Minloc is not simplified when inputArr is characterType
2250
2251 func.func @_QPtestminloc_doesntwork1d_chars(%arg0: !fir.boxchar<1> {fir.bindc_name = "a"}) -> !fir.array<1xi32> {
2252 %0 = fir.alloca !fir.box<!fir.heap<!fir.array<?xi32>>>
2253 %1:2 = fir.unboxchar %arg0 : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1,?>>, index)
2254 %2 = fir.convert %1#0 : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<!fir.array<10x!fir.char<1>>>
2255 %c10 = arith.constant 10 : index
2256 %c1 = arith.constant 1 : index
2257 %3 = fir.alloca !fir.array<1xi32> {bindc_name = "testminloc_doesntwork1d_chars", uniq_name = "_QFtestminloc_doesntwork1d_charsEtestminloc_doesntwork1d_chars"}
2258 %4 = fir.shape %c1 : (index) -> !fir.shape<1>
2259 %5 = fir.array_load %3(%4) : (!fir.ref<!fir.array<1xi32>>, !fir.shape<1>) -> !fir.array<1xi32>
2260 %6 = fir.shape %c10 : (index) -> !fir.shape<1>
2261 %7 = fir.embox %2(%6) : (!fir.ref<!fir.array<10x!fir.char<1>>>, !fir.shape<1>) -> !fir.box<!fir.array<10x!fir.char<1>>>
2262 %8 = fir.absent !fir.box<i1>
2263 %c4 = arith.constant 4 : index
2264 %false = arith.constant false
2265 %9 = fir.zero_bits !fir.heap<!fir.array<?xi32>>
2266 %c0 = arith.constant 0 : index
2267 %10 = fir.shape %c0 : (index) -> !fir.shape<1>
2268 %11 = fir.embox %9(%10) : (!fir.heap<!fir.array<?xi32>>, !fir.shape<1>) -> !fir.box<!fir.heap<!fir.array<?xi32>>>
2269 fir.store %11 to %0 : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>
2270 %12 = fir.address_of(@_QQclX74460ff3ef22ea53671c22344e1556b9) : !fir.ref<!fir.char<1,41>>
2271 %c4_i32 = arith.constant 4 : i32
2272 %13 = fir.convert %0 : (!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>) -> !fir.ref<!fir.box<none>>
2273 %14 = fir.convert %7 : (!fir.box<!fir.array<10x!fir.char<1>>>) -> !fir.box<none>
2274 %15 = fir.convert %c4 : (index) -> i32
2275 %16 = fir.convert %12 : (!fir.ref<!fir.char<1,41>>) -> !fir.ref<i8>
2276 %17 = fir.convert %8 : (!fir.box<i1>) -> !fir.box<none>
2277 fir.call @_FortranAMinlocCharacter(%13, %14, %15, %16, %c4_i32, %17, %false) fastmath<contract> : (!fir.ref<!fir.box<none>>, !fir.box<none>, i32, !fir.ref<i8>, i32, !fir.box<none>, i1) -> ()
2278 %19 = fir.load %0 : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>
2279 %c0_0 = arith.constant 0 : index
2280 %20:3 = fir.box_dims %19, %c0_0 : (!fir.box<!fir.heap<!fir.array<?xi32>>>, index) -> (index, index, index)
2281 %21 = fir.box_addr %19 : (!fir.box<!fir.heap<!fir.array<?xi32>>>) -> !fir.heap<!fir.array<?xi32>>
2282 %22 = fir.shape_shift %20#0, %20#1 : (index, index) -> !fir.shapeshift<1>
2283 %23 = fir.array_load %21(%22) : (!fir.heap<!fir.array<?xi32>>, !fir.shapeshift<1>) -> !fir.array<?xi32>
2284 %c1_1 = arith.constant 1 : index
2285 %c0_2 = arith.constant 0 : index
2286 %24 = arith.subi %c1, %c1_1 : index
2287 %25 = fir.do_loop %arg1 = %c0_2 to %24 step %c1_1 unordered iter_args(%arg2 = %5) -> (!fir.array<1xi32>) {
2288 %27 = fir.array_fetch %23, %arg1 : (!fir.array<?xi32>, index) -> i32
2289 %28 = fir.array_update %arg2, %27, %arg1 : (!fir.array<1xi32>, i32, index) -> !fir.array<1xi32>
2290 fir.result %28 : !fir.array<1xi32>
2291 }
2292 fir.array_merge_store %5, %25 to %3 : !fir.array<1xi32>, !fir.array<1xi32>, !fir.ref<!fir.array<1xi32>>
2293 fir.freemem %21 : !fir.heap<!fir.array<?xi32>>
2294 %26 = fir.load %3 : !fir.ref<!fir.array<1xi32>>
2295 return %26 : !fir.array<1xi32>
2296 }
2297
2298 // CHECK-LABEL: func.func @_QPtestminloc_doesntwork1d_chars(
2299 // CHECK-SAME: %[[ARR:.*]]: !fir.boxchar<1> {fir.bindc_name = "a"}) -> !fir.array<1xi32> {
2300 // CHECK-NOT: fir.call @_FortranAMinlocCharacterx1_i32_contract_simplified({{.*}}) fastmath<contract> : (!fir.ref<!fir.box<none>>, !fir.box<none>, !fir.box<none>) -> ()
2301 // CHECK: fir.call @_FortranAMinlocCharacter({{.*}}) fastmath<contract> : (!fir.ref<!fir.box<none>>, !fir.box<none>, i32, !fir.ref<i8>, i32, !fir.box<none>, i1) -> ()
2302 // CHECK-NOT: fir.call @_FortranAMinlocCharacterx1_i32_contract_simplified({{.*}}) fastmath<contract> : (!fir.ref<!fir.box<none>>, !fir.box<none>, !fir.box<none>) -> ()
2303
2304 // -----
2305 // Check Minloc is not simplified when mask is unknown rank
2306
2307 func.func @_QPtestminloc_doesntwork1d_unknownmask(%arg0: !fir.ref<!fir.array<10xi32>> {fir.bindc_name = "a"}) -> !fir.array<1xi32> {
2308 %0 = fir.alloca !fir.box<!fir.heap<!fir.array<?xi32>>>
2309 %c10 = arith.constant 10 : index
2310 %1 = fir.alloca i32 {bindc_name = "b", uniq_name = "_QFtestminloc_doesntwork1d_unknownmaskEb"}
2311 %2 = fir.alloca !fir.box<!fir.heap<!fir.array<?x!fir.logical<4>>>> {bindc_name = "mask", uniq_name = "_QFtestminloc_doesntwork1d_unknownmaskEmask"}
2312 %3 = fir.alloca !fir.heap<!fir.array<?x!fir.logical<4>>> {uniq_name = "_QFtestminloc_doesntwork1d_unknownmaskEmask.addr"}
2313 %4 = fir.alloca index {uniq_name = "_QFtestminloc_doesntwork1d_unknownmaskEmask.lb0"}
2314 %5 = fir.alloca index {uniq_name = "_QFtestminloc_doesntwork1d_unknownmaskEmask.ext0"}
2315 %6 = fir.zero_bits !fir.heap<!fir.array<?x!fir.logical<4>>>
2316 fir.store %6 to %3 : !fir.ref<!fir.heap<!fir.array<?x!fir.logical<4>>>>
2317 %c1 = arith.constant 1 : index
2318 %7 = fir.alloca !fir.array<1xi32> {bindc_name = "testminloc_doesntwork1d_unknownmask", uniq_name = "_QFtestminloc_doesntwork1d_unknownmaskEtestminloc_doesntwork1d_unknownmask"}
2319 %8 = fir.load %1 : !fir.ref<i32>
2320 %9 = fir.convert %8 : (i32) -> index
2321 %c0 = arith.constant 0 : index
2322 %10 = arith.cmpi sgt, %9, %c0 : index
2323 %11 = arith.select %10, %9, %c0 : index
2324 %12 = fir.allocmem !fir.array<?x!fir.logical<4>>, %11 {fir.must_be_heap = true, uniq_name = "_QFtestminloc_doesntwork1d_unknownmaskEmask.alloc"}
2325 fir.store %12 to %3 : !fir.ref<!fir.heap<!fir.array<?x!fir.logical<4>>>>
2326 fir.store %11 to %5 : !fir.ref<index>
2327 %c1_0 = arith.constant 1 : index
2328 fir.store %c1_0 to %4 : !fir.ref<index>
2329 %13 = fir.shape %c1 : (index) -> !fir.shape<1>
2330 %14 = fir.array_load %7(%13) : (!fir.ref<!fir.array<1xi32>>, !fir.shape<1>) -> !fir.array<1xi32>
2331 %15 = fir.shape %c10 : (index) -> !fir.shape<1>
2332 %16 = fir.embox %arg0(%15) : (!fir.ref<!fir.array<10xi32>>, !fir.shape<1>) -> !fir.box<!fir.array<10xi32>>
2333 %17 = fir.load %3 : !fir.ref<!fir.heap<!fir.array<?x!fir.logical<4>>>>
2334 %18 = fir.convert %17 : (!fir.heap<!fir.array<?x!fir.logical<4>>>) -> i64
2335 %c0_i64 = arith.constant 0 : i64
2336 %19 = arith.cmpi ne, %18, %c0_i64 : i64
2337 %20 = fir.load %4 : !fir.ref<index>
2338 %21 = fir.load %5 : !fir.ref<index>
2339 %22 = fir.load %3 : !fir.ref<!fir.heap<!fir.array<?x!fir.logical<4>>>>
2340 %23 = fir.shape_shift %20, %21 : (index, index) -> !fir.shapeshift<1>
2341 %24 = fir.embox %22(%23) : (!fir.heap<!fir.array<?x!fir.logical<4>>>, !fir.shapeshift<1>) -> !fir.box<!fir.array<?x!fir.logical<4>>>
2342 %25 = fir.absent !fir.box<!fir.array<?x!fir.logical<4>>>
2343 %26 = arith.select %19, %24, %25 : !fir.box<!fir.array<?x!fir.logical<4>>>
2344 %c4 = arith.constant 4 : index
2345 %false = arith.constant false
2346 %27 = fir.zero_bits !fir.heap<!fir.array<?xi32>>
2347 %c0_1 = arith.constant 0 : index
2348 %28 = fir.shape %c0_1 : (index) -> !fir.shape<1>
2349 %29 = fir.embox %27(%28) : (!fir.heap<!fir.array<?xi32>>, !fir.shape<1>) -> !fir.box<!fir.heap<!fir.array<?xi32>>>
2350 fir.store %29 to %0 : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>
2351 %30 = fir.address_of(@_QQclX74460ff3ef22ea53671c22344e1556b9) : !fir.ref<!fir.char<1,41>>
2352 %c7_i32 = arith.constant 7 : i32
2353 %31 = fir.convert %0 : (!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>) -> !fir.ref<!fir.box<none>>
2354 %32 = fir.convert %16 : (!fir.box<!fir.array<10xi32>>) -> !fir.box<none>
2355 %33 = fir.convert %c4 : (index) -> i32
2356 %34 = fir.convert %30 : (!fir.ref<!fir.char<1,41>>) -> !fir.ref<i8>
2357 %35 = fir.convert %26 : (!fir.box<!fir.array<?x!fir.logical<4>>>) -> !fir.box<none>
2358 fir.call @_FortranAMinlocInteger4(%31, %32, %33, %34, %c7_i32, %35, %false) fastmath<contract> : (!fir.ref<!fir.box<none>>, !fir.box<none>, i32, !fir.ref<i8>, i32, !fir.box<none>, i1) -> ()
2359 %37 = fir.load %0 : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>
2360 %c0_2 = arith.constant 0 : index
2361 %38:3 = fir.box_dims %37, %c0_2 : (!fir.box<!fir.heap<!fir.array<?xi32>>>, index) -> (index, index, index)
2362 %39 = fir.box_addr %37 : (!fir.box<!fir.heap<!fir.array<?xi32>>>) -> !fir.heap<!fir.array<?xi32>>
2363 %40 = fir.shape_shift %38#0, %38#1 : (index, index) -> !fir.shapeshift<1>
2364 %41 = fir.array_load %39(%40) : (!fir.heap<!fir.array<?xi32>>, !fir.shapeshift<1>) -> !fir.array<?xi32>
2365 %c1_3 = arith.constant 1 : index
2366 %c0_4 = arith.constant 0 : index
2367 %42 = arith.subi %c1, %c1_3 : index
2368 %43 = fir.do_loop %arg1 = %c0_4 to %42 step %c1_3 unordered iter_args(%arg2 = %14) -> (!fir.array<1xi32>) {
2369 %45 = fir.array_fetch %41, %arg1 : (!fir.array<?xi32>, index) -> i32
2370 %46 = fir.array_update %arg2, %45, %arg1 : (!fir.array<1xi32>, i32, index) -> !fir.array<1xi32>
2371 fir.result %46 : !fir.array<1xi32>
2372 }
2373 fir.array_merge_store %14, %43 to %7 : !fir.array<1xi32>, !fir.array<1xi32>, !fir.ref<!fir.array<1xi32>>
2374 fir.freemem %39 : !fir.heap<!fir.array<?xi32>>
2375 %44 = fir.load %7 : !fir.ref<!fir.array<1xi32>>
2376 return %44 : !fir.array<1xi32>
2377 }
2378
2379 // CHECK-LABEL: func.func @_QPtestminloc_doesntwork1d_unknownmask(
2380 // CHECK-SAME: %[[ARR:.*]]: !fir.ref<!fir.array<10xi32>> {fir.bindc_name = "a"}) -> !fir.array<1xi32> {
2381 // CHECK-NOT: fir.call @_FortranAMinlocInteger4x1_i32_contract_simplified({{.*}}) fastmath<contract> : (!fir.ref<!fir.box<none>>, !fir.box<none>, !fir.box<none>) -> ()
2382 // CHECK: fir.call @_FortranAMinlocInteger4({{.*}}) fastmath<contract> : (!fir.ref<!fir.box<none>>, !fir.box<none>, i32, !fir.ref<i8>, i32, !fir.box<none>, i1) -> ()
2383 // CHECK-NOT: fir.call @_FortranAMinlocInteger4x1_i32_contract_simplified({{.*}}) fastmath<contract> : (!fir.ref<!fir.box<none>>, !fir.box<none>, !fir.box<none>) -> ()
2384
2385 // -----
2386 // Check Maxloc simplifies similarly to minloc
2387 func.func @_QPtestmaxloc_works1d(%arg0: !fir.ref<!fir.array<10xi32>> {fir.bindc_name = "a"}, %arg1: !fir.ref<!fir.array<10x!fir.logical<4>>> {fir.bindc_name = "b"}) -> !fir.array<1xi32> {
2388 %0 = fir.alloca !fir.box<!fir.heap<!fir.array<?xi32>>>
2389 %c10 = arith.constant 10 : index
2390 %c10_0 = arith.constant 10 : index
2391 %c1 = arith.constant 1 : index
2392 %1 = fir.alloca !fir.array<1xi32> {bindc_name = "testmaxloc_works1d", uniq_name = "_QFtestmaxloc_works1dEtestmaxloc_works1d"}
2393 %2 = fir.shape %c1 : (index) -> !fir.shape<1>
2394 %3 = fir.array_load %1(%2) : (!fir.ref<!fir.array<1xi32>>, !fir.shape<1>) -> !fir.array<1xi32>
2395 %4 = fir.shape %c10 : (index) -> !fir.shape<1>
2396 %5 = fir.embox %arg0(%4) : (!fir.ref<!fir.array<10xi32>>, !fir.shape<1>) -> !fir.box<!fir.array<10xi32>>
2397 %6 = fir.shape %c10_0 : (index) -> !fir.shape<1>
2398 %7 = fir.embox %arg1(%6) : (!fir.ref<!fir.array<10x!fir.logical<4>>>, !fir.shape<1>) -> !fir.box<!fir.array<10x!fir.logical<4>>>
2399 %c4 = arith.constant 4 : index
2400 %false = arith.constant false
2401 %8 = fir.zero_bits !fir.heap<!fir.array<?xi32>>
2402 %c0 = arith.constant 0 : index
2403 %9 = fir.shape %c0 : (index) -> !fir.shape<1>
2404 %10 = fir.embox %8(%9) : (!fir.heap<!fir.array<?xi32>>, !fir.shape<1>) -> !fir.box<!fir.heap<!fir.array<?xi32>>>
2405 fir.store %10 to %0 : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>
2406 %11 = fir.address_of(@_QQclXea5bcf7f706678e1796661f8916f3379) : !fir.ref<!fir.char<1,55>>
2407 %c5_i32 = arith.constant 5 : i32
2408 %12 = fir.convert %0 : (!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>) -> !fir.ref<!fir.box<none>>
2409 %13 = fir.convert %5 : (!fir.box<!fir.array<10xi32>>) -> !fir.box<none>
2410 %14 = fir.convert %c4 : (index) -> i32
2411 %15 = fir.convert %11 : (!fir.ref<!fir.char<1,55>>) -> !fir.ref<i8>
2412 %16 = fir.convert %7 : (!fir.box<!fir.array<10x!fir.logical<4>>>) -> !fir.box<none>
2413 fir.call @_FortranAMaxlocInteger4(%12, %13, %14, %15, %c5_i32, %16, %false) fastmath<contract> : (!fir.ref<!fir.box<none>>, !fir.box<none>, i32, !fir.ref<i8>, i32, !fir.box<none>, i1) -> ()
2414 %18 = fir.load %0 : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>
2415 %c0_1 = arith.constant 0 : index
2416 %19:3 = fir.box_dims %18, %c0_1 : (!fir.box<!fir.heap<!fir.array<?xi32>>>, index) -> (index, index, index)
2417 %20 = fir.box_addr %18 : (!fir.box<!fir.heap<!fir.array<?xi32>>>) -> !fir.heap<!fir.array<?xi32>>
2418 %21 = fir.shape_shift %19#0, %19#1 : (index, index) -> !fir.shapeshift<1>
2419 %22 = fir.array_load %20(%21) : (!fir.heap<!fir.array<?xi32>>, !fir.shapeshift<1>) -> !fir.array<?xi32>
2420 %c1_2 = arith.constant 1 : index
2421 %c0_3 = arith.constant 0 : index
2422 %23 = arith.subi %c1, %c1_2 : index
2423 %24 = fir.do_loop %arg2 = %c0_3 to %23 step %c1_2 unordered iter_args(%arg3 = %3) -> (!fir.array<1xi32>) {
2424 %26 = fir.array_fetch %22, %arg2 : (!fir.array<?xi32>, index) -> i32
2425 %27 = fir.array_update %arg3, %26, %arg2 : (!fir.array<1xi32>, i32, index) -> !fir.array<1xi32>
2426 fir.result %27 : !fir.array<1xi32>
2427 }
2428 fir.array_merge_store %3, %24 to %1 : !fir.array<1xi32>, !fir.array<1xi32>, !fir.ref<!fir.array<1xi32>>
2429 fir.freemem %20 : !fir.heap<!fir.array<?xi32>>
2430 %25 = fir.load %1 : !fir.ref<!fir.array<1xi32>>
2431 return %25 : !fir.array<1xi32>
2432 }
2433
2434 // CHECK-LABEL: func.func @_QPtestmaxloc_works1d(
2435 // CHECK-SAME: %[[INARR:.*]]: !fir.ref<!fir.array<10xi32>> {fir.bindc_name = "a"},
2436 // CHECK-SAME: %[[MASK:.*]]: !fir.ref<!fir.array<10x!fir.logical<4>>> {fir.bindc_name = "b"}) -> !fir.array<1xi32> {
2437 // CHECK: %[[OUTARR:.*]] = fir.alloca !fir.box<!fir.heap<!fir.array<?xi32>>>
2438 // CHECK: %[[SIZE10_0:.*]] = arith.constant 10 : index
2439 // CHECK: %[[SIZE10_1:.*]] = arith.constant 10 : index
2440 // CHECK: %[[INARR_SHAPE:.*]] = fir.shape %[[SIZE10_0]] : (index) -> !fir.shape<1>
2441 // CHECK: %[[BOX_INARR:.*]] = fir.embox %[[INARR]](%[[INARR_SHAPE]]) : (!fir.ref<!fir.array<10xi32>>, !fir.shape<1>) -> !fir.box<!fir.array<10xi32>>
2442 // CHECK: %[[MASK_SHAPE:.*]] = fir.shape %[[SIZE10_1]] : (index) -> !fir.shape<1>
2443 // CHECK: %[[BOX_MASK:.*]] = fir.embox %[[MASK]](%[[MASK_SHAPE]]) : (!fir.ref<!fir.array<10x!fir.logical<4>>>, !fir.shape<1>) -> !fir.box<!fir.array<10x!fir.logical<4>>>
2444 // CHECK: %[[REF_BOX_OUTARR_NONE:.*]] = fir.convert %[[OUTARR]] : (!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>) -> !fir.ref<!fir.box<none>>
2445 // CHECK: %[[BOX_INARR_NONE:.*]] = fir.convert %[[BOX_INARR]] : (!fir.box<!fir.array<10xi32>>) -> !fir.box<none>
2446 // CHECK: %[[BOX_MASK_NONE:.*]] = fir.convert %[[BOX_MASK]] : (!fir.box<!fir.array<10x!fir.logical<4>>>) -> !fir.box<none>
2447 // CHECK: fir.call @_FortranAMaxlocInteger4x1_Logical4x1_i32_contract_simplified(%[[REF_BOX_OUTARR_NONE]], %[[BOX_INARR_NONE]], %[[BOX_MASK_NONE]]) fastmath<contract> : (!fir.ref<!fir.box<none>>, !fir.box<none>, !fir.box<none>) -> ()
2448
2449 // CHECK-LABEL: func.func private @_FortranAMaxlocInteger4x1_Logical4x1_i32_contract_simplified(
2450 // CHECK-SAME: %[[REF_BOX_OUTARR_NONE:.*]]: !fir.ref<!fir.box<none>>,
2451 // CHECK-SAME: %[[BOX_INARR_NONE:.*]]: !fir.box<none>,
2452 // CHECK-SAME: %[[BOX_MASK_NONE:.*]]: !fir.box<none>) attributes {llvm.linkage = #llvm.linkage<linkonce_odr>} {
2453 // CHECK: %[[FLAG_ALLOC:.*]] = fir.alloca i32
2454 // CHECK: %[[INIT_OUT_IDX:.*]] = arith.constant 0 : i32
2455 // CHECK: %[[OUTARR_SIZE:.*]] = arith.constant 1 : index
2456 // CHECK: %[[OUTARR:.*]] = fir.allocmem !fir.array<1xi32>
2457 // CHECK: %[[OUTARR_SHAPE:.*]] = fir.shape %[[OUTARR_SIZE]] : (index) -> !fir.shape<1>
2458 // CHECK: %[[BOX_OUTARR:.*]] = fir.embox %[[OUTARR]](%[[OUTARR_SHAPE]]) : (!fir.heap<!fir.array<1xi32>>, !fir.shape<1>) -> !fir.box<!fir.heap<!fir.array<1xi32>>>
2459 // CHECK: %[[BOX_MASK:.*]] = fir.convert %[[BOX_MASK_NONE]] : (!fir.box<none>) -> !fir.box<!fir.array<?x!fir.logical<4>>>
2460 // CHECK: %[[OUTARR_IDX0:.*]] = arith.constant 0 : index
2461 // CHECK: %[[OUTARR_ITEM0:.*]] = fir.coordinate_of %[[BOX_OUTARR]], %[[OUTARR_IDX0]] : (!fir.box<!fir.heap<!fir.array<1xi32>>>, index) -> !fir.ref<i32>
2462 // CHECK: fir.store %[[INIT_OUT_IDX]] to %[[OUTARR_ITEM0]] : !fir.ref<i32>
2463 // CHECK: %[[CINDEX_0:.*]] = arith.constant 0 : index
2464 // CHECK: %[[BOX_INARR:.*]] = fir.convert %[[BOX_INARR_NONE]] : (!fir.box<none>) -> !fir.box<!fir.array<?xi32>>
2465 // CHECK: %[[FLAG_SET:.*]] = arith.constant 1 : i32
2466 // CHECK: %[[FLAG_EMPTY:.*]] = arith.constant 0 : i32
2467 // CHECK: fir.store %[[FLAG_EMPTY]] to %[[FLAG_ALLOC]] : !fir.ref<i32>
2468 // CHECK: %[[MAX:.*]] = arith.constant -2147483648 : i32
2469 // CHECK: %[[CINDEX_1:.*]] = arith.constant 1 : index
2470 // CHECK: %[[DIM_INDEX0:.*]] = arith.constant 0 : index
2471 // CHECK: %[[DIMS:.*]]:3 = fir.box_dims %[[BOX_INARR]], %[[DIM_INDEX0]] : (!fir.box<!fir.array<?xi32>>, index) -> (index, index, index)
2472 // CHECK: %[[EXTENT:.*]] = arith.subi %[[DIMS]]#1, %[[CINDEX_1]] : index
2473 // CHECK: %[[DOLOOP:.*]] = fir.do_loop %[[ITER:.*]] = %[[CINDEX_0]] to %[[EXTENT]] step %[[CINDEX_1]] iter_args(%[[MIN:.*]] = %[[MAX]]) -> (i32) {
2474 // CHECK: %[[MASK_ITEM:.*]] = fir.coordinate_of %[[BOX_MASK]], %[[ITER]] : (!fir.box<!fir.array<?x!fir.logical<4>>>, index) -> !fir.ref<!fir.logical<4>>
2475 // CHECK: %[[MASK_ITEMVAL:.*]] = fir.load %[[MASK_ITEM]] : !fir.ref<!fir.logical<4>>
2476 // CHECK: %[[MASK_IF_ITEM:.*]] = fir.convert %[[MASK_ITEMVAL]] : (!fir.logical<4>) -> i1
2477 // CHECK: %[[IF_MASK:.*]] = fir.if %[[MASK_IF_ITEM]] -> (i32) {
2478 // CHECK: %[[FLAG_SET2:.*]] = arith.constant 1 : i32
2479 // CHECK: %[[ISFIRST:.*]] = fir.load %[[FLAG_ALLOC]] : !fir.ref<i32>
2480 // CHECK: %[[INARR_ITEM:.*]] = fir.coordinate_of %[[BOX_INARR]], %[[ITER]] : (!fir.box<!fir.array<?xi32>>, index) -> !fir.ref<i32>
2481 // CHECK: %[[INARR_ITEMVAL:.*]] = fir.load %[[INARR_ITEM]] : !fir.ref<i32>
2482 // CHECK: %[[NEW_MIN:.*]] = arith.cmpi sgt, %[[INARR_ITEMVAL]], %[[MIN]] : i32
2483 // CHECK: %[[ISFIRSTL:.*]] = fir.convert %[[ISFIRST]] : (i32) -> i1
2484 // CHECK: %[[ISFIRSTNOT:.*]] = arith.xori %[[ISFIRSTL]], %true : i1
2485 // CHECK: %[[ORCOND:.*]] = arith.ori %[[NEW_MIN]], %[[ISFIRSTNOT]] : i1
2486 // CHECK: %[[IF_NEW_MIN:.*]] = fir.if %[[ORCOND]] -> (i32) {
2487 // CHECK: fir.store %[[FLAG_SET2]] to %[[FLAG_ALLOC]] : !fir.ref<i32>
2488 // CHECK: %[[ONE:.*]] = arith.constant 1 : i32
2489 // CHECK: %[[OUTARR_IDX:.*]] = arith.constant 0 : index
2490 // CHECK: %[[OUTARR_ITEM:.*]] = fir.coordinate_of %[[BOX_OUTARR]], %[[OUTARR_IDX]] : (!fir.box<!fir.heap<!fir.array<1xi32>>>, index) -> !fir.ref<i32>
2491 // CHECK: %[[ITER_I32:.*]] = fir.convert %[[ITER]] : (index) -> i32
2492 // CHECK: %[[FORTRAN_IDX:.*]] = arith.addi %[[ITER_I32]], %[[ONE]] : i32
2493 // CHECK: fir.store %[[FORTRAN_IDX]] to %[[OUTARR_ITEM]] : !fir.ref<i32>
2494 // CHECK: fir.result %[[INARR_ITEMVAL]] : i32
2495 // CHECK: } else {
2496 // CHECK: fir.result %[[MIN]] : i32
2497 // CHECK: }
2498 // CHECK: fir.result %[[IF_NEW_MIN:.*]] : i32
2499 // CHECK: } else {
2500 // CHECK: fir.result %[[MIN]] : i32
2501 // CHECK: }
2502 // CHECK: fir.result %[[IF_MASK:.*]] : i32
2503 // CHECK: }
2504 // CHECK: %[[REF_BOX_OUTARR:.*]] = fir.convert %[[REF_BOX_OUTARR_NONE]] : (!fir.ref<!fir.box<none>>) -> !fir.ref<!fir.box<!fir.heap<!fir.array<1xi32>>>>
2505 // CHECK: fir.store %[[BOX_OUTARR]] to %[[REF_BOX_OUTARR]] : !fir.ref<!fir.box<!fir.heap<!fir.array<1xi32>>>>
2506 // CHECK: return
2507 // CHECK: }
2508
2509 // -----
2510 // Check Maxloc simplifies correctly for 1D case with scalar mask and f64 input
2511
2512 func.func @_QPtestmaxloc_works1d_scalarmask_f64(%arg0: !fir.ref<!fir.array<10xf64>> {fir.bindc_name = "a"}, %arg1: !fir.ref<!fir.logical<4>> {fir.bindc_name = "b"}) -> !fir.array<1xi32> {
2513 %0 = fir.alloca !fir.box<!fir.heap<!fir.array<?xi32>>>
2514 %c10 = arith.constant 10 : index
2515 %c1 = arith.constant 1 : index
2516 %1 = fir.alloca !fir.array<1xi32> {bindc_name = "testmaxloc_works1d_scalarmask_f64", uniq_name = "_QFtestmaxloc_works1d_scalarmask_f64Etestminloc_works1d_scalarmask_f64"}
2517 %2 = fir.shape %c1 : (index) -> !fir.shape<1>
2518 %3 = fir.array_load %1(%2) : (!fir.ref<!fir.array<1xi32>>, !fir.shape<1>) -> !fir.array<1xi32>
2519 %4 = fir.shape %c10 : (index) -> !fir.shape<1>
2520 %5 = fir.embox %arg0(%4) : (!fir.ref<!fir.array<10xf64>>, !fir.shape<1>) -> !fir.box<!fir.array<10xf64>>
2521 %6 = fir.embox %arg1 : (!fir.ref<!fir.logical<4>>) -> !fir.box<!fir.logical<4>>
2522 %c4 = arith.constant 4 : index
2523 %false = arith.constant false
2524 %7 = fir.zero_bits !fir.heap<!fir.array<?xi32>>
2525 %c0 = arith.constant 0 : index
2526 %8 = fir.shape %c0 : (index) -> !fir.shape<1>
2527 %9 = fir.embox %7(%8) : (!fir.heap<!fir.array<?xi32>>, !fir.shape<1>) -> !fir.box<!fir.heap<!fir.array<?xi32>>>
2528 fir.store %9 to %0 : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>
2529 %10 = fir.address_of(@_QQclX66951c28c5b8bab5cdb25c1ac762b978) : !fir.ref<!fir.char<1,65>>
2530 %c6_i32 = arith.constant 6 : i32
2531 %11 = fir.convert %0 : (!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>) -> !fir.ref<!fir.box<none>>
2532 %12 = fir.convert %5 : (!fir.box<!fir.array<10xf64>>) -> !fir.box<none>
2533 %13 = fir.convert %c4 : (index) -> i32
2534 %14 = fir.convert %10 : (!fir.ref<!fir.char<1,65>>) -> !fir.ref<i8>
2535 %15 = fir.convert %6 : (!fir.box<!fir.logical<4>>) -> !fir.box<none>
2536 fir.call @_FortranAMaxlocReal8(%11, %12, %13, %14, %c6_i32, %15, %false) fastmath<contract> : (!fir.ref<!fir.box<none>>, !fir.box<none>, i32, !fir.ref<i8>, i32, !fir.box<none>, i1) -> ()
2537 %17 = fir.load %0 : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>
2538 %c0_0 = arith.constant 0 : index
2539 %18:3 = fir.box_dims %17, %c0_0 : (!fir.box<!fir.heap<!fir.array<?xi32>>>, index) -> (index, index, index)
2540 %19 = fir.box_addr %17 : (!fir.box<!fir.heap<!fir.array<?xi32>>>) -> !fir.heap<!fir.array<?xi32>>
2541 %20 = fir.shape_shift %18#0, %18#1 : (index, index) -> !fir.shapeshift<1>
2542 %21 = fir.array_load %19(%20) : (!fir.heap<!fir.array<?xi32>>, !fir.shapeshift<1>) -> !fir.array<?xi32>
2543 %c1_1 = arith.constant 1 : index
2544 %c0_2 = arith.constant 0 : index
2545 %22 = arith.subi %c1, %c1_1 : index
2546 %23 = fir.do_loop %arg2 = %c0_2 to %22 step %c1_1 unordered iter_args(%arg3 = %3) -> (!fir.array<1xi32>) {
2547 %25 = fir.array_fetch %21, %arg2 : (!fir.array<?xi32>, index) -> i32
2548 %26 = fir.array_update %arg3, %25, %arg2 : (!fir.array<1xi32>, i32, index) -> !fir.array<1xi32>
2549 fir.result %26 : !fir.array<1xi32>
2550 }
2551 fir.array_merge_store %3, %23 to %1 : !fir.array<1xi32>, !fir.array<1xi32>, !fir.ref<!fir.array<1xi32>>
2552 fir.freemem %19 : !fir.heap<!fir.array<?xi32>>
2553 %24 = fir.load %1 : !fir.ref<!fir.array<1xi32>>
2554 return %24 : !fir.array<1xi32>
2555 }
2556
2557 // CHECK-LABEL: func.func @_QPtestmaxloc_works1d_scalarmask_f64(
2558 // CHECK-SAME: %[[INARR:.*]]: !fir.ref<!fir.array<10xf64>> {fir.bindc_name = "a"},
2559 // CHECK-SAME: %[[MASK:.*]]: !fir.ref<!fir.logical<4>> {fir.bindc_name = "b"}) -> !fir.array<1xi32> {
2560 // CHECK: fir.call @_FortranAMaxlocReal8x1_Logical4x0_i32_contract_simplified({{.*}}, {{.*}}, {{.*}}) fastmath<contract> : (!fir.ref<!fir.box<none>>, !fir.box<none>, !fir.box<none>) -> ()
2561
2562 // CHECK-LABEL: func.func private @_FortranAMaxlocReal8x1_Logical4x0_i32_contract_simplified(
2563 // CHECK-SAME: %[[REF_BOX_OUTARR_NONE:.*]]: !fir.ref<!fir.box<none>>,
2564 // CHECK-SAME: %[[BOX_INARR_NONE:.*]]: !fir.box<none>,
2565 // CHECK-SAME: %[[BOX_MASK_NONE:.*]]: !fir.box<none>) attributes {llvm.linkage = #llvm.linkage<linkonce_odr>} {
2566 // CHECK: %[[FLAG_ALLOC:.*]] = fir.alloca i32
2567 // CHECK: %[[INIT_OUT_IDX:.*]] = arith.constant 0 : i32
2568 // CHECK: %[[OUTARR_SIZE:.*]] = arith.constant 1 : index
2569 // CHECK: %[[OUTARR:.*]] = fir.allocmem !fir.array<1xi32>
2570 // CHECK: %[[OUTARR_SHAPE:.*]] = fir.shape %[[OUTARR_SIZE]] : (index) -> !fir.shape<1>
2571 // CHECK: %[[BOX_OUTARR:.*]] = fir.embox %[[OUTARR]](%[[OUTARR_SHAPE]]) : (!fir.heap<!fir.array<1xi32>>, !fir.shape<1>) -> !fir.box<!fir.heap<!fir.array<1xi32>>>
2572 // CHECK: %[[OUTARR_IDX0:.*]] = arith.constant 0 : index
2573 // CHECK: %[[OUTARR_ITEM0:.*]] = fir.coordinate_of %[[BOX_OUTARR]], %[[OUTARR_IDX0]] : (!fir.box<!fir.heap<!fir.array<1xi32>>>, index) -> !fir.ref<i32>
2574 // CHECK: fir.store %[[INIT_OUT_IDX]] to %[[OUTARR_ITEM0]] : !fir.ref<i32>
2575 // CHECK: %[[MASK_ADDR:.*]] = fir.box_addr %[[BOX_MASK_NONE]] : (!fir.box<none>) -> !fir.ref<!fir.logical<4>>
2576 // CHECK: %[[MASK_LOGICAL:.*]] = fir.load %[[MASK_ADDR]] : !fir.ref<!fir.logical<4>>
2577 // CHECK: %[[MASK:.*]] = fir.convert %[[MASK_LOGICAL]] : (!fir.logical<4>) -> i1
2578 // CHECK: %[[INIT_RES:.*]] = fir.if %[[MASK]] -> (f64) {
2579 // CHECK: %[[C_INDEX0:.*]] = arith.constant 0 : index
2580 // CHECK: %[[BOX_INARR:.*]] = fir.convert %[[BOX_INARR_NONE]] : (!fir.box<none>) -> !fir.box<!fir.array<?xf64>>
2581 // CHECK: %[[FLAG_SET:.*]] = arith.constant 1 : i32
2582 // CHECK: %[[FLAG_EMPTY:.*]] = arith.constant 0 : i32
2583 // CHECK: fir.store %[[FLAG_EMPTY]] to %[[FLAG_ALLOC]] : !fir.ref<i32>
2584 // CHECK: %[[MAX:.*]] = arith.constant 0xFFF0000000000000 : f64
2585 // CHECK: %[[C_INDEX1:.*]] = arith.constant 1 : index
2586 // CHECK: %[[DIM_INDEX:.*]] = arith.constant 0 : index
2587 // CHECK: %[[DIMS:.*]]:3 = fir.box_dims %[[BOX_INARR]], %[[DIM_INDEX]] : (!fir.box<!fir.array<?xf64>>, index) -> (index, index, index)
2588 // CHECK: %[[EXTENT:.*]] = arith.subi %[[DIMS]]#1, %[[C_INDEX1]] : index
2589 // CHECK: %[[DOLOOP:.*]] = fir.do_loop %[[ITER:.*]] = %[[C_INDEX0]] to %[[EXTENT]] step %[[C_INDEX1]] iter_args(%[[MIN:.*]] = %[[MAX]]) -> (f64) {
2590 // CHECK: %[[FLAG_SET2:.*]] = arith.constant 1 : i32
2591 // CHECK: %[[ISFIRST:.*]] = fir.load %[[FLAG_ALLOC]] : !fir.ref<i32>
2592 // CHECK: %[[INARR_ITEM:.*]] = fir.coordinate_of %[[BOX_INARR]], %[[ITER]] : (!fir.box<!fir.array<?xf64>>, index) -> !fir.ref<f64>
2593 // CHECK: %[[INARR_ITEMVAL:.*]] = fir.load %[[INARR_ITEM]] : !fir.ref<f64>
2594 // CHECK: %[[NEW_MIN:.*]] = arith.cmpf ogt, %[[INARR_ITEMVAL]], %arg4 fastmath<contract> : f64
2595 // CHECK: %[[CONDRED:.*]] = arith.cmpf une, %arg4, %arg4 fastmath<contract> : f64
2596 // CHECK: %[[CONDELEM:.*]] = arith.cmpf oeq, %[[INARR_ITEMVAL]], %[[INARR_ITEMVAL]] fastmath<contract> : f64
2597 // CHECK: %[[ANDCOND:.*]] = arith.andi %[[CONDRED]], %[[CONDELEM]] : i1
2598 // CHECK: %[[NEW_MIN2:.*]] = arith.ori %[[NEW_MIN]], %[[ANDCOND]] : i1
2599 // CHECK: %[[ISFIRSTL:.*]] = fir.convert %[[ISFIRST]] : (i32) -> i1
2600 // CHECK: %[[ISFIRSTNOT:.*]] = arith.xori %[[ISFIRSTL]], %true : i1
2601 // CHECK: %[[ORCOND:.*]] = arith.ori %[[NEW_MIN2]], %[[ISFIRSTNOT]] : i1
2602 // CHECK: %[[IF_NEW_MIN:.*]] = fir.if %[[ORCOND]] -> (f64) {
2603 // CHECK: %[[ONE:.*]] = arith.constant 1 : i32
2604 // CHECK: %[[OUTARR_IDX:.*]] = arith.constant 0 : index
2605 // CHECK: %[[OUTARR_ITEM:.*]] = fir.coordinate_of %[[BOX_OUTARR]], %[[OUTARR_IDX]] : (!fir.box<!fir.heap<!fir.array<1xi32>>>, index) -> !fir.ref<i32>
2606 // CHECK: %[[ITER_I32:.*]] = fir.convert %[[ITER]] : (index) -> i32
2607 // CHECK: %[[FORTRAN_IDX:.*]] = arith.addi %[[ITER_I32]], %[[ONE]] : i32
2608 // CHECK: fir.store %[[FORTRAN_IDX]] to %[[OUTARR_ITEM]] : !fir.ref<i32>
2609 // CHECK: fir.result %[[INARR_ITEMVAL]] : f64
2610 // CHECK: } else {
2611 // CHECK: fir.result %[[MIN]] : f64
2612 // CHECK: }
2613 // CHECK: fir.result %[[IF_NEW_MIN:.*]] : f64
2614 // CHECK: }
2615 // CHECK: }
2616 // CHECK: %[[REF_BOX_OUTARR:.*]] = fir.convert %[[VAL_0]] : (!fir.ref<!fir.box<none>>) -> !fir.ref<!fir.box<!fir.heap<!fir.array<1xi32>>>>
2617 // CHECK: fir.store %[[BOX_OUTARR]] to %[[REF_BOX_OUTARR]] : !fir.ref<!fir.box<!fir.heap<!fir.array<1xi32>>>>
2618 // CHECK: return
2619 // CHECK: }