mirror of
https://github.com/rust-lang/rust.git
synced 2024-11-26 08:44:35 +00:00
Update tests for 32bit targets
This commit is contained in:
bjorn3
parent
ccd1bc2ad1
commit
8ed77fd29e
@ -1,7 +1,11 @@
|
||||
// 32-bit x86 returns `f32` and `f64` differently to avoid the x87 stack.
|
||||
//@ revisions: x86 other
|
||||
// 32-bit systems will return 128bit values using a return area pointer.
|
||||
//@ revisions: x86 bit32 bit64
|
||||
//@[x86] only-x86
|
||||
//@[other] ignore-x86
|
||||
//@[bit32] ignore-x86
|
||||
//@[bit32] only-32bit
|
||||
//@[bit64] ignore-x86
|
||||
//@[bit64] only-64bit
|
||||
|
||||
// Verify that our intrinsics generate the correct LLVM calls for f128
|
||||
|
||||
@ -52,42 +56,54 @@ pub fn f128_le(a: f128, b: f128) -> bool {
|
||||
a <= b
|
||||
}
|
||||
|
||||
// CHECK-LABEL: fp128 @f128_neg(
|
||||
// x86-LABEL: void @f128_neg({{.*}}sret([16 x i8])
|
||||
// bit32-LABEL: void @f128_neg({{.*}}sret([16 x i8])
|
||||
// bit64-LABEL: fp128 @f128_neg(
|
||||
#[no_mangle]
|
||||
pub fn f128_neg(a: f128) -> f128 {
|
||||
// CHECK: fneg fp128
|
||||
-a
|
||||
}
|
||||
|
||||
// CHECK-LABEL: fp128 @f128_add(
|
||||
// x86-LABEL: void @f128_add({{.*}}sret([16 x i8])
|
||||
// bit32-LABEL: void @f128_add({{.*}}sret([16 x i8])
|
||||
// bit64-LABEL: fp128 @f128_add(
|
||||
#[no_mangle]
|
||||
pub fn f128_add(a: f128, b: f128) -> f128 {
|
||||
// CHECK: fadd fp128 %{{.+}}, %{{.+}}
|
||||
a + b
|
||||
}
|
||||
|
||||
// CHECK-LABEL: fp128 @f128_sub(
|
||||
// x86-LABEL: void @f128_sub({{.*}}sret([16 x i8])
|
||||
// bit32-LABEL: void @f128_sub({{.*}}sret([16 x i8])
|
||||
// bit64-LABEL: fp128 @f128_sub(
|
||||
#[no_mangle]
|
||||
pub fn f128_sub(a: f128, b: f128) -> f128 {
|
||||
// CHECK: fsub fp128 %{{.+}}, %{{.+}}
|
||||
a - b
|
||||
}
|
||||
|
||||
// CHECK-LABEL: fp128 @f128_mul(
|
||||
// x86-LABEL: void @f128_mul({{.*}}sret([16 x i8])
|
||||
// bit32-LABEL: void @f128_mul({{.*}}sret([16 x i8])
|
||||
// bit64-LABEL: fp128 @f128_mul(
|
||||
#[no_mangle]
|
||||
pub fn f128_mul(a: f128, b: f128) -> f128 {
|
||||
// CHECK: fmul fp128 %{{.+}}, %{{.+}}
|
||||
a * b
|
||||
}
|
||||
|
||||
// CHECK-LABEL: fp128 @f128_div(
|
||||
// x86-LABEL: void @f128_div({{.*}}sret([16 x i8])
|
||||
// bit32-LABEL: void @f128_div({{.*}}sret([16 x i8])
|
||||
// bit64-LABEL: fp128 @f128_div(
|
||||
#[no_mangle]
|
||||
pub fn f128_div(a: f128, b: f128) -> f128 {
|
||||
// CHECK: fdiv fp128 %{{.+}}, %{{.+}}
|
||||
a / b
|
||||
}
|
||||
|
||||
// CHECK-LABEL: fp128 @f128_rem(
|
||||
// x86-LABEL: void @f128_rem({{.*}}sret([16 x i8])
|
||||
// bit32-LABEL: void @f128_rem({{.*}}sret([16 x i8])
|
||||
// bit64-LABEL: fp128 @f128_rem(
|
||||
#[no_mangle]
|
||||
pub fn f128_rem(a: f128, b: f128) -> f128 {
|
||||
// CHECK: frem fp128 %{{.+}}, %{{.+}}
|
||||
@ -143,44 +159,56 @@ pub fn f128_as_f16(a: f128) -> f16 {
|
||||
a as f16
|
||||
}
|
||||
|
||||
// other-LABEL: float @f128_as_f32(
|
||||
// x86-LABEL: i32 @f128_as_f32(
|
||||
// bit32-LABEL: float @f128_as_f32(
|
||||
// bit64-LABEL: float @f128_as_f32(
|
||||
#[no_mangle]
|
||||
pub fn f128_as_f32(a: f128) -> f32 {
|
||||
// CHECK: fptrunc fp128 %{{.+}} to float
|
||||
a as f32
|
||||
}
|
||||
|
||||
// other-LABEL: double @f128_as_f64(
|
||||
// x86-LABEL: void @f128_as_f64(
|
||||
// bit32-LABEL: double @f128_as_f64(
|
||||
// bit64-LABEL: double @f128_as_f64(
|
||||
#[no_mangle]
|
||||
pub fn f128_as_f64(a: f128) -> f64 {
|
||||
// CHECK: fptrunc fp128 %{{.+}} to double
|
||||
a as f64
|
||||
}
|
||||
|
||||
// CHECK-LABEL: fp128 @f128_as_self(
|
||||
// x86-LABEL: void @f128_as_self({{.*}}sret([16 x i8])
|
||||
// bit32-LABEL: void @f128_as_self({{.*}}sret([16 x i8])
|
||||
// bit64-LABEL: fp128 @f128_as_self(
|
||||
#[no_mangle]
|
||||
pub fn f128_as_self(a: f128) -> f128 {
|
||||
// CHECK: ret fp128 %{{.+}}
|
||||
// x86: store fp128 %a, ptr %_0, align 16
|
||||
// bit32: store fp128 %a, ptr %_0, align 16
|
||||
// bit64: ret fp128 %{{.+}}
|
||||
a as f128
|
||||
}
|
||||
|
||||
// CHECK-LABEL: fp128 @f16_as_f128(
|
||||
// x86-LABEL: void @f16_as_f128({{.*}}sret([16 x i8])
|
||||
// bit32-LABEL: void @f16_as_f128({{.*}}sret([16 x i8])
|
||||
// bit64-LABEL: fp128 @f16_as_f128(
|
||||
#[no_mangle]
|
||||
pub fn f16_as_f128(a: f16) -> f128 {
|
||||
// CHECK: fpext half %{{.+}} to fp128
|
||||
a as f128
|
||||
}
|
||||
|
||||
// CHECK-LABEL: fp128 @f32_as_f128(
|
||||
// x86-LABEL: void @f32_as_f128({{.*}}sret([16 x i8])
|
||||
// bit32-LABEL: void @f32_as_f128({{.*}}sret([16 x i8])
|
||||
// bit64-LABEL: fp128 @f32_as_f128(
|
||||
#[no_mangle]
|
||||
pub fn f32_as_f128(a: f32) -> f128 {
|
||||
// CHECK: fpext float %{{.+}} to fp128
|
||||
a as f128
|
||||
}
|
||||
|
||||
// CHECK-LABEL: fp128 @f64_as_f128(
|
||||
// x86-LABEL: void @f64_as_f128({{.*}}sret([16 x i8])
|
||||
// bit32-LABEL: void @f64_as_f128({{.*}}sret([16 x i8])
|
||||
// bit64-LABEL: fp128 @f64_as_f128(
|
||||
#[no_mangle]
|
||||
pub fn f64_as_f128(a: f64) -> f128 {
|
||||
// CHECK: fpext double %{{.+}} to fp128
|
||||
@ -216,7 +244,9 @@ pub fn f128_as_u64(a: f128) -> u64 {
|
||||
a as u64
|
||||
}
|
||||
|
||||
// CHECK-LABEL: i128 @f128_as_u128(
|
||||
// x86-LABEL: void @f128_as_u128({{.*}}sret([16 x i8])
|
||||
// bit32-LABEL: void @f128_as_u128({{.*}}sret([16 x i8])
|
||||
// bit64-LABEL: i128 @f128_as_u128(
|
||||
#[no_mangle]
|
||||
pub fn f128_as_u128(a: f128) -> u128 {
|
||||
// CHECK: call i128 @llvm.fptoui.sat.i128.f128(fp128 %{{.+}})
|
||||
@ -250,7 +280,9 @@ pub fn f128_as_i64(a: f128) -> i64 {
|
||||
a as i64
|
||||
}
|
||||
|
||||
// CHECK-LABEL: i128 @f128_as_i128(
|
||||
// x86-LABEL: void @f128_as_i128({{.*}}sret([16 x i8])
|
||||
// bit32-LABEL: void @f128_as_i128({{.*}}sret([16 x i8])
|
||||
// bit64-LABEL: i128 @f128_as_i128(
|
||||
#[no_mangle]
|
||||
pub fn f128_as_i128(a: f128) -> i128 {
|
||||
// CHECK: call i128 @llvm.fptosi.sat.i128.f128(fp128 %{{.+}})
|
||||
@ -259,70 +291,90 @@ pub fn f128_as_i128(a: f128) -> i128 {
|
||||
|
||||
/* int to float conversions */
|
||||
|
||||
// CHECK-LABEL: fp128 @u8_as_f128(
|
||||
// x86-LABEL: void @u8_as_f128({{.*}}sret([16 x i8])
|
||||
// bit32-LABEL: void @u8_as_f128({{.*}}sret([16 x i8])
|
||||
// bit64-LABEL: fp128 @u8_as_f128(
|
||||
#[no_mangle]
|
||||
pub fn u8_as_f128(a: u8) -> f128 {
|
||||
// CHECK: uitofp i8 %{{.+}} to fp128
|
||||
a as f128
|
||||
}
|
||||
|
||||
// CHECK-LABEL: fp128 @u16_as_f128(
|
||||
// x86-LABEL: void @u16_as_f128({{.*}}sret([16 x i8])
|
||||
// bit32-LABEL: void @u16_as_f128({{.*}}sret([16 x i8])
|
||||
// bit64-LABEL: fp128 @u16_as_f128(
|
||||
#[no_mangle]
|
||||
pub fn u16_as_f128(a: u16) -> f128 {
|
||||
// CHECK: uitofp i16 %{{.+}} to fp128
|
||||
a as f128
|
||||
}
|
||||
|
||||
// CHECK-LABEL: fp128 @u32_as_f128(
|
||||
// x86-LABEL: void @u32_as_f128({{.*}}sret([16 x i8])
|
||||
// bit32-LABEL: void @u32_as_f128({{.*}}sret([16 x i8])
|
||||
// bit64-LABEL: fp128 @u32_as_f128(
|
||||
#[no_mangle]
|
||||
pub fn u32_as_f128(a: u32) -> f128 {
|
||||
// CHECK: uitofp i32 %{{.+}} to fp128
|
||||
a as f128
|
||||
}
|
||||
|
||||
// CHECK-LABEL: fp128 @u64_as_f128(
|
||||
// x86-LABEL: void @u64_as_f128({{.*}}sret([16 x i8])
|
||||
// bit32-LABEL: void @u64_as_f128({{.*}}sret([16 x i8])
|
||||
// bit64-LABEL: fp128 @u64_as_f128(
|
||||
#[no_mangle]
|
||||
pub fn u64_as_f128(a: u64) -> f128 {
|
||||
// CHECK: uitofp i64 %{{.+}} to fp128
|
||||
a as f128
|
||||
}
|
||||
|
||||
// CHECK-LABEL: fp128 @u128_as_f128(
|
||||
// x86-LABEL: void @u128_as_f128({{.*}}sret([16 x i8])
|
||||
// bit32-LABEL: void @u128_as_f128({{.*}}sret([16 x i8])
|
||||
// bit64-LABEL: fp128 @u128_as_f128(
|
||||
#[no_mangle]
|
||||
pub fn u128_as_f128(a: u128) -> f128 {
|
||||
// CHECK: uitofp i128 %{{.+}} to fp128
|
||||
a as f128
|
||||
}
|
||||
|
||||
// CHECK-LABEL: fp128 @i8_as_f128(
|
||||
// x86-LABEL: void @i8_as_f128({{.*}}sret([16 x i8])
|
||||
// bit32-LABEL: void @i8_as_f128({{.*}}sret([16 x i8])
|
||||
// bit64-LABEL: fp128 @i8_as_f128(
|
||||
#[no_mangle]
|
||||
pub fn i8_as_f128(a: i8) -> f128 {
|
||||
// CHECK: sitofp i8 %{{.+}} to fp128
|
||||
a as f128
|
||||
}
|
||||
|
||||
// CHECK-LABEL: fp128 @i16_as_f128(
|
||||
// x86-LABEL: void @i16_as_f128({{.*}}sret([16 x i8])
|
||||
// bit32-LABEL: void @i16_as_f128({{.*}}sret([16 x i8])
|
||||
// bit64-LABEL: fp128 @i16_as_f128(
|
||||
#[no_mangle]
|
||||
pub fn i16_as_f128(a: i16) -> f128 {
|
||||
// CHECK: sitofp i16 %{{.+}} to fp128
|
||||
a as f128
|
||||
}
|
||||
|
||||
// CHECK-LABEL: fp128 @i32_as_f128(
|
||||
// x86-LABEL: void @i32_as_f128({{.*}}sret([16 x i8])
|
||||
// bit32-LABEL: void @i32_as_f128({{.*}}sret([16 x i8])
|
||||
// bit64-LABEL: fp128 @i32_as_f128(
|
||||
#[no_mangle]
|
||||
pub fn i32_as_f128(a: i32) -> f128 {
|
||||
// CHECK: sitofp i32 %{{.+}} to fp128
|
||||
a as f128
|
||||
}
|
||||
|
||||
// CHECK-LABEL: fp128 @i64_as_f128(
|
||||
// x86-LABEL: void @i64_as_f128({{.*}}sret([16 x i8])
|
||||
// bit32-LABEL: void @i64_as_f128({{.*}}sret([16 x i8])
|
||||
// bit64-LABEL: fp128 @i64_as_f128(
|
||||
#[no_mangle]
|
||||
pub fn i64_as_f128(a: i64) -> f128 {
|
||||
// CHECK: sitofp i64 %{{.+}} to fp128
|
||||
a as f128
|
||||
}
|
||||
|
||||
// CHECK-LABEL: fp128 @i128_as_f128(
|
||||
// x86-LABEL: void @i128_as_f128({{.*}}sret([16 x i8])
|
||||
// bit32-LABEL: void @i128_as_f128({{.*}}sret([16 x i8])
|
||||
// bit64-LABEL: fp128 @i128_as_f128(
|
||||
#[no_mangle]
|
||||
pub fn i128_as_f128(a: i128) -> f128 {
|
||||
// CHECK: sitofp i128 %{{.+}} to fp128
|
||||
|
||||
@ -1,7 +1,11 @@
|
||||
// 32-bit x86 returns `f32` and `f64` differently to avoid the x87 stack.
|
||||
//@ revisions: x86 other
|
||||
// 32-bit systems will return 128bit values using a return area pointer.
|
||||
//@ revisions: x86 bit32 bit64
|
||||
//@[x86] only-x86
|
||||
//@[other] ignore-x86
|
||||
//@[bit32] ignore-x86
|
||||
//@[bit32] only-32bit
|
||||
//@[bit64] ignore-x86
|
||||
//@[bit64] only-64bit
|
||||
|
||||
// Verify that our intrinsics generate the correct LLVM calls for f16
|
||||
|
||||
@ -145,23 +149,27 @@ pub fn f16_as_self(a: f16) -> f16 {
|
||||
a as f16
|
||||
}
|
||||
|
||||
// other-LABEL: float @f16_as_f32(
|
||||
// x86-LABEL: i32 @f16_as_f32(
|
||||
// bit32-LABEL: float @f16_as_f32(
|
||||
// bit64-LABEL: float @f16_as_f32(
|
||||
#[no_mangle]
|
||||
pub fn f16_as_f32(a: f16) -> f32 {
|
||||
// CHECK: fpext half %{{.+}} to float
|
||||
a as f32
|
||||
}
|
||||
|
||||
// other-LABEL: double @f16_as_f64(
|
||||
// x86-LABEL: void @f16_as_f64(
|
||||
// bit32-LABEL: double @f16_as_f64(
|
||||
// bit64-LABEL: double @f16_as_f64(
|
||||
#[no_mangle]
|
||||
pub fn f16_as_f64(a: f16) -> f64 {
|
||||
// CHECK: fpext half %{{.+}} to double
|
||||
a as f64
|
||||
}
|
||||
|
||||
// CHECK-LABEL: fp128 @f16_as_f128(
|
||||
// x86-LABEL: void @f16_as_f128({{.*}}sret([16 x i8])
|
||||
// bit32-LABEL: void @f16_as_f128({{.*}}sret([16 x i8])
|
||||
// bit64-LABEL: fp128 @f16_as_f128(
|
||||
#[no_mangle]
|
||||
pub fn f16_as_f128(a: f16) -> f128 {
|
||||
// CHECK: fpext half %{{.+}} to fp128
|
||||
@ -218,7 +226,9 @@ pub fn f16_as_u64(a: f16) -> u64 {
|
||||
a as u64
|
||||
}
|
||||
|
||||
// CHECK-LABEL: i128 @f16_as_u128(
|
||||
// x86-LABEL: void @f16_as_u128({{.*}}sret([16 x i8])
|
||||
// bit32-LABEL: void @f16_as_u128({{.*}}sret([16 x i8])
|
||||
// bit64-LABEL: i128 @f16_as_u128(
|
||||
#[no_mangle]
|
||||
pub fn f16_as_u128(a: f16) -> u128 {
|
||||
// CHECK: call i128 @llvm.fptoui.sat.i128.f16(half %{{.+}})
|
||||
@ -252,7 +262,9 @@ pub fn f16_as_i64(a: f16) -> i64 {
|
||||
a as i64
|
||||
}
|
||||
|
||||
// CHECK-LABEL: i128 @f16_as_i128(
|
||||
// x86-LABEL: void @f16_as_i128({{.*}}sret([16 x i8])
|
||||
// bit32-LABEL: void @f16_as_i128({{.*}}sret([16 x i8])
|
||||
// bit64-LABEL: i128 @f16_as_i128(
|
||||
#[no_mangle]
|
||||
pub fn f16_as_i128(a: f16) -> i128 {
|
||||
// CHECK: call i128 @llvm.fptosi.sat.i128.f16(half %{{.+}})
|
||||
|
||||
@ -1,3 +1,7 @@
|
||||
// 32-bit systems will return 128bit values using a return area pointer.
|
||||
//@ revisions: bit32 bit64
|
||||
//@[bit32] only-32bit
|
||||
//@[bit64] only-64bit
|
||||
//@ compile-flags: -O -C no-prepopulate-passes -Z randomize-layout=no
|
||||
|
||||
#![crate_type = "lib"]
|
||||
@ -98,26 +102,36 @@ pub fn make_struct_1(a: i32) -> Struct1 {
|
||||
|
||||
pub struct Struct2Asc(i16, i64);
|
||||
|
||||
// CHECK-LABEL: { i64, i16 } @make_struct_2_asc(i16 noundef %a, i64 noundef %b)
|
||||
// bit32-LABEL: void @make_struct_2_asc({{.*}} sret([16 x i8]) {{.*}} %s,
|
||||
// bit64-LABEL: { i64, i16 } @make_struct_2_asc(
|
||||
// CHECK-SAME: i16 noundef %a, i64 noundef %b)
|
||||
#[no_mangle]
|
||||
pub fn make_struct_2_asc(a: i16, b: i64) -> Struct2Asc {
|
||||
// CHECK-NOT: alloca
|
||||
// CHECK: %[[TEMP0:.+]] = insertvalue { i64, i16 } poison, i64 %b, 0
|
||||
// CHECK: %[[TEMP1:.+]] = insertvalue { i64, i16 } %[[TEMP0]], i16 %a, 1
|
||||
// CHECK: ret { i64, i16 } %[[TEMP1]]
|
||||
// bit32: %[[GEP:.+]] = getelementptr inbounds i8, ptr %s, i32 8
|
||||
// bit32: store i16 %a, ptr %[[GEP]], align 8
|
||||
// bit32: store i64 %b, ptr %s, align 8
|
||||
// bit64: %[[TEMP0:.+]] = insertvalue { i64, i16 } poison, i64 %b, 0
|
||||
// bit64: %[[TEMP1:.+]] = insertvalue { i64, i16 } %[[TEMP0]], i16 %a, 1
|
||||
// bit64: ret { i64, i16 } %[[TEMP1]]
|
||||
let s = Struct2Asc(a, b);
|
||||
s
|
||||
}
|
||||
|
||||
pub struct Struct2Desc(i64, i16);
|
||||
|
||||
// CHECK-LABEL: { i64, i16 } @make_struct_2_desc(i64 noundef %a, i16 noundef %b)
|
||||
// bit32-LABEL: void @make_struct_2_desc({{.*}} sret([16 x i8]) {{.*}} %s,
|
||||
// bit64-LABEL: { i64, i16 } @make_struct_2_desc(
|
||||
// CHECK-SAME: i64 noundef %a, i16 noundef %b)
|
||||
#[no_mangle]
|
||||
pub fn make_struct_2_desc(a: i64, b: i16) -> Struct2Desc {
|
||||
// CHECK-NOT: alloca
|
||||
// CHECK: %[[TEMP0:.+]] = insertvalue { i64, i16 } poison, i64 %a, 0
|
||||
// CHECK: %[[TEMP1:.+]] = insertvalue { i64, i16 } %[[TEMP0]], i16 %b, 1
|
||||
// CHECK: ret { i64, i16 } %[[TEMP1]]
|
||||
// bit32: store i64 %a, ptr %s, align 8
|
||||
// bit32: %[[GEP:.+]] = getelementptr inbounds i8, ptr %s, i32 8
|
||||
// bit32: store i16 %b, ptr %[[GEP]], align 8
|
||||
// bit64: %[[TEMP0:.+]] = insertvalue { i64, i16 } poison, i64 %a, 0
|
||||
// bit64: %[[TEMP1:.+]] = insertvalue { i64, i16 } %[[TEMP0]], i16 %b, 1
|
||||
// bit64: ret { i64, i16 } %[[TEMP1]]
|
||||
let s = Struct2Desc(a, b);
|
||||
s
|
||||
}
|
||||
|
||||
@ -1,6 +1,10 @@
|
||||
// Checks that range metadata gets emitted on functions result and arguments
|
||||
// with scalar value.
|
||||
|
||||
// 32-bit systems will return 128bit values using a return area pointer.
|
||||
//@ revisions: bit32 bit64
|
||||
//@[bit32] only-32bit
|
||||
//@[bit64] only-64bit
|
||||
//@ compile-flags: -O -C no-prepopulate-passes
|
||||
//@ min-llvm-version: 19
|
||||
|
||||
@ -13,7 +17,8 @@ use std::num::NonZero;
|
||||
#[no_mangle]
|
||||
pub fn helper(_: usize) {}
|
||||
|
||||
// CHECK: noundef range(i128 1, 0) i128 @nonzero_int(i128 noundef range(i128 1, 0) %x)
|
||||
// bit32: void @nonzero_int({{.*}} sret([16 x i8]) {{.*}}, i128 noundef range(i128 1, 0) %x)
|
||||
// bit64: noundef range(i128 1, 0) i128 @nonzero_int(i128 noundef range(i128 1, 0) %x)
|
||||
#[no_mangle]
|
||||
pub fn nonzero_int(x: NonZero<u128>) -> NonZero<u128> {
|
||||
x
|
||||
@ -43,7 +48,9 @@ pub enum Enum1 {
|
||||
C(u64),
|
||||
}
|
||||
|
||||
// CHECK: { [[ENUM1_TYP:i[0-9]+]], i64 } @enum1_value([[ENUM1_TYP]] noundef range([[ENUM1_TYP]] 0, 3) %x.0, i64 noundef %x.1)
|
||||
// bit32: void @enum1_value({{.*}} sret([16 x i8]) {{[^,]*}}, [[ENUM1_TYP:i[0-9]+]]
|
||||
// bit64: { [[ENUM1_TYP:i[0-9]+]], i64 } @enum1_value([[ENUM1_TYP]]
|
||||
// CHECK-SAME: noundef range([[ENUM1_TYP]] 0, 3) %x.0, i64 noundef %x.1)
|
||||
#[no_mangle]
|
||||
pub fn enum1_value(x: Enum1) -> Enum1 {
|
||||
x
|
||||
|
||||
@ -1,3 +1,7 @@
|
||||
// 32-bit systems will return 128bit values using a return area pointer.
|
||||
//@ revisions: bit32 bit64
|
||||
//@[bit32] only-32bit
|
||||
//@[bit64] only-64bit
|
||||
//@ compile-flags: -C no-prepopulate-passes -Copt-level=0
|
||||
|
||||
// Test that tuples get optimized layout, in particular with a ZST in the last field (#63244)
|
||||
@ -5,42 +9,52 @@
|
||||
#![crate_type = "lib"]
|
||||
|
||||
type ScalarZstLast = (u128, ());
|
||||
// CHECK: define {{(dso_local )?}}i128 @test_ScalarZstLast(i128 %_1)
|
||||
// bit32: define {{(dso_local )?}}void @test_ScalarZstLast({{.*}} sret([16 x i8]) {{.*}}, i128 %_1)
|
||||
// bit64: define {{(dso_local )?}}i128 @test_ScalarZstLast(i128 %_1)
|
||||
#[no_mangle]
|
||||
pub fn test_ScalarZstLast(_: ScalarZstLast) -> ScalarZstLast {
|
||||
loop {}
|
||||
}
|
||||
|
||||
type ScalarZstFirst = ((), u128);
|
||||
// CHECK: define {{(dso_local )?}}i128 @test_ScalarZstFirst(i128 %_1)
|
||||
// bit32: define {{(dso_local )?}}void @test_ScalarZstFirst({{.*}} sret([16 x i8]) {{.*}}, i128 %_1)
|
||||
// bit64: define {{(dso_local )?}}i128 @test_ScalarZstFirst(i128 %_1)
|
||||
#[no_mangle]
|
||||
pub fn test_ScalarZstFirst(_: ScalarZstFirst) -> ScalarZstFirst {
|
||||
loop {}
|
||||
}
|
||||
|
||||
type ScalarPairZstLast = (u8, u128, ());
|
||||
// CHECK: define {{(dso_local )?}}void @test_ScalarPairZstLast(ptr sret([32 x i8]) align 16 %_0, i128 %_1.0, i8 %_1.1)
|
||||
// bit32: define {{(dso_local )?}}void @test_ScalarPairZstLast(ptr sret([24 x i8]) align 8
|
||||
// bit64: define {{(dso_local )?}}void @test_ScalarPairZstLast(ptr sret([32 x i8]) align 16
|
||||
// CHECK-SAME: %_0, i128 %_1.0, i8 %_1.1)
|
||||
#[no_mangle]
|
||||
pub fn test_ScalarPairZstLast(_: ScalarPairZstLast) -> ScalarPairZstLast {
|
||||
loop {}
|
||||
}
|
||||
|
||||
type ScalarPairZstFirst = ((), u8, u128);
|
||||
// CHECK: define {{(dso_local )?}}void @test_ScalarPairZstFirst(ptr sret([32 x i8]) align 16 %_0, i8 %_1.0, i128 %_1.1)
|
||||
// bit32: define {{(dso_local )?}}void @test_ScalarPairZstFirst(ptr sret([24 x i8]) align 8
|
||||
// bit64: define {{(dso_local )?}}void @test_ScalarPairZstFirst(ptr sret([32 x i8]) align 16
|
||||
// CHECK-SAME: %_0, i8 %_1.0, i128 %_1.1)
|
||||
#[no_mangle]
|
||||
pub fn test_ScalarPairZstFirst(_: ScalarPairZstFirst) -> ScalarPairZstFirst {
|
||||
loop {}
|
||||
}
|
||||
|
||||
type ScalarPairLotsOfZsts = ((), u8, (), u128, ());
|
||||
// CHECK: define {{(dso_local )?}}void @test_ScalarPairLotsOfZsts(ptr sret([32 x i8]) align 16 %_0, i128 %_1.0, i8 %_1.1)
|
||||
// bit32: define {{(dso_local )?}}void @test_ScalarPairLotsOfZsts(ptr sret([24 x i8]) align 8
|
||||
// bit64: define {{(dso_local )?}}void @test_ScalarPairLotsOfZsts(ptr sret([32 x i8]) align 16
|
||||
// CHECK-SAME: %_0, i128 %_1.0, i8 %_1.1)
|
||||
#[no_mangle]
|
||||
pub fn test_ScalarPairLotsOfZsts(_: ScalarPairLotsOfZsts) -> ScalarPairLotsOfZsts {
|
||||
loop {}
|
||||
}
|
||||
|
||||
type ScalarPairLottaNesting = (((), ((), u8, (), u128, ())), ());
|
||||
// CHECK: define {{(dso_local )?}}void @test_ScalarPairLottaNesting(ptr sret([32 x i8]) align 16 %_0, i128 %_1.0, i8 %_1.1)
|
||||
// bit32: define {{(dso_local )?}}void @test_ScalarPairLottaNesting(ptr sret([24 x i8]) align 8
|
||||
// bit64: define {{(dso_local )?}}void @test_ScalarPairLottaNesting(ptr sret([32 x i8]) align 16
|
||||
// CHECK-SAME: %_0, i128 %_1.0, i8 %_1.1)
|
||||
#[no_mangle]
|
||||
pub fn test_ScalarPairLottaNesting(_: ScalarPairLottaNesting) -> ScalarPairLottaNesting {
|
||||
loop {}
|
||||
|
||||
@ -1,9 +1,13 @@
|
||||
//@ ignore-emscripten vectors passed directly
|
||||
//@ compile-flags: -O -C no-prepopulate-passes
|
||||
// 32-bit x86 returns `f32` differently to avoid the x87 stack.
|
||||
//@ revisions: x86 other
|
||||
// 32-bit systems will return 128bit values using a return area pointer.
|
||||
//@ revisions: x86 bit32 bit64
|
||||
//@[x86] only-x86
|
||||
//@[other] ignore-x86
|
||||
//@[bit32] ignore-x86
|
||||
//@[bit32] only-32bit
|
||||
//@[bit64] ignore-x86
|
||||
//@[bit64] only-64bit
|
||||
|
||||
// This test that using union forward the abi of the inner type, as
|
||||
// discussed in #54668
|
||||
@ -71,8 +75,9 @@ pub union UnionF32 {
|
||||
a: f32,
|
||||
}
|
||||
|
||||
// other: define {{(dso_local )?}}float @test_UnionF32(float %_1)
|
||||
// x86: define {{(dso_local )?}}i32 @test_UnionF32(float %_1)
|
||||
// bit32: define {{(dso_local )?}}float @test_UnionF32(float %_1)
|
||||
// bit64: define {{(dso_local )?}}float @test_UnionF32(float %_1)
|
||||
#[no_mangle]
|
||||
pub fn test_UnionF32(_: UnionF32) -> UnionF32 {
|
||||
loop {}
|
||||
@ -83,8 +88,9 @@ pub union UnionF32F32 {
|
||||
b: f32,
|
||||
}
|
||||
|
||||
// other: define {{(dso_local )?}}float @test_UnionF32F32(float %_1)
|
||||
// x86: define {{(dso_local )?}}i32 @test_UnionF32F32(float %_1)
|
||||
// bit32: define {{(dso_local )?}}float @test_UnionF32F32(float %_1)
|
||||
// bit64: define {{(dso_local )?}}float @test_UnionF32F32(float %_1)
|
||||
#[no_mangle]
|
||||
pub fn test_UnionF32F32(_: UnionF32F32) -> UnionF32F32 {
|
||||
loop {}
|
||||
@ -104,7 +110,9 @@ pub fn test_UnionF32U32(_: UnionF32U32) -> UnionF32U32 {
|
||||
pub union UnionU128 {
|
||||
a: u128,
|
||||
}
|
||||
// CHECK: define {{(dso_local )?}}i128 @test_UnionU128(i128 %_1)
|
||||
// x86: define {{(dso_local )?}}void @test_UnionU128({{.*}}sret([16 x i8]){{.*}}, i128 %_1)
|
||||
// bit32: define {{(dso_local )?}}void @test_UnionU128({{.*}}sret([16 x i8]){{.*}}, i128 %_1)
|
||||
// bit64: define {{(dso_local )?}}i128 @test_UnionU128(i128 %_1)
|
||||
#[no_mangle]
|
||||
pub fn test_UnionU128(_: UnionU128) -> UnionU128 {
|
||||
loop {}
|
||||
|
||||
Loading…
Reference in New Issue
Block a user