mirror of
https://github.com/rust-lang/rust.git
synced 2025-10-31 13:04:42 +00:00
488ddd3bbc
These types are currently rejected for `as` casts by the compiler. Remove this incorrect check and add codegen tests for all conversions involving these types.
324 lines
6.9 KiB
Rust
324 lines
6.9 KiB
Rust
// Verify that our intrinsics generate the correct LLVM calls for f128
|
|
|
|
#![crate_type = "lib"]
|
|
#![feature(f128)]
|
|
#![feature(f16)]
|
|
#![feature(core_intrinsics)]
|
|
|
|
// CHECK-LABEL: i1 @f128_eq(
|
|
#[no_mangle]
|
|
pub fn f128_eq(a: f128, b: f128) -> bool {
|
|
// CHECK: fcmp oeq fp128 %{{.+}}, %{{.+}}
|
|
a == b
|
|
}
|
|
|
|
// CHECK-LABEL: i1 @f128_ne(
|
|
#[no_mangle]
|
|
pub fn f128_ne(a: f128, b: f128) -> bool {
|
|
// CHECK: fcmp une fp128 %{{.+}}, %{{.+}}
|
|
a != b
|
|
}
|
|
|
|
// CHECK-LABEL: i1 @f128_gt(
|
|
#[no_mangle]
|
|
pub fn f128_gt(a: f128, b: f128) -> bool {
|
|
// CHECK: fcmp ogt fp128 %{{.+}}, %{{.+}}
|
|
a > b
|
|
}
|
|
|
|
// CHECK-LABEL: i1 @f128_ge(
|
|
#[no_mangle]
|
|
pub fn f128_ge(a: f128, b: f128) -> bool {
|
|
// CHECK: fcmp oge fp128 %{{.+}}, %{{.+}}
|
|
a >= b
|
|
}
|
|
|
|
// CHECK-LABEL: i1 @f128_lt(
|
|
#[no_mangle]
|
|
pub fn f128_lt(a: f128, b: f128) -> bool {
|
|
// CHECK: fcmp olt fp128 %{{.+}}, %{{.+}}
|
|
a < b
|
|
}
|
|
|
|
// CHECK-LABEL: i1 @f128_le(
|
|
#[no_mangle]
|
|
pub fn f128_le(a: f128, b: f128) -> bool {
|
|
// CHECK: fcmp ole fp128 %{{.+}}, %{{.+}}
|
|
a <= b
|
|
}
|
|
|
|
// CHECK-LABEL: fp128 @f128_neg(
|
|
#[no_mangle]
|
|
pub fn f128_neg(a: f128) -> f128 {
|
|
// CHECK: fneg fp128
|
|
-a
|
|
}
|
|
|
|
// CHECK-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(
|
|
#[no_mangle]
|
|
pub fn f128_sub(a: f128, b: f128) -> f128 {
|
|
// CHECK: fsub fp128 %{{.+}}, %{{.+}}
|
|
a - b
|
|
}
|
|
|
|
// CHECK-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(
|
|
#[no_mangle]
|
|
pub fn f128_div(a: f128, b: f128) -> f128 {
|
|
// CHECK: fdiv fp128 %{{.+}}, %{{.+}}
|
|
a / b
|
|
}
|
|
|
|
// CHECK-LABEL: fp128 @f128_rem(
|
|
#[no_mangle]
|
|
pub fn f128_rem(a: f128, b: f128) -> f128 {
|
|
// CHECK: frem fp128 %{{.+}}, %{{.+}}
|
|
a % b
|
|
}
|
|
|
|
// CHECK-LABEL: void @f128_add_assign(
|
|
#[no_mangle]
|
|
pub fn f128_add_assign(a: &mut f128, b: f128) {
|
|
// CHECK: fadd fp128 %{{.+}}, %{{.+}}
|
|
// CHECK-NEXT: store fp128 %{{.+}}, ptr %{{.+}}
|
|
*a += b;
|
|
}
|
|
|
|
// CHECK-LABEL: void @f128_sub_assign(
|
|
#[no_mangle]
|
|
pub fn f128_sub_assign(a: &mut f128, b: f128) {
|
|
// CHECK: fsub fp128 %{{.+}}, %{{.+}}
|
|
// CHECK-NEXT: store fp128 %{{.+}}, ptr %{{.+}}
|
|
*a -= b;
|
|
}
|
|
|
|
// CHECK-LABEL: void @f128_mul_assign(
|
|
#[no_mangle]
|
|
pub fn f128_mul_assign(a: &mut f128, b: f128) {
|
|
// CHECK: fmul fp128 %{{.+}}, %{{.+}}
|
|
// CHECK-NEXT: store fp128 %{{.+}}, ptr %{{.+}}
|
|
*a *= b
|
|
}
|
|
|
|
// CHECK-LABEL: void @f128_div_assign(
|
|
#[no_mangle]
|
|
pub fn f128_div_assign(a: &mut f128, b: f128) {
|
|
// CHECK: fdiv fp128 %{{.+}}, %{{.+}}
|
|
// CHECK-NEXT: store fp128 %{{.+}}, ptr %{{.+}}
|
|
*a /= b
|
|
}
|
|
|
|
// CHECK-LABEL: void @f128_rem_assign(
|
|
#[no_mangle]
|
|
pub fn f128_rem_assign(a: &mut f128, b: f128) {
|
|
// CHECK: frem fp128 %{{.+}}, %{{.+}}
|
|
// CHECK-NEXT: store fp128 %{{.+}}, ptr %{{.+}}
|
|
*a %= b
|
|
}
|
|
|
|
/* float to float conversions */
|
|
|
|
// CHECK-LABEL: half @f128_as_f16(
|
|
#[no_mangle]
|
|
pub fn f128_as_f16(a: f128) -> f16 {
|
|
// CHECK: fptrunc fp128 %{{.+}} to half
|
|
a as f16
|
|
}
|
|
|
|
// CHECK-LABEL: float @f128_as_f32(
|
|
#[no_mangle]
|
|
pub fn f128_as_f32(a: f128) -> f32 {
|
|
// CHECK: fptrunc fp128 %{{.+}} to float
|
|
a as f32
|
|
}
|
|
|
|
// CHECK-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(
|
|
#[no_mangle]
|
|
pub fn f128_as_self(a: f128) -> f128 {
|
|
// CHECK: ret fp128 %{{.+}}
|
|
a as f128
|
|
}
|
|
|
|
// CHECK-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(
|
|
#[no_mangle]
|
|
pub fn f32_as_f128(a: f32) -> f128 {
|
|
// CHECK: fpext float %{{.+}} to fp128
|
|
a as f128
|
|
}
|
|
|
|
// CHECK-LABEL: fp128 @f64_as_f128(
|
|
#[no_mangle]
|
|
pub fn f64_as_f128(a: f64) -> f128 {
|
|
// CHECK: fpext double %{{.+}} to fp128
|
|
a as f128
|
|
}
|
|
|
|
/* float to int conversions */
|
|
|
|
// CHECK-LABEL: i8 @f128_as_u8(
|
|
#[no_mangle]
|
|
pub fn f128_as_u8(a: f128) -> u8 {
|
|
// CHECK: call i8 @llvm.fptoui.sat.i8.f128(fp128 %{{.+}})
|
|
a as u8
|
|
}
|
|
|
|
#[no_mangle]
|
|
pub fn f128_as_u16(a: f128) -> u16 {
|
|
// CHECK: call i16 @llvm.fptoui.sat.i16.f128(fp128 %{{.+}})
|
|
a as u16
|
|
}
|
|
|
|
// CHECK-LABEL: i32 @f128_as_u32(
|
|
#[no_mangle]
|
|
pub fn f128_as_u32(a: f128) -> u32 {
|
|
// CHECK: call i32 @llvm.fptoui.sat.i32.f128(fp128 %{{.+}})
|
|
a as u32
|
|
}
|
|
|
|
// CHECK-LABEL: i64 @f128_as_u64(
|
|
#[no_mangle]
|
|
pub fn f128_as_u64(a: f128) -> u64 {
|
|
// CHECK: call i64 @llvm.fptoui.sat.i64.f128(fp128 %{{.+}})
|
|
a as u64
|
|
}
|
|
|
|
// CHECK-LABEL: i128 @f128_as_u128(
|
|
#[no_mangle]
|
|
pub fn f128_as_u128(a: f128) -> u128 {
|
|
// CHECK: call i128 @llvm.fptoui.sat.i128.f128(fp128 %{{.+}})
|
|
a as u128
|
|
}
|
|
|
|
// CHECK-LABEL: i8 @f128_as_i8(
|
|
#[no_mangle]
|
|
pub fn f128_as_i8(a: f128) -> i8 {
|
|
// CHECK: call i8 @llvm.fptosi.sat.i8.f128(fp128 %{{.+}})
|
|
a as i8
|
|
}
|
|
|
|
// CHECK-LABEL: i16 @f128_as_i16(
|
|
#[no_mangle]
|
|
pub fn f128_as_i16(a: f128) -> i16 {
|
|
// CHECK: call i16 @llvm.fptosi.sat.i16.f128(fp128 %{{.+}})
|
|
a as i16
|
|
}
|
|
// CHECK-LABEL: i32 @f128_as_i32(
|
|
#[no_mangle]
|
|
pub fn f128_as_i32(a: f128) -> i32 {
|
|
// CHECK: call i32 @llvm.fptosi.sat.i32.f128(fp128 %{{.+}})
|
|
a as i32
|
|
}
|
|
|
|
// CHECK-LABEL: i64 @f128_as_i64(
|
|
#[no_mangle]
|
|
pub fn f128_as_i64(a: f128) -> i64 {
|
|
// CHECK: call i64 @llvm.fptosi.sat.i64.f128(fp128 %{{.+}})
|
|
a as i64
|
|
}
|
|
|
|
// CHECK-LABEL: i128 @f128_as_i128(
|
|
#[no_mangle]
|
|
pub fn f128_as_i128(a: f128) -> i128 {
|
|
// CHECK: call i128 @llvm.fptosi.sat.i128.f128(fp128 %{{.+}})
|
|
a as i128
|
|
}
|
|
|
|
/* int to float conversions */
|
|
|
|
// CHECK-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(
|
|
#[no_mangle]
|
|
pub fn u16_as_f128(a: u16) -> f128 {
|
|
// CHECK: uitofp i16 %{{.+}} to fp128
|
|
a as f128
|
|
}
|
|
|
|
// CHECK-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(
|
|
#[no_mangle]
|
|
pub fn u64_as_f128(a: u64) -> f128 {
|
|
// CHECK: uitofp i64 %{{.+}} to fp128
|
|
a as f128
|
|
}
|
|
|
|
// CHECK-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(
|
|
#[no_mangle]
|
|
pub fn i8_as_f128(a: i8) -> f128 {
|
|
// CHECK: sitofp i8 %{{.+}} to fp128
|
|
a as f128
|
|
}
|
|
|
|
// CHECK-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(
|
|
#[no_mangle]
|
|
pub fn i32_as_f128(a: i32) -> f128 {
|
|
// CHECK: sitofp i32 %{{.+}} to fp128
|
|
a as f128
|
|
}
|
|
|
|
// CHECK-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(
|
|
#[no_mangle]
|
|
pub fn i128_as_f128(a: i128) -> f128 {
|
|
// CHECK: sitofp i128 %{{.+}} to fp128
|
|
a as f128
|
|
}
|