Skip to content

Commit 9e4472e

Browse files
nikicflovent
nikic
authored and
flovent
committed
[MLIR][LLVMIR] Always use TargetFolder in IRBuilder (llvm#126929)
This is a followup to llvm#126745, generalizing it to always use TargetFolder, including inside function bodies. This avoids generating non-canonical constant expressions that can be folded away.
1 parent 88a4d24 commit 9e4472e

19 files changed

+71
-71
lines changed

‎flang/test/Fir/alloc.fir

+18-18
Original file line numberDiff line numberDiff line change
@@ -19,14 +19,14 @@ func.func @alloca_scalars_nonchar() -> !fir.ref<i32> {
1919
}
2020

2121
// CHECK-LABEL: define ptr @allocmem_scalar_nonchar(
22-
// CHECK: call ptr @malloc(i64 ptrtoint (ptr getelementptr (i32, ptr null, i32 1) to i64))
22+
// CHECK: call ptr @malloc(i64 4)
2323
func.func @allocmem_scalar_nonchar() -> !fir.heap<i32> {
2424
%1 = fir.allocmem i32
2525
return %1 : !fir.heap<i32>
2626
}
2727

2828
// CHECK-LABEL: define ptr @allocmem_scalars_nonchar(
29-
// CHECK: call ptr @malloc(i64 mul (i64 ptrtoint (ptr getelementptr (i32, ptr null, i32 1) to i64), i64 100))
29+
// CHECK: call ptr @malloc(i64 400)
3030
func.func @allocmem_scalars_nonchar() -> !fir.heap<i32> {
3131
%0 = arith.constant 100 : index
3232
%1 = fir.allocmem i32, %0
@@ -48,14 +48,14 @@ func.func @alloca_scalar_char_kind() -> !fir.ref<!fir.char<2,10>> {
4848
}
4949

5050
// CHECK-LABEL: define ptr @allocmem_scalar_char(
51-
// CHECK: call ptr @malloc(i64 ptrtoint (ptr getelementptr ([10 x i8], ptr null, i32 1) to i64))
51+
// CHECK: call ptr @malloc(i64 10)
5252
func.func @allocmem_scalar_char() -> !fir.heap<!fir.char<1,10>> {
5353
%1 = fir.allocmem !fir.char<1,10>
5454
return %1 : !fir.heap<!fir.char<1,10>>
5555
}
5656

5757
// CHECK-LABEL: define ptr @allocmem_scalar_char_kind(
58-
// CHECK: call ptr @malloc(i64 ptrtoint (ptr getelementptr ([10 x i16], ptr null, i32 1) to i64))
58+
// CHECK: call ptr @malloc(i64 20)
5959
func.func @allocmem_scalar_char_kind() -> !fir.heap<!fir.char<2,10>> {
6060
%1 = fir.allocmem !fir.char<2,10>
6161
return %1 : !fir.heap<!fir.char<2,10>>
@@ -82,7 +82,7 @@ func.func @alloca_scalar_dynchar_kind(%l : i32) -> !fir.ref<!fir.char<2,?>> {
8282
// CHECK-LABEL: define ptr @allocmem_scalar_dynchar(
8383
// CHECK-SAME: i32 %[[len:.*]])
8484
// CHECK: %[[mul1:.*]] = sext i32 %[[len]] to i64
85-
// CHECK: %[[mul2:.*]] = mul i64 ptrtoint (ptr getelementptr (i8, ptr null, i32 1) to i64), %[[mul1]]
85+
// CHECK: %[[mul2:.*]] = mul i64 1, %[[mul1]]
8686
// CHECK: call ptr @malloc(i64 %[[mul2]])
8787
func.func @allocmem_scalar_dynchar(%l : i32) -> !fir.heap<!fir.char<1,?>> {
8888
%1 = fir.allocmem !fir.char<1,?>(%l : i32)
@@ -92,7 +92,7 @@ func.func @allocmem_scalar_dynchar(%l : i32) -> !fir.heap<!fir.char<1,?>> {
9292
// CHECK-LABEL: define ptr @allocmem_scalar_dynchar_kind(
9393
// CHECK-SAME: i32 %[[len:.*]])
9494
// CHECK: %[[mul1:.*]] = sext i32 %[[len]] to i64
95-
// CHECK: %[[mul2:.*]] = mul i64 ptrtoint (ptr getelementptr (i16, ptr null, i32 1) to i64), %[[mul1]]
95+
// CHECK: %[[mul2:.*]] = mul i64 2, %[[mul1]]
9696
// CHECK: call ptr @malloc(i64 %[[mul2]])
9797
func.func @allocmem_scalar_dynchar_kind(%l : i32) -> !fir.heap<!fir.char<2,?>>{
9898
%1 = fir.allocmem !fir.char<2,?>(%l : i32)
@@ -131,14 +131,14 @@ func.func @alloca_array_of_dynchar(%l: i32) -> !fir.ref<!fir.array<3x3x!fir.char
131131
}
132132

133133
// CHECK-LABEL: define ptr @allocmem_array_of_nonchar(
134-
// CHECK: call ptr @malloc(i64 ptrtoint (ptr getelementptr ([3 x [3 x i32]], ptr null, i32 1) to i64))
134+
// CHECK: call ptr @malloc(i64 36)
135135
func.func @allocmem_array_of_nonchar() -> !fir.heap<!fir.array<3x3xi32>> {
136136
%1 = fir.allocmem !fir.array<3x3xi32>
137137
return %1 : !fir.heap<!fir.array<3x3xi32>>
138138
}
139139

140140
// CHECK-LABEL: define ptr @allocmem_array_of_char(
141-
// CHECK: call ptr @malloc(i64 ptrtoint (ptr getelementptr ([3 x [3 x [10 x i8]]], ptr null, i32 1) to i64))
141+
// CHECK: call ptr @malloc(i64 90)
142142
func.func @allocmem_array_of_char() -> !fir.heap<!fir.array<3x3x!fir.char<1,10>>> {
143143
%1 = fir.allocmem !fir.array<3x3x!fir.char<1,10>>
144144
return %1 : !fir.heap<!fir.array<3x3x!fir.char<1,10>>>
@@ -147,7 +147,7 @@ func.func @allocmem_array_of_char() -> !fir.heap<!fir.array<3x3x!fir.char<1,10>>
147147
// CHECK-LABEL: define ptr @allocmem_array_of_dynchar(
148148
// CHECK-SAME: i32 %[[len:.*]])
149149
// CHECK: %[[mul1:.*]] = sext i32 %[[len]] to i64
150-
// CHECK: %[[mul2:.*]] = mul i64 mul (i64 ptrtoint (ptr getelementptr (i8, ptr null, i32 1) to i64), i64 9), %[[mul1]]
150+
// CHECK: %[[mul2:.*]] = mul i64 9, %[[mul1]]
151151
// CHECK: call ptr @malloc(i64 %[[mul2]])
152152
func.func @allocmem_array_of_dynchar(%l: i32) -> !fir.heap<!fir.array<3x3x!fir.char<1,?>>> {
153153
%1 = fir.allocmem !fir.array<3x3x!fir.char<1,?>>(%l : i32)
@@ -175,7 +175,7 @@ func.func @alloca_dynarray_of_nonchar2(%e: index) -> !fir.ref<!fir.array<?x?xi32
175175

176176
// CHECK-LABEL: define ptr @allocmem_dynarray_of_nonchar(
177177
// CHECK-SAME: i64 %[[extent:.*]])
178-
// CHECK: %[[prod1:.*]] = mul i64 ptrtoint (ptr getelementptr ([3 x i32], ptr null, i32 1) to i64), %[[extent]]
178+
// CHECK: %[[prod1:.*]] = mul i64 12, %[[extent]]
179179
// CHECK: call ptr @malloc(i64 %[[prod1]])
180180
func.func @allocmem_dynarray_of_nonchar(%e: index) -> !fir.heap<!fir.array<3x?xi32>> {
181181
%1 = fir.allocmem !fir.array<3x?xi32>, %e
@@ -184,7 +184,7 @@ func.func @allocmem_dynarray_of_nonchar(%e: index) -> !fir.heap<!fir.array<3x?xi
184184

185185
// CHECK-LABEL: define ptr @allocmem_dynarray_of_nonchar2(
186186
// CHECK-SAME: i64 %[[extent:.*]])
187-
// CHECK: %[[prod1:.*]] = mul i64 ptrtoint (ptr getelementptr (i32, ptr null, i32 1) to i64), %[[extent]]
187+
// CHECK: %[[prod1:.*]] = mul i64 4, %[[extent]]
188188
// CHECK: %[[prod2:.*]] = mul i64 %[[prod1]], %[[extent]]
189189
// CHECK: call ptr @malloc(i64 %[[prod2]])
190190
func.func @allocmem_dynarray_of_nonchar2(%e: index) -> !fir.heap<!fir.array<?x?xi32>> {
@@ -213,7 +213,7 @@ func.func @alloca_dynarray_of_char2(%e : index) -> !fir.ref<!fir.array<?x?x!fir.
213213

214214
// CHECK-LABEL: define ptr @allocmem_dynarray_of_char(
215215
// CHECK-SAME: i64 %[[extent:.*]])
216-
// CHECK: %[[prod1:.*]] = mul i64 ptrtoint (ptr getelementptr ([3 x [10 x i16]], ptr null, i32 1) to i64), %[[extent]]
216+
// CHECK: %[[prod1:.*]] = mul i64 60, %[[extent]]
217217
// CHECK: call ptr @malloc(i64 %[[prod1]])
218218
func.func @allocmem_dynarray_of_char(%e : index) -> !fir.heap<!fir.array<3x?x!fir.char<2,10>>> {
219219
%1 = fir.allocmem !fir.array<3x?x!fir.char<2,10>>, %e
@@ -222,7 +222,7 @@ func.func @allocmem_dynarray_of_char(%e : index) -> !fir.heap<!fir.array<3x?x!fi
222222

223223
// CHECK-LABEL: define ptr @allocmem_dynarray_of_char2(
224224
// CHECK-SAME: i64 %[[extent:.*]])
225-
// CHECK: %[[prod1:.*]] = mul i64 ptrtoint (ptr getelementptr ([10 x i16], ptr null, i32 1) to i64), %[[extent]]
225+
// CHECK: %[[prod1:.*]] = mul i64 20, %[[extent]]
226226
// CHECK: %[[prod2:.*]] = mul i64 %[[prod1]], %[[extent]]
227227
// CHECK: call ptr @malloc(i64 %[[prod2]])
228228
func.func @allocmem_dynarray_of_char2(%e : index) -> !fir.heap<!fir.array<?x?x!fir.char<2,10>>> {
@@ -255,7 +255,7 @@ func.func @alloca_dynarray_of_dynchar2(%l: i32, %e : index) -> !fir.ref<!fir.arr
255255
// CHECK-LABEL: define ptr @allocmem_dynarray_of_dynchar(
256256
// CHECK-SAME: i32 %[[len:.*]], i64 %[[extent:.*]])
257257
// CHECK: %[[prod1:.*]] = sext i32 %[[len]] to i64
258-
// CHECK: %[[prod2:.*]] = mul i64 mul (i64 ptrtoint (ptr getelementptr (i16, ptr null, i32 1) to i64), i64 3), %[[prod1]]
258+
// CHECK: %[[prod2:.*]] = mul i64 6, %[[prod1]]
259259
// CHECK: %[[prod3:.*]] = mul i64 %[[prod2]], %[[extent]]
260260
// CHECK: call ptr @malloc(i64 %[[prod3]])
261261
func.func @allocmem_dynarray_of_dynchar(%l: i32, %e : index) -> !fir.heap<!fir.array<3x?x!fir.char<2,?>>> {
@@ -266,7 +266,7 @@ func.func @allocmem_dynarray_of_dynchar(%l: i32, %e : index) -> !fir.heap<!fir.a
266266
// CHECK-LABEL: define ptr @allocmem_dynarray_of_dynchar2(
267267
// CHECK-SAME: i32 %[[len:.*]], i64 %[[extent:.*]])
268268
// CHECK: %[[a:.*]] = sext i32 %[[len]] to i64
269-
// CHECK: %[[prod1:.*]] = mul i64 ptrtoint (ptr getelementptr (i16, ptr null, i32 1) to i64), %[[a]]
269+
// CHECK: %[[prod1:.*]] = mul i64 2, %[[a]]
270270
// CHECK: %[[prod2:.*]] = mul i64 %[[prod1]], %[[extent]]
271271
// CHECK: %[[prod3:.*]] = mul i64 %[[prod2]], %[[extent]]
272272
// CHECK: call ptr @malloc(i64 %[[prod3]])
@@ -306,7 +306,7 @@ func.func @alloca_array_with_holes_dynchar(%arg0: index, %arg1: index) -> !fir.r
306306

307307
// CHECK-LABEL: define ptr @allocmem_array_with_holes_nonchar(
308308
// CHECK-SAME: i64 %[[e1:.*]], i64 %[[e2:.*]])
309-
// CHECK: %[[a:.*]] = mul i64 mul (i64 ptrtoint{{.*}} 15), %[[e1]]
309+
// CHECK: %[[a:.*]] = mul i64 240, %[[e1]]
310310
// CHECK: %[[b:.*]] = mul i64 %3, %[[e2]]
311311
// CHECK: call ptr @malloc(i64 %[[b]])
312312
func.func @allocmem_array_with_holes_nonchar(%0 : index, %1 : index) -> !fir.heap<!fir.array<4x?x3x?x5xi32>> {
@@ -316,7 +316,7 @@ func.func @allocmem_array_with_holes_nonchar(%0 : index, %1 : index) -> !fir.hea
316316

317317
// CHECK-LABEL: define ptr @allocmem_array_with_holes_char(
318318
// CHECK-SAME: i64 %[[e:.*]])
319-
// CHECK: %[[mul:.*]] = mul i64 mul (i64 ptrtoint (ptr getelementptr ([3 x [10 x i16]], ptr null, i32 1) to i64), i64 4), %[[e]]
319+
// CHECK: %[[mul:.*]] = mul i64 240, %[[e]]
320320
// CHECK: call ptr @malloc(i64 %[[mul]])
321321
func.func @allocmem_array_with_holes_char(%e: index) -> !fir.heap<!fir.array<3x?x4x!fir.char<2,10>>> {
322322
%1 = fir.allocmem !fir.array<3x?x4x!fir.char<2,10>>, %e
@@ -325,7 +325,7 @@ func.func @allocmem_array_with_holes_char(%e: index) -> !fir.heap<!fir.array<3x?
325325

326326
// CHECK-LABEL: define ptr @allocmem_array_with_holes_dynchar(
327327
// CHECK-SAME: i64 %[[len:.*]], i64 %[[extent:.*]])
328-
// CHECK: %[[a:.*]] = mul i64 mul (i64 ptrtoint (ptr getelementptr (i16, ptr null, i32 1) to i64), i64 12), %[[len]]
328+
// CHECK: %[[a:.*]] = mul i64 24, %[[len]]
329329
// CHECK: %[[b:.*]] = mul i64 %[[a]], %[[extent]]
330330
// CHECK: call ptr @malloc(i64 %[[b]])
331331
func.func @allocmem_array_with_holes_dynchar(%arg0: index, %arg1: index) -> !fir.heap<!fir.array<3x?x4x!fir.char<2,?>>> {

‎flang/test/Fir/arrexp.fir

+1-1
Original file line numberDiff line numberDiff line change
@@ -145,7 +145,7 @@ func.func @f6(%arg0: !fir.box<!fir.array<?xf32>>, %arg1: f32) {
145145

146146
// CHECK: %[[EXT_GEP:.*]] = getelementptr {{.*}} %[[A]], i32 0, i32 7, i64 0, i32 1
147147
// CHECK: %[[EXTENT:.*]] = load i64, ptr %[[EXT_GEP]]
148-
// CHECK: %[[SIZE:.*]] = mul i64 ptrtoint (ptr getelementptr (float, ptr null, i32 1) to i64), %[[EXTENT]]
148+
// CHECK: %[[SIZE:.*]] = mul i64 4, %[[EXTENT]]
149149
// CHECK: %[[MALLOC:.*]] = call ptr @malloc(i64 %[[SIZE]])
150150
%1 = fir.slice %c2, %c10, %c1 : (index, index, index) -> !fir.slice<1>
151151
%2 = fir.array_load %arg0 [%1] : (!fir.box<!fir.array<?xf32>>, !fir.slice<1>) -> !fir.array<?xf32>

‎flang/test/Fir/box.fir

+10-10
Original file line numberDiff line numberDiff line change
@@ -27,7 +27,7 @@ func.func private @ga(%b : !fir.box<!fir.array<?xf32>>)
2727
// CHECK: (ptr captures(none) %[[ARG:.*]])
2828
func.func @f(%a : !fir.ref<f32>) {
2929
// CHECK: %[[DESC:.*]] = alloca { ptr, i64, i32, i8, i8, i8, i8 }
30-
// CHECK: %[[INS0:.*]] = insertvalue {{.*}} { ptr undef, i64 ptrtoint (ptr getelementptr (float, ptr null, i32 1) to i64), i32 20240719, i8 0, i8 27, i8 0, i8 0 }, ptr %[[ARG]], 0
30+
// CHECK: %[[INS0:.*]] = insertvalue {{.*}} { ptr undef, i64 4, i32 20240719, i8 0, i8 27, i8 0, i8 0 }, ptr %[[ARG]], 0
3131
// CHECK: store {{.*}} %[[INS0]], {{.*}} %[[DESC]]
3232
%b = fir.embox %a : (!fir.ref<f32>) -> !fir.box<f32>
3333

@@ -44,7 +44,7 @@ func.func @fa(%a : !fir.ref<!fir.array<100xf32>>) {
4444
%c1 = arith.constant 1 : index
4545
%c100 = arith.constant 100 : index
4646
%d = fir.shape %c100 : (index) -> !fir.shape<1>
47-
// CHECK: %[[INS70:.*]] = insertvalue {{.*}} { ptr undef, i64 ptrtoint (ptr getelementptr (float, ptr null, i32 1) to i64), i32 20240719, i8 1, i8 27, i8 0, i8 0, {{.*}} }, ptr %{{.*}}, 0
47+
// CHECK: %[[INS70:.*]] = insertvalue {{.*}} { ptr undef, i64 4, i32 20240719, i8 1, i8 27, i8 0, i8 0, {{.*}} }, ptr %{{.*}}, 0
4848
%b = fir.embox %c(%d) : (!fir.ref<!fir.array<?xf32>>, !fir.shape<1>) -> !fir.box<!fir.array<?xf32>>
4949
// CHECK: call void @ga(
5050
fir.call @ga(%b) : (!fir.box<!fir.array<?xf32>>) -> ()
@@ -57,7 +57,7 @@ func.func @fa(%a : !fir.ref<!fir.array<100xf32>>) {
5757
// CHECK-SAME: ptr captures(none) %[[res:.*]], ptr captures(none) %[[arg0:.*]], i64 %[[arg1:.*]])
5858
func.func @b1(%arg0 : !fir.ref<!fir.char<1,?>>, %arg1 : index) -> !fir.box<!fir.char<1,?>> {
5959
// CHECK: %[[alloca:.*]] = alloca { ptr, i64, i32, i8, i8, i8, i8 }
60-
// CHECK: %[[size:.*]] = mul i64 ptrtoint (ptr getelementptr (i8, ptr null, i32 1) to i64), %[[arg1]]
60+
// CHECK: %[[size:.*]] = mul i64 1, %[[arg1]]
6161
// CHECK: insertvalue {{.*}} undef, i64 %[[size]], 1
6262
// CHECK: insertvalue {{.*}} i32 20240719, 2
6363
// CHECK: insertvalue {{.*}} ptr %[[arg0]], 0
@@ -74,8 +74,8 @@ func.func @b1(%arg0 : !fir.ref<!fir.char<1,?>>, %arg1 : index) -> !fir.box<!fir.
7474
func.func @b2(%arg0 : !fir.ref<!fir.array<?x!fir.char<1,5>>>, %arg1 : index) -> !fir.box<!fir.array<?x!fir.char<1,5>>> {
7575
%1 = fir.shape %arg1 : (index) -> !fir.shape<1>
7676
// CHECK: %[[alloca:.*]] = alloca { ptr, i64, i32, i8, i8, i8, i8, [1 x [3 x i64]] }
77-
// CHECK: insertvalue {{.*}} { ptr undef, i64 ptrtoint (ptr getelementptr ([5 x i8], ptr null, i32 1) to i64), i32 20240719, i8 1, i8 40, i8 0, i8 0, {{.*}} }, i64 %[[arg1]], 7, 0, 1
78-
// CHECK: insertvalue {{.*}} %{{.*}}, i64 ptrtoint (ptr getelementptr ([5 x i8], ptr null, i32 1) to i64), 7, 0, 2
77+
// CHECK: insertvalue {{.*}} { ptr undef, i64 5, i32 20240719, i8 1, i8 40, i8 0, i8 0, {{.*}} }, i64 %[[arg1]], 7, 0, 1
78+
// CHECK: insertvalue {{.*}} %{{.*}}, i64 5, 7, 0, 2
7979
// CHECK: insertvalue {{.*}} ptr %[[arg0]], 0
8080
%2 = fir.embox %arg0(%1) : (!fir.ref<!fir.array<?x!fir.char<1,5>>>, !fir.shape<1>) -> !fir.box<!fir.array<?x!fir.char<1,5>>>
8181
// CHECK: store {{.*}}, ptr %[[alloca]]
@@ -89,7 +89,7 @@ func.func @b2(%arg0 : !fir.ref<!fir.array<?x!fir.char<1,5>>>, %arg1 : index) ->
8989
func.func @b3(%arg0 : !fir.ref<!fir.array<?x!fir.char<1,?>>>, %arg1 : index, %arg2 : index) -> !fir.box<!fir.array<?x!fir.char<1,?>>> {
9090
%1 = fir.shape %arg2 : (index) -> !fir.shape<1>
9191
// CHECK: %[[alloca:.*]] = alloca { ptr, i64, i32, i8, i8, i8, i8, [1 x [3 x i64]] }
92-
// CHECK: %[[size:.*]] = mul i64 ptrtoint (ptr getelementptr (i8, ptr null, i32 1) to i64), %[[arg1]]
92+
// CHECK: %[[size:.*]] = mul i64 1, %[[arg1]]
9393
// CHECK: insertvalue {{.*}} i64 %[[size]], 1
9494
// CHECK: insertvalue {{.*}} i32 20240719, 2
9595
// CHECK: insertvalue {{.*}} i64 %[[arg2]], 7, 0, 1
@@ -108,7 +108,7 @@ func.func @b4(%arg0 : !fir.ref<!fir.array<7x!fir.char<1,?>>>, %arg1 : index) ->
108108
%c_7 = arith.constant 7 : index
109109
%1 = fir.shape %c_7 : (index) -> !fir.shape<1>
110110
// CHECK: %[[alloca:.*]] = alloca { ptr, i64, i32, i8, i8, i8, i8, [1 x [3 x i64]] }
111-
// CHECK: %[[size:.*]] = mul i64 ptrtoint (ptr getelementptr (i8, ptr null, i32 1) to i64), %[[arg1]]
111+
// CHECK: %[[size:.*]] = mul i64 1, %[[arg1]]
112112
// CHECK: insertvalue {{.*}} i64 %[[size]], 1
113113
// CHECK: insertvalue {{.*}} i32 20240719, 2
114114
// CHECK: insertvalue {{.*}} i64 7, 7, 0, 1
@@ -154,12 +154,12 @@ func.func @box6(%0 : !fir.ref<!fir.array<?x?x?x?xf32>>, %1 : index, %2 : index)
154154
// CHECK: %[[sdp2:.*]] = sdiv i64 %[[dp2]], 2
155155
// CHECK: %[[cmp:.*]] = icmp sgt i64 %[[sdp2]], 0
156156
// CHECK: %[[extent:.*]] = select i1 %[[cmp]], i64 %[[sdp2]], i64 0
157-
// CHECK: insertvalue { ptr, i64, i32, i8, i8, i8, i8, [2 x [3 x i64]] } { ptr undef, i64 ptrtoint (ptr getelementptr (float, ptr null, i32 1) to i64), i32 20240719, i8 2, i8 27, i8 0, i8 0, [2 x [3 x i64]] [{{\[}}3 x i64] [i64 1, i64 undef, i64 undef], [3 x i64] undef] }, i64 %[[extent]], 7, 0, 1
158-
// CHECK: insertvalue { ptr, i64, i32, i8, i8, i8, i8, [2 x [3 x i64]] } %{{.*}}, i64 mul (i64 ptrtoint (ptr getelementptr (float, ptr null, i32 1) to i64), i64 200), 7, 0, 2
157+
// CHECK: insertvalue { ptr, i64, i32, i8, i8, i8, i8, [2 x [3 x i64]] } { ptr undef, i64 4, i32 20240719, i8 2, i8 27, i8 0, i8 0, [2 x [3 x i64]] [{{\[}}3 x i64] [i64 1, i64 undef, i64 undef], [3 x i64] undef] }, i64 %[[extent]], 7, 0, 1
158+
// CHECK: insertvalue { ptr, i64, i32, i8, i8, i8, i8, [2 x [3 x i64]] } %{{.*}}, i64 800, 7, 0, 2
159159
// CHECK: %[[op25:.*]] = add i64 25000, %[[i100p40]]
160160
// CHECK: insertvalue { ptr, i64, i32, i8, i8, i8, i8, [2 x [3 x i64]] } %{{.*}}, i64 1, 7, 1, 0
161161
// CHECK: insertvalue { ptr, i64, i32, i8, i8, i8, i8, [2 x [3 x i64]] } %{{.*}}, i64 4, 7, 1, 1
162-
// CHECK: insertvalue { ptr, i64, i32, i8, i8, i8, i8, [2 x [3 x i64]] } %{{.*}}, i64 mul (i64 ptrtoint (ptr getelementptr (float, ptr null, i32 1) to i64), i64 30000), 7, 1, 2
162+
// CHECK: insertvalue { ptr, i64, i32, i8, i8, i8, i8, [2 x [3 x i64]] } %{{.*}}, i64 120000, 7, 1, 2
163163
// CHECK: %[[op300:.*]] = add i64 300000, %[[op25]]
164164
// CHECK: %[[ptr:.*]] = getelementptr float, ptr %[[ARG0]], i64 %[[op300]]
165165
// CHECK: insertvalue { ptr, i64, i32, i8, i8, i8, i8, [2 x [3 x i64]] } %{{.*}}, ptr %[[ptr]], 0

‎flang/test/Fir/embox.fir

+7-8
Original file line numberDiff line numberDiff line change
@@ -13,8 +13,8 @@ func.func @_QPtest_slice() {
1313
// CHECK: %[[a2:.*]] = alloca [20 x i32], i64 1, align 4
1414
// CHECK: %[[a3:.*]] = getelementptr [20 x i32], ptr %[[a2]], i64 0, i64 0
1515
// CHECK: %[[a4:.*]] = insertvalue { ptr, i64, i32, i8, i8, i8, i8, [1 x [3 x i64]] }
16-
// CHECK: { ptr undef, i64 ptrtoint (ptr getelementptr (i32, ptr null, i32 1) to i64), i32 20240719, i8 1, i8 9, i8 0, i8 0, [1 x [3 x i64]]
17-
// CHECK: [i64 1, i64 5, i64 mul (i64 ptrtoint (ptr getelementptr (i32, ptr null, i32 1) to i64), i64 2)]] }, ptr %[[a3]], 0
16+
// CHECK: { ptr undef, i64 4, i32 20240719, i8 1, i8 9, i8 0, i8 0, [1 x [3 x i64]]
17+
// CHECK: [i64 1, i64 5, i64 8]] }, ptr %[[a3]], 0
1818
// CHECK: store { ptr, i64, i32, i8, i8, i8, i8, [1 x [3 x i64]] } %[[a4]], ptr %[[a1]], align 8
1919
// CHECK: call void @_QPtest_callee(ptr %[[a1]])
2020
%c20 = arith.constant 20 : index
@@ -40,9 +40,8 @@ func.func @_QPtest_dt_slice() {
4040
// CHECK: %[[a3:.*]] = alloca [20 x %_QFtest_dt_sliceTt], i64 1, align 8
4141
// CHECK: %[[a4:.*]] = getelementptr [20 x %_QFtest_dt_sliceTt], ptr %[[a3]], i64 0, i64 0, i32 0
4242
// CHECK: %[[a5:.*]] = insertvalue { ptr, i64, i32, i8, i8, i8, i8, [1 x [3 x i64]] }
43-
// CHECK-SAME: { ptr undef, i64 ptrtoint (ptr getelementptr (i32, ptr null, i32 1) to i64), i32 20240719, i8 1, i8 9, i8 0, i8 0, [1 x [3 x i64]]
44-
// CHECK-SAME: [i64 1, i64 5, i64 mul
45-
// CHECK-SAME: (i64 ptrtoint (ptr getelementptr (%_QFtest_dt_sliceTt, ptr null, i32 1) to i64), i64 2)]] }
43+
// CHECK-SAME: { ptr undef, i64 4, i32 20240719, i8 1, i8 9, i8 0, i8 0, [1 x [3 x i64]]
44+
// CHECK-SAME: [i64 1, i64 5, i64 16
4645
// CHECK-SAME: , ptr %[[a4]], 0
4746

4847
// CHECK: store { ptr, i64, i32, i8, i8, i8, i8, [1 x [3 x i64]] } %[[a5]], ptr %[[a1]], align 8
@@ -75,7 +74,7 @@ func.func @emboxSubstring(%arg0: !fir.ref<!fir.array<2x3x!fir.char<1,4>>>) {
7574
%1 = fir.slice %c1, %c2, %c1, %c1, %c3, %c1 substr %c1_i64, %c2_i64 : (index, index, index, index, index, index, i64, i64) -> !fir.slice<2>
7675
%2 = fir.embox %arg0(%0) [%1] : (!fir.ref<!fir.array<2x3x!fir.char<1,4>>>, !fir.shape<2>, !fir.slice<2>) -> !fir.box<!fir.array<?x?x!fir.char<1,?>>>
7776
// CHECK: %[[addr:.*]] = getelementptr [3 x [2 x [4 x i8]]], ptr %[[arg0]], i64 0, i64 0, i64 0, i64 1
78-
// CHECK: insertvalue {[[descriptorType:.*]]} { ptr undef, i64 mul (i64 ptrtoint (ptr getelementptr (i8, ptr null, i32 1) to i64), i64 2), i32 20240719, i8 2, i8 40, i8 0, i8 0
77+
// CHECK: insertvalue {[[descriptorType:.*]]} { ptr undef, i64 2, i32 20240719, i8 2, i8 40, i8 0, i8 0
7978
// CHECK-SAME: [2 x [3 x i64]] [{{\[}}3 x i64] [i64 1, i64 2, i64 4], [3 x i64] [i64 1, i64 3, i64 8]] }
8079
// CHECK-SAME: ptr %[[addr]], 0
8180

@@ -98,7 +97,7 @@ func.func @fir_dev_issue_1416(%arg0: !fir.ref<!fir.array<40x?xf32>>, %low: index
9897
// CHECK: %[[offset:.*]] = add i64 %[[mul]], 0
9998
// CHECK: %[[addr:.*]] = getelementptr [40 x float], ptr %0, i64 %[[offset]], i64 0
10099
// CHECK: %[[box:.*]] = insertvalue { ptr, i64, i32, i8, i8, i8, i8, [1 x [3 x i64]] }
101-
// CHECK-SAME: { ptr undef, i64 ptrtoint (ptr getelementptr (float, ptr null, i32 1) to i64), i32 20240719, i8 1, i8 27, i8 0, i8 0, [1 x [3 x i64]] [{{.*}} [i64 1, i64 40, i64 ptrtoint (ptr getelementptr (float, ptr null, i32 1) to i64)]] }, ptr %[[addr]], 0
100+
// CHECK-SAME: { ptr undef, i64 4, i32 20240719, i8 1, i8 27, i8 0, i8 0, [1 x [3 x i64]] [{{.*}} [i64 1, i64 40, i64 4]] }, ptr %[[addr]], 0
102101
%3 = fir.embox %arg0(%1) [%2] : (!fir.ref<!fir.array<40x?xf32>>, !fir.shapeshift<2>, !fir.slice<2>) -> !fir.box<!fir.array<?xf32>>
103102
fir.call @do_something(%3) : (!fir.box<!fir.array<?xf32>>) -> ()
104103
return
@@ -126,4 +125,4 @@ func.func @_QPtest_allocator2() {
126125
return
127126
}
128127

129-
// CHECK: %{{.*}} = insertvalue { ptr, i64, i32, i8, i8, i8, i8, [1 x [3 x i64]] } { ptr undef, i64 ptrtoint (ptr getelementptr (i32, ptr null, i32 1) to i64), i32 20240719, i8 1, i8 9, i8 0, i8 6
128+
// CHECK: %{{.*}} = insertvalue { ptr, i64, i32, i8, i8, i8, i8, [1 x [3 x i64]] } { ptr undef, i64 4, i32 20240719, i8 1, i8 9, i8 0, i8 6

0 commit comments

Comments
 (0)