Skip to content
This commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.

Commit 4ef0a5f

Browse files
tgross35tgross35
committedMar 14, 2024·
Add basic library support for f16 and f128
Implement basic operation traits that get lowered to intrinsics. This does not yet create a new module for these types. Additionally, add codegn tests for the implemented operations.
1 parent 5ac0b2d commit 4ef0a5f

File tree

10 files changed

+338
-0
lines changed

10 files changed

+338
-0
lines changed
 

‎library/core/src/clone.rs

+3
Original file line numberDiff line numberDiff line change
@@ -231,6 +231,9 @@ mod impls {
231231
bool char
232232
}
233233

234+
#[cfg(not(bootstrap))]
235+
impl_clone! { f16 f128 }
236+
234237
#[unstable(feature = "never_type", issue = "35121")]
235238
impl Clone for ! {
236239
#[inline]

‎library/core/src/cmp.rs

+6
Original file line numberDiff line numberDiff line change
@@ -1489,6 +1489,9 @@ mod impls {
14891489
bool char usize u8 u16 u32 u64 u128 isize i8 i16 i32 i64 i128 f32 f64
14901490
}
14911491

1492+
#[cfg(not(bootstrap))]
1493+
partial_eq_impl! { f16 f128 }
1494+
14921495
macro_rules! eq_impl {
14931496
($($t:ty)*) => ($(
14941497
#[stable(feature = "rust1", since = "1.0.0")]
@@ -1541,6 +1544,9 @@ mod impls {
15411544

15421545
partial_ord_impl! { f32 f64 }
15431546

1547+
#[cfg(not(bootstrap))]
1548+
partial_ord_impl! { f16 f128 }
1549+
15441550
macro_rules! ord_impl {
15451551
($($t:ty)*) => ($(
15461552
#[stable(feature = "rust1", since = "1.0.0")]

‎library/core/src/convert/num.rs

+17
Original file line numberDiff line numberDiff line change
@@ -38,6 +38,11 @@ macro_rules! impl_float_to_int {
3838
impl_float_to_int!(f32 => u8, u16, u32, u64, u128, usize, i8, i16, i32, i64, i128, isize);
3939
impl_float_to_int!(f64 => u8, u16, u32, u64, u128, usize, i8, i16, i32, i64, i128, isize);
4040

41+
#[cfg(not(bootstrap))]
42+
impl_float_to_int!(f16 => u8, u16, u32, u64, u128, usize, i8, i16, i32, i64, i128, isize);
43+
#[cfg(not(bootstrap))]
44+
impl_float_to_int!(f128 => u8, u16, u32, u64, u128, usize, i8, i16, i32, i64, i128, isize);
45+
4146
// Conversion traits for primitive integer and float types
4247
// Conversions T -> T are covered by a blanket impl and therefore excluded
4348
// Some conversions from and to usize/isize are not implemented due to portability concerns
@@ -166,6 +171,18 @@ impl_from!(u32 => f64, #[stable(feature = "lossless_float_conv", since = "1.6.0"
166171
// float -> float
167172
impl_from!(f32 => f64, #[stable(feature = "lossless_float_conv", since = "1.6.0")]);
168173

174+
// todo: these are insta-stable regardless of the gate, right?
175+
#[cfg(not(bootstrap))]
176+
impl_from! { f16 => f32, #[stable(feature = "lossless_float_conv", since = "1.6.0")] }
177+
#[cfg(not(bootstrap))]
178+
impl_from! { f16 => f64, #[stable(feature = "lossless_float_conv", since = "1.6.0")] }
179+
#[cfg(not(bootstrap))]
180+
impl_from! { f16 => f128, #[stable(feature = "lossless_float_conv", since = "1.6.0")] }
181+
#[cfg(not(bootstrap))]
182+
impl_from! { f32 => f128, #[stable(feature = "lossless_float_conv", since = "1.6.0")] }
183+
#[cfg(not(bootstrap))]
184+
impl_from! { f64 => f128, #[stable(feature = "lossless_float_conv", since = "1.6.0")] }
185+
169186
macro_rules! impl_float_from_bool {
170187
($float:ty) => {
171188
#[stable(feature = "float_from_bool", since = "1.68.0")]

‎library/core/src/default.rs

+5
Original file line numberDiff line numberDiff line change
@@ -178,3 +178,8 @@ default_impl! { i128, 0, "Returns the default value of `0`" }
178178

179179
default_impl! { f32, 0.0f32, "Returns the default value of `0.0`" }
180180
default_impl! { f64, 0.0f64, "Returns the default value of `0.0`" }
181+
182+
#[cfg(not(bootstrap))]
183+
default_impl! { f16, 0.0f16, "Returns the default value of `0.0`" }
184+
#[cfg(not(bootstrap))]
185+
default_impl! { f128, 0.0f128, "Returns the default value of `0.0`" }

‎library/core/src/fmt/nofloat.rs

+5
Original file line numberDiff line numberDiff line change
@@ -13,3 +13,8 @@ macro_rules! floating {
1313

1414
floating! { f32 }
1515
floating! { f64 }
16+
17+
#[cfg(not(bootstrap))]
18+
floating! { f16 }
19+
#[cfg(not(bootstrap))]
20+
floating! { f128 }

‎library/core/src/lib.rs

+2
Original file line numberDiff line numberDiff line change
@@ -205,6 +205,8 @@
205205
#![cfg_attr(bootstrap, feature(diagnostic_namespace))]
206206
#![cfg_attr(bootstrap, feature(exhaustive_patterns))]
207207
#![cfg_attr(bootstrap, feature(platform_intrinsics))]
208+
#![cfg_attr(not(bootstrap), feature(f128))]
209+
#![cfg_attr(not(bootstrap), feature(f16))]
208210
#![cfg_attr(not(bootstrap), feature(freeze_impls))]
209211
#![cfg_attr(not(bootstrap), feature(min_exhaustive_patterns))]
210212
#![feature(abi_unadjusted)]

‎library/core/src/marker.rs

+7
Original file line numberDiff line numberDiff line change
@@ -429,6 +429,13 @@ marker_impls! {
429429

430430
}
431431

432+
// todo: which feature gate should we use?
433+
#[cfg(not(bootstrap))]
434+
marker_impls! {
435+
#[stable(feature = "rust1", since = "1.0.0")]
436+
Copy for f16, f128
437+
}
438+
432439
#[unstable(feature = "never_type", issue = "35121")]
433440
impl Copy for ! {}
434441

‎library/core/src/ops/arith.rs

+33
Original file line numberDiff line numberDiff line change
@@ -111,6 +111,9 @@ macro_rules! add_impl {
111111

112112
add_impl! { usize u8 u16 u32 u64 u128 isize i8 i16 i32 i64 i128 f32 f64 }
113113

114+
#[cfg(not(bootstrap))]
115+
add_impl! { f16 f128 }
116+
114117
/// The subtraction operator `-`.
115118
///
116119
/// Note that `Rhs` is `Self` by default, but this is not mandatory. For
@@ -220,6 +223,9 @@ macro_rules! sub_impl {
220223

221224
sub_impl! { usize u8 u16 u32 u64 u128 isize i8 i16 i32 i64 i128 f32 f64 }
222225

226+
#[cfg(not(bootstrap))]
227+
sub_impl! { f16 f128 }
228+
223229
/// The multiplication operator `*`.
224230
///
225231
/// Note that `Rhs` is `Self` by default, but this is not mandatory.
@@ -350,6 +356,9 @@ macro_rules! mul_impl {
350356

351357
mul_impl! { usize u8 u16 u32 u64 u128 isize i8 i16 i32 i64 i128 f32 f64 }
352358

359+
#[cfg(not(bootstrap))]
360+
mul_impl! { f16 f128 }
361+
353362
/// The division operator `/`.
354363
///
355364
/// Note that `Rhs` is `Self` by default, but this is not mandatory.
@@ -508,6 +517,9 @@ macro_rules! div_impl_float {
508517

509518
div_impl_float! { f32 f64 }
510519

520+
#[cfg(not(bootstrap))]
521+
div_impl_float! { f16 f128 }
522+
511523
/// The remainder operator `%`.
512524
///
513525
/// Note that `Rhs` is `Self` by default, but this is not mandatory.
@@ -625,6 +637,9 @@ macro_rules! rem_impl_float {
625637

626638
rem_impl_float! { f32 f64 }
627639

640+
#[cfg(not(bootstrap))]
641+
rem_impl_float! { f16 f128 }
642+
628643
/// The unary negation operator `-`.
629644
///
630645
/// # Examples
@@ -700,6 +715,9 @@ macro_rules! neg_impl {
700715

701716
neg_impl! { isize i8 i16 i32 i64 i128 f32 f64 }
702717

718+
#[cfg(not(bootstrap))]
719+
neg_impl! { f16 f128 }
720+
703721
/// The addition assignment operator `+=`.
704722
///
705723
/// # Examples
@@ -767,6 +785,9 @@ macro_rules! add_assign_impl {
767785

768786
add_assign_impl! { usize u8 u16 u32 u64 u128 isize i8 i16 i32 i64 i128 f32 f64 }
769787

788+
#[cfg(not(bootstrap))]
789+
add_assign_impl! { f16 f128 }
790+
770791
/// The subtraction assignment operator `-=`.
771792
///
772793
/// # Examples
@@ -834,6 +855,9 @@ macro_rules! sub_assign_impl {
834855

835856
sub_assign_impl! { usize u8 u16 u32 u64 u128 isize i8 i16 i32 i64 i128 f32 f64 }
836857

858+
#[cfg(not(bootstrap))]
859+
sub_assign_impl! { f16 f128 }
860+
837861
/// The multiplication assignment operator `*=`.
838862
///
839863
/// # Examples
@@ -892,6 +916,9 @@ macro_rules! mul_assign_impl {
892916

893917
mul_assign_impl! { usize u8 u16 u32 u64 u128 isize i8 i16 i32 i64 i128 f32 f64 }
894918

919+
#[cfg(not(bootstrap))]
920+
mul_assign_impl! { f16 f128 }
921+
895922
/// The division assignment operator `/=`.
896923
///
897924
/// # Examples
@@ -949,6 +976,9 @@ macro_rules! div_assign_impl {
949976

950977
div_assign_impl! { usize u8 u16 u32 u64 u128 isize i8 i16 i32 i64 i128 f32 f64 }
951978

979+
#[cfg(not(bootstrap))]
980+
div_assign_impl! { f16 f128 }
981+
952982
/// The remainder assignment operator `%=`.
953983
///
954984
/// # Examples
@@ -1009,3 +1039,6 @@ macro_rules! rem_assign_impl {
10091039
}
10101040

10111041
rem_assign_impl! { usize u8 u16 u32 u64 u128 isize i8 i16 i32 i64 i128 f32 f64 }
1042+
1043+
#[cfg(not(bootstrap))]
1044+
rem_assign_impl! { f16 f128 }

‎tests/codegen/float/f128.rs

+129
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,129 @@
1+
// Verify that our intrinsics generate the correct LLVM calls for f128
2+
3+
#![crate_type = "lib"]
4+
#![feature(f128)]
5+
#![feature(core_intrinsics)]
6+
7+
// CHECK-LABEL: i1 @f128_eq(
8+
#[no_mangle]
9+
pub fn f128_eq(a: f128, b: f128) -> bool {
10+
// CHECK: fcmp oeq fp128 %{{.+}}, %{{.+}}
11+
a == b
12+
}
13+
14+
// CHECK-LABEL: i1 @f128_ne(
15+
#[no_mangle]
16+
pub fn f128_ne(a: f128, b: f128) -> bool {
17+
// CHECK: fcmp une fp128 %{{.+}}, %{{.+}}
18+
a != b
19+
}
20+
21+
// CHECK-LABEL: i1 @f128_gt(
22+
#[no_mangle]
23+
pub fn f128_gt(a: f128, b: f128) -> bool {
24+
// CHECK: fcmp ogt fp128 %{{.+}}, %{{.+}}
25+
a > b
26+
}
27+
28+
// CHECK-LABEL: i1 @f128_ge(
29+
#[no_mangle]
30+
pub fn f128_ge(a: f128, b: f128) -> bool {
31+
// CHECK: fcmp oge fp128 %{{.+}}, %{{.+}}
32+
a >= b
33+
}
34+
35+
// CHECK-LABEL: i1 @f128_lt(
36+
#[no_mangle]
37+
pub fn f128_lt(a: f128, b: f128) -> bool {
38+
// CHECK: fcmp olt fp128 %{{.+}}, %{{.+}}
39+
a < b
40+
}
41+
42+
// CHECK-LABEL: i1 @f128_le(
43+
#[no_mangle]
44+
pub fn f128_le(a: f128, b: f128) -> bool {
45+
// CHECK: fcmp ole fp128 %{{.+}}, %{{.+}}
46+
a <= b
47+
}
48+
49+
// CHECK-LABEL: fp128 @f128_neg(
50+
#[no_mangle]
51+
pub fn f128_neg(a: f128) -> f128 {
52+
// CHECK: fneg fp128
53+
-a
54+
}
55+
56+
// CHECK-LABEL: fp128 @f128_add(
57+
#[no_mangle]
58+
pub fn f128_add(a: f128, b: f128) -> f128 {
59+
// CHECK: fadd fp128 %{{.+}}, %{{.+}}
60+
a + b
61+
}
62+
63+
// CHECK-LABEL: fp128 @f128_sub(
64+
#[no_mangle]
65+
pub fn f128_sub(a: f128, b: f128) -> f128 {
66+
// CHECK: fsub fp128 %{{.+}}, %{{.+}}
67+
a - b
68+
}
69+
70+
// CHECK-LABEL: fp128 @f128_mul(
71+
#[no_mangle]
72+
pub fn f128_mul(a: f128, b: f128) -> f128 {
73+
// CHECK: fmul fp128 %{{.+}}, %{{.+}}
74+
a * b
75+
}
76+
77+
// CHECK-LABEL: fp128 @f128_div(
78+
#[no_mangle]
79+
pub fn f128_div(a: f128, b: f128) -> f128 {
80+
// CHECK: fdiv fp128 %{{.+}}, %{{.+}}
81+
a / b
82+
}
83+
84+
// CHECK-LABEL: fp128 @f128_rem(
85+
#[no_mangle]
86+
pub fn f128_rem(a: f128, b: f128) -> f128 {
87+
// CHECK: frem fp128 %{{.+}}, %{{.+}}
88+
a % b
89+
}
90+
91+
// CHECK-LABEL: void @f128_add_assign(
92+
#[no_mangle]
93+
pub fn f128_add_assign(a: &mut f128, b: f128) {
94+
// CHECK: fadd fp128 %{{.+}}, %{{.+}}
95+
// CHECK-NEXT: store fp128 %{{.+}}, ptr %{{.+}}
96+
*a += b;
97+
}
98+
99+
// CHECK-LABEL: void @f128_sub_assign(
100+
#[no_mangle]
101+
pub fn f128_sub_assign(a: &mut f128, b: f128) {
102+
// CHECK: fsub fp128 %{{.+}}, %{{.+}}
103+
// CHECK-NEXT: store fp128 %{{.+}}, ptr %{{.+}}
104+
*a -= b;
105+
}
106+
107+
// CHECK-LABEL: void @f128_mul_assign(
108+
#[no_mangle]
109+
pub fn f128_mul_assign(a: &mut f128, b: f128) {
110+
// CHECK: fmul fp128 %{{.+}}, %{{.+}}
111+
// CHECK-NEXT: store fp128 %{{.+}}, ptr %{{.+}}
112+
*a *= b
113+
}
114+
115+
// CHECK-LABEL: void @f128_div_assign(
116+
#[no_mangle]
117+
pub fn f128_div_assign(a: &mut f128, b: f128) {
118+
// CHECK: fdiv fp128 %{{.+}}, %{{.+}}
119+
// CHECK-NEXT: store fp128 %{{.+}}, ptr %{{.+}}
120+
*a /= b
121+
}
122+
123+
// CHECK-LABEL: void @f128_rem_assign(
124+
#[no_mangle]
125+
pub fn f128_rem_assign(a: &mut f128, b: f128) {
126+
// CHECK: frem fp128 %{{.+}}, %{{.+}}
127+
// CHECK-NEXT: store fp128 %{{.+}}, ptr %{{.+}}
128+
*a %= b
129+
}

0 commit comments

Comments
 (0)
Please sign in to comment.