Skip to content

Commit 8ed77fd

Browse files
bjorn3bjorn3
committed
Update tests for 32bit targets
1 parent ccd1bc2 commit 8ed77fd

File tree

6 files changed

+162
-55
lines changed

6 files changed

+162
-55
lines changed

‎tests/codegen/float/f128.rs

+79-27
Original file line numberDiff line numberDiff line change
@@ -1,7 +1,11 @@
11
// 32-bit x86 returns `f32` and `f64` differently to avoid the x87 stack.
2-
//@ revisions: x86 other
2+
// 32-bit systems will return 128bit values using a return area pointer.
3+
//@ revisions: x86 bit32 bit64
34
//@[x86] only-x86
4-
//@[other] ignore-x86
5+
//@[bit32] ignore-x86
6+
//@[bit32] only-32bit
7+
//@[bit64] ignore-x86
8+
//@[bit64] only-64bit
59

610
// Verify that our intrinsics generate the correct LLVM calls for f128
711

@@ -52,42 +56,54 @@ pub fn f128_le(a: f128, b: f128) -> bool {
5256
a <= b
5357
}
5458

55-
// CHECK-LABEL: fp128 @f128_neg(
59+
// x86-LABEL: void @f128_neg({{.*}}sret([16 x i8])
60+
// bit32-LABEL: void @f128_neg({{.*}}sret([16 x i8])
61+
// bit64-LABEL: fp128 @f128_neg(
5662
#[no_mangle]
5763
pub fn f128_neg(a: f128) -> f128 {
5864
// CHECK: fneg fp128
5965
-a
6066
}
6167

62-
// CHECK-LABEL: fp128 @f128_add(
68+
// x86-LABEL: void @f128_add({{.*}}sret([16 x i8])
69+
// bit32-LABEL: void @f128_add({{.*}}sret([16 x i8])
70+
// bit64-LABEL: fp128 @f128_add(
6371
#[no_mangle]
6472
pub fn f128_add(a: f128, b: f128) -> f128 {
6573
// CHECK: fadd fp128 %{{.+}}, %{{.+}}
6674
a + b
6775
}
6876

69-
// CHECK-LABEL: fp128 @f128_sub(
77+
// x86-LABEL: void @f128_sub({{.*}}sret([16 x i8])
78+
// bit32-LABEL: void @f128_sub({{.*}}sret([16 x i8])
79+
// bit64-LABEL: fp128 @f128_sub(
7080
#[no_mangle]
7181
pub fn f128_sub(a: f128, b: f128) -> f128 {
7282
// CHECK: fsub fp128 %{{.+}}, %{{.+}}
7383
a - b
7484
}
7585

76-
// CHECK-LABEL: fp128 @f128_mul(
86+
// x86-LABEL: void @f128_mul({{.*}}sret([16 x i8])
87+
// bit32-LABEL: void @f128_mul({{.*}}sret([16 x i8])
88+
// bit64-LABEL: fp128 @f128_mul(
7789
#[no_mangle]
7890
pub fn f128_mul(a: f128, b: f128) -> f128 {
7991
// CHECK: fmul fp128 %{{.+}}, %{{.+}}
8092
a * b
8193
}
8294

83-
// CHECK-LABEL: fp128 @f128_div(
95+
// x86-LABEL: void @f128_div({{.*}}sret([16 x i8])
96+
// bit32-LABEL: void @f128_div({{.*}}sret([16 x i8])
97+
// bit64-LABEL: fp128 @f128_div(
8498
#[no_mangle]
8599
pub fn f128_div(a: f128, b: f128) -> f128 {
86100
// CHECK: fdiv fp128 %{{.+}}, %{{.+}}
87101
a / b
88102
}
89103

90-
// CHECK-LABEL: fp128 @f128_rem(
104+
// x86-LABEL: void @f128_rem({{.*}}sret([16 x i8])
105+
// bit32-LABEL: void @f128_rem({{.*}}sret([16 x i8])
106+
// bit64-LABEL: fp128 @f128_rem(
91107
#[no_mangle]
92108
pub fn f128_rem(a: f128, b: f128) -> f128 {
93109
// CHECK: frem fp128 %{{.+}}, %{{.+}}
@@ -143,44 +159,56 @@ pub fn f128_as_f16(a: f128) -> f16 {
143159
a as f16
144160
}
145161

146-
// other-LABEL: float @f128_as_f32(
147162
// x86-LABEL: i32 @f128_as_f32(
163+
// bit32-LABEL: float @f128_as_f32(
164+
// bit64-LABEL: float @f128_as_f32(
148165
#[no_mangle]
149166
pub fn f128_as_f32(a: f128) -> f32 {
150167
// CHECK: fptrunc fp128 %{{.+}} to float
151168
a as f32
152169
}
153170

154-
// other-LABEL: double @f128_as_f64(
155171
// x86-LABEL: void @f128_as_f64(
172+
// bit32-LABEL: double @f128_as_f64(
173+
// bit64-LABEL: double @f128_as_f64(
156174
#[no_mangle]
157175
pub fn f128_as_f64(a: f128) -> f64 {
158176
// CHECK: fptrunc fp128 %{{.+}} to double
159177
a as f64
160178
}
161179

162-
// CHECK-LABEL: fp128 @f128_as_self(
180+
// x86-LABEL: void @f128_as_self({{.*}}sret([16 x i8])
181+
// bit32-LABEL: void @f128_as_self({{.*}}sret([16 x i8])
182+
// bit64-LABEL: fp128 @f128_as_self(
163183
#[no_mangle]
164184
pub fn f128_as_self(a: f128) -> f128 {
165-
// CHECK: ret fp128 %{{.+}}
185+
// x86: store fp128 %a, ptr %_0, align 16
186+
// bit32: store fp128 %a, ptr %_0, align 16
187+
// bit64: ret fp128 %{{.+}}
166188
a as f128
167189
}
168190

169-
// CHECK-LABEL: fp128 @f16_as_f128(
191+
// x86-LABEL: void @f16_as_f128({{.*}}sret([16 x i8])
192+
// bit32-LABEL: void @f16_as_f128({{.*}}sret([16 x i8])
193+
// bit64-LABEL: fp128 @f16_as_f128(
170194
#[no_mangle]
171195
pub fn f16_as_f128(a: f16) -> f128 {
172196
// CHECK: fpext half %{{.+}} to fp128
173197
a as f128
174198
}
175199

176-
// CHECK-LABEL: fp128 @f32_as_f128(
200+
// x86-LABEL: void @f32_as_f128({{.*}}sret([16 x i8])
201+
// bit32-LABEL: void @f32_as_f128({{.*}}sret([16 x i8])
202+
// bit64-LABEL: fp128 @f32_as_f128(
177203
#[no_mangle]
178204
pub fn f32_as_f128(a: f32) -> f128 {
179205
// CHECK: fpext float %{{.+}} to fp128
180206
a as f128
181207
}
182208

183-
// CHECK-LABEL: fp128 @f64_as_f128(
209+
// x86-LABEL: void @f64_as_f128({{.*}}sret([16 x i8])
210+
// bit32-LABEL: void @f64_as_f128({{.*}}sret([16 x i8])
211+
// bit64-LABEL: fp128 @f64_as_f128(
184212
#[no_mangle]
185213
pub fn f64_as_f128(a: f64) -> f128 {
186214
// CHECK: fpext double %{{.+}} to fp128
@@ -216,7 +244,9 @@ pub fn f128_as_u64(a: f128) -> u64 {
216244
a as u64
217245
}
218246

219-
// CHECK-LABEL: i128 @f128_as_u128(
247+
// x86-LABEL: void @f128_as_u128({{.*}}sret([16 x i8])
248+
// bit32-LABEL: void @f128_as_u128({{.*}}sret([16 x i8])
249+
// bit64-LABEL: i128 @f128_as_u128(
220250
#[no_mangle]
221251
pub fn f128_as_u128(a: f128) -> u128 {
222252
// CHECK: call i128 @llvm.fptoui.sat.i128.f128(fp128 %{{.+}})
@@ -250,7 +280,9 @@ pub fn f128_as_i64(a: f128) -> i64 {
250280
a as i64
251281
}
252282

253-
// CHECK-LABEL: i128 @f128_as_i128(
283+
// x86-LABEL: void @f128_as_i128({{.*}}sret([16 x i8])
284+
// bit32-LABEL: void @f128_as_i128({{.*}}sret([16 x i8])
285+
// bit64-LABEL: i128 @f128_as_i128(
254286
#[no_mangle]
255287
pub fn f128_as_i128(a: f128) -> i128 {
256288
// CHECK: call i128 @llvm.fptosi.sat.i128.f128(fp128 %{{.+}})
@@ -259,70 +291,90 @@ pub fn f128_as_i128(a: f128) -> i128 {
259291

260292
/* int to float conversions */
261293

262-
// CHECK-LABEL: fp128 @u8_as_f128(
294+
// x86-LABEL: void @u8_as_f128({{.*}}sret([16 x i8])
295+
// bit32-LABEL: void @u8_as_f128({{.*}}sret([16 x i8])
296+
// bit64-LABEL: fp128 @u8_as_f128(
263297
#[no_mangle]
264298
pub fn u8_as_f128(a: u8) -> f128 {
265299
// CHECK: uitofp i8 %{{.+}} to fp128
266300
a as f128
267301
}
268302

269-
// CHECK-LABEL: fp128 @u16_as_f128(
303+
// x86-LABEL: void @u16_as_f128({{.*}}sret([16 x i8])
304+
// bit32-LABEL: void @u16_as_f128({{.*}}sret([16 x i8])
305+
// bit64-LABEL: fp128 @u16_as_f128(
270306
#[no_mangle]
271307
pub fn u16_as_f128(a: u16) -> f128 {
272308
// CHECK: uitofp i16 %{{.+}} to fp128
273309
a as f128
274310
}
275311

276-
// CHECK-LABEL: fp128 @u32_as_f128(
312+
// x86-LABEL: void @u32_as_f128({{.*}}sret([16 x i8])
313+
// bit32-LABEL: void @u32_as_f128({{.*}}sret([16 x i8])
314+
// bit64-LABEL: fp128 @u32_as_f128(
277315
#[no_mangle]
278316
pub fn u32_as_f128(a: u32) -> f128 {
279317
// CHECK: uitofp i32 %{{.+}} to fp128
280318
a as f128
281319
}
282320

283-
// CHECK-LABEL: fp128 @u64_as_f128(
321+
// x86-LABEL: void @u64_as_f128({{.*}}sret([16 x i8])
322+
// bit32-LABEL: void @u64_as_f128({{.*}}sret([16 x i8])
323+
// bit64-LABEL: fp128 @u64_as_f128(
284324
#[no_mangle]
285325
pub fn u64_as_f128(a: u64) -> f128 {
286326
// CHECK: uitofp i64 %{{.+}} to fp128
287327
a as f128
288328
}
289329

290-
// CHECK-LABEL: fp128 @u128_as_f128(
330+
// x86-LABEL: void @u128_as_f128({{.*}}sret([16 x i8])
331+
// bit32-LABEL: void @u128_as_f128({{.*}}sret([16 x i8])
332+
// bit64-LABEL: fp128 @u128_as_f128(
291333
#[no_mangle]
292334
pub fn u128_as_f128(a: u128) -> f128 {
293335
// CHECK: uitofp i128 %{{.+}} to fp128
294336
a as f128
295337
}
296338

297-
// CHECK-LABEL: fp128 @i8_as_f128(
339+
// x86-LABEL: void @i8_as_f128({{.*}}sret([16 x i8])
340+
// bit32-LABEL: void @i8_as_f128({{.*}}sret([16 x i8])
341+
// bit64-LABEL: fp128 @i8_as_f128(
298342
#[no_mangle]
299343
pub fn i8_as_f128(a: i8) -> f128 {
300344
// CHECK: sitofp i8 %{{.+}} to fp128
301345
a as f128
302346
}
303347

304-
// CHECK-LABEL: fp128 @i16_as_f128(
348+
// x86-LABEL: void @i16_as_f128({{.*}}sret([16 x i8])
349+
// bit32-LABEL: void @i16_as_f128({{.*}}sret([16 x i8])
350+
// bit64-LABEL: fp128 @i16_as_f128(
305351
#[no_mangle]
306352
pub fn i16_as_f128(a: i16) -> f128 {
307353
// CHECK: sitofp i16 %{{.+}} to fp128
308354
a as f128
309355
}
310356

311-
// CHECK-LABEL: fp128 @i32_as_f128(
357+
// x86-LABEL: void @i32_as_f128({{.*}}sret([16 x i8])
358+
// bit32-LABEL: void @i32_as_f128({{.*}}sret([16 x i8])
359+
// bit64-LABEL: fp128 @i32_as_f128(
312360
#[no_mangle]
313361
pub fn i32_as_f128(a: i32) -> f128 {
314362
// CHECK: sitofp i32 %{{.+}} to fp128
315363
a as f128
316364
}
317365

318-
// CHECK-LABEL: fp128 @i64_as_f128(
366+
// x86-LABEL: void @i64_as_f128({{.*}}sret([16 x i8])
367+
// bit32-LABEL: void @i64_as_f128({{.*}}sret([16 x i8])
368+
// bit64-LABEL: fp128 @i64_as_f128(
319369
#[no_mangle]
320370
pub fn i64_as_f128(a: i64) -> f128 {
321371
// CHECK: sitofp i64 %{{.+}} to fp128
322372
a as f128
323373
}
324374

325-
// CHECK-LABEL: fp128 @i128_as_f128(
375+
// x86-LABEL: void @i128_as_f128({{.*}}sret([16 x i8])
376+
// bit32-LABEL: void @i128_as_f128({{.*}}sret([16 x i8])
377+
// bit64-LABEL: fp128 @i128_as_f128(
326378
#[no_mangle]
327379
pub fn i128_as_f128(a: i128) -> f128 {
328380
// CHECK: sitofp i128 %{{.+}} to fp128

‎tests/codegen/float/f16.rs

+19-7
Original file line numberDiff line numberDiff line change
@@ -1,7 +1,11 @@
11
// 32-bit x86 returns `f32` and `f64` differently to avoid the x87 stack.
2-
//@ revisions: x86 other
2+
// 32-bit systems will return 128bit values using a return area pointer.
3+
//@ revisions: x86 bit32 bit64
34
//@[x86] only-x86
4-
//@[other] ignore-x86
5+
//@[bit32] ignore-x86
6+
//@[bit32] only-32bit
7+
//@[bit64] ignore-x86
8+
//@[bit64] only-64bit
59

610
// Verify that our intrinsics generate the correct LLVM calls for f16
711

@@ -145,23 +149,27 @@ pub fn f16_as_self(a: f16) -> f16 {
145149
a as f16
146150
}
147151

148-
// other-LABEL: float @f16_as_f32(
149152
// x86-LABEL: i32 @f16_as_f32(
153+
// bit32-LABEL: float @f16_as_f32(
154+
// bit64-LABEL: float @f16_as_f32(
150155
#[no_mangle]
151156
pub fn f16_as_f32(a: f16) -> f32 {
152157
// CHECK: fpext half %{{.+}} to float
153158
a as f32
154159
}
155160

156-
// other-LABEL: double @f16_as_f64(
157161
// x86-LABEL: void @f16_as_f64(
162+
// bit32-LABEL: double @f16_as_f64(
163+
// bit64-LABEL: double @f16_as_f64(
158164
#[no_mangle]
159165
pub fn f16_as_f64(a: f16) -> f64 {
160166
// CHECK: fpext half %{{.+}} to double
161167
a as f64
162168
}
163169

164-
// CHECK-LABEL: fp128 @f16_as_f128(
170+
// x86-LABEL: void @f16_as_f128({{.*}}sret([16 x i8])
171+
// bit32-LABEL: void @f16_as_f128({{.*}}sret([16 x i8])
172+
// bit64-LABEL: fp128 @f16_as_f128(
165173
#[no_mangle]
166174
pub fn f16_as_f128(a: f16) -> f128 {
167175
// CHECK: fpext half %{{.+}} to fp128
@@ -218,7 +226,9 @@ pub fn f16_as_u64(a: f16) -> u64 {
218226
a as u64
219227
}
220228

221-
// CHECK-LABEL: i128 @f16_as_u128(
229+
// x86-LABEL: void @f16_as_u128({{.*}}sret([16 x i8])
230+
// bit32-LABEL: void @f16_as_u128({{.*}}sret([16 x i8])
231+
// bit64-LABEL: i128 @f16_as_u128(
222232
#[no_mangle]
223233
pub fn f16_as_u128(a: f16) -> u128 {
224234
// CHECK: call i128 @llvm.fptoui.sat.i128.f16(half %{{.+}})
@@ -252,7 +262,9 @@ pub fn f16_as_i64(a: f16) -> i64 {
252262
a as i64
253263
}
254264

255-
// CHECK-LABEL: i128 @f16_as_i128(
265+
// x86-LABEL: void @f16_as_i128({{.*}}sret([16 x i8])
266+
// bit32-LABEL: void @f16_as_i128({{.*}}sret([16 x i8])
267+
// bit64-LABEL: i128 @f16_as_i128(
256268
#[no_mangle]
257269
pub fn f16_as_i128(a: f16) -> i128 {
258270
// CHECK: call i128 @llvm.fptosi.sat.i128.f16(half %{{.+}})

‎tests/codegen/mir-aggregate-no-alloca.rs

+22-8
Original file line numberDiff line numberDiff line change
@@ -1,3 +1,7 @@
1+
// 32-bit systems will return 128bit values using a return area pointer.
2+
//@ revisions: bit32 bit64
3+
//@[bit32] only-32bit
4+
//@[bit64] only-64bit
15
//@ compile-flags: -O -C no-prepopulate-passes -Z randomize-layout=no
26

37
#![crate_type = "lib"]
@@ -98,26 +102,36 @@ pub fn make_struct_1(a: i32) -> Struct1 {
98102

99103
pub struct Struct2Asc(i16, i64);
100104

101-
// CHECK-LABEL: { i64, i16 } @make_struct_2_asc(i16 noundef %a, i64 noundef %b)
105+
// bit32-LABEL: void @make_struct_2_asc({{.*}} sret([16 x i8]) {{.*}} %s,
106+
// bit64-LABEL: { i64, i16 } @make_struct_2_asc(
107+
// CHECK-SAME: i16 noundef %a, i64 noundef %b)
102108
#[no_mangle]
103109
pub fn make_struct_2_asc(a: i16, b: i64) -> Struct2Asc {
104110
// CHECK-NOT: alloca
105-
// CHECK: %[[TEMP0:.+]] = insertvalue { i64, i16 } poison, i64 %b, 0
106-
// CHECK: %[[TEMP1:.+]] = insertvalue { i64, i16 } %[[TEMP0]], i16 %a, 1
107-
// CHECK: ret { i64, i16 } %[[TEMP1]]
111+
// bit32: %[[GEP:.+]] = getelementptr inbounds i8, ptr %s, i32 8
112+
// bit32: store i16 %a, ptr %[[GEP]], align 8
113+
// bit32: store i64 %b, ptr %s, align 8
114+
// bit64: %[[TEMP0:.+]] = insertvalue { i64, i16 } poison, i64 %b, 0
115+
// bit64: %[[TEMP1:.+]] = insertvalue { i64, i16 } %[[TEMP0]], i16 %a, 1
116+
// bit64: ret { i64, i16 } %[[TEMP1]]
108117
let s = Struct2Asc(a, b);
109118
s
110119
}
111120

112121
pub struct Struct2Desc(i64, i16);
113122

114-
// CHECK-LABEL: { i64, i16 } @make_struct_2_desc(i64 noundef %a, i16 noundef %b)
123+
// bit32-LABEL: void @make_struct_2_desc({{.*}} sret([16 x i8]) {{.*}} %s,
124+
// bit64-LABEL: { i64, i16 } @make_struct_2_desc(
125+
// CHECK-SAME: i64 noundef %a, i16 noundef %b)
115126
#[no_mangle]
116127
pub fn make_struct_2_desc(a: i64, b: i16) -> Struct2Desc {
117128
// CHECK-NOT: alloca
118-
// CHECK: %[[TEMP0:.+]] = insertvalue { i64, i16 } poison, i64 %a, 0
119-
// CHECK: %[[TEMP1:.+]] = insertvalue { i64, i16 } %[[TEMP0]], i16 %b, 1
120-
// CHECK: ret { i64, i16 } %[[TEMP1]]
129+
// bit32: store i64 %a, ptr %s, align 8
130+
// bit32: %[[GEP:.+]] = getelementptr inbounds i8, ptr %s, i32 8
131+
// bit32: store i16 %b, ptr %[[GEP]], align 8
132+
// bit64: %[[TEMP0:.+]] = insertvalue { i64, i16 } poison, i64 %a, 0
133+
// bit64: %[[TEMP1:.+]] = insertvalue { i64, i16 } %[[TEMP0]], i16 %b, 1
134+
// bit64: ret { i64, i16 } %[[TEMP1]]
121135
let s = Struct2Desc(a, b);
122136
s
123137
}

0 commit comments

Comments
 (0)