mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Update tests for 32bit targets

Browse Source
This commit is contained in:
bjorn3 2024-10-12 16:17:34 +00:00
parent ccd1bc2ad1
commit 8ed77fd29e
6 changed files with 162 additions and 55 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

106
tests/codegen/float/f128.rs
View File

@ -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

26
tests/codegen/float/f16.rs
View File

@ -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 %{{.+}})

30
tests/codegen/mir-aggregate-no-alloca.rs
View File

@ -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
}

11
tests/codegen/range-attribute.rs
View File

@ -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 @@
#[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

26
tests/codegen/tuple-layout-opt.rs
View File

@ -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 {}

18
tests/codegen/union-abi.rs
View File

@ -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 {}