Skip to content

Commit f8e97ba

Browse files
ruancomelliruancomelli
committed
Add const support for float rounding methods
Add const support for the float rounding methods floor, ceil, trunc, fract, round and round_ties_even. This works by moving the calculation logic from src/tools/miri/src/intrinsics/mod.rs into compiler/rustc_const_eval/src/interpret/intrinsics.rs. All relevant method definitions were adjusted to include the `const` keyword for all supported float types: f16, f32, f64 and f128. The constness is hidden behind the feature gate feature(const_float_round_methods) which is tracked in #141555 This commit is a squash of the following commits: - test: add tests that we expect to pass when float rounding becomes const - feat: make float rounding methods `const` - fix: replace `rustc_allow_const_fn_unstable(core_intrinsics)` attribute with `#[rustc_const_unstable(feature = "f128", issue = "116909")]` in `library/core/src/num/f128.rs` - revert: undo update to `library/stdarch` - refactor: replace multiple `float_<mode>_intrinsic` rounding methods with a single, parametrized one - fix: add `#[cfg(not(bootstrap))]` to new const method tests - test: add extra sign tests to check `+0.0` and `-0.0` - revert: undo accidental changes to `round` docs - fix: gate `const` float round method behind `const_float_round_methods` - fix: remove unnecessary `#![feature(const_float_methods)]` - fix: remove unnecessary `#![feature(const_float_methods)]` [2] - revert: undo changes to `tests/ui/consts/const-eval/float_methods.rs` - fix: adjust after rebase - test: fix float tests - test: add tests for `fract` - chore: add commented-out `const_float_round_methods` feature gates to `f16` and `f128` - fix: adjust NaN when rounding floats - chore: add FIXME comment for de-duplicating float tests - test: remove unnecessary test file `tests/ui/consts/const-eval/float_methods.rs` - test: fix tests after upstream simplification of how float tests are run
1 parent 852f15c commit f8e97ba

File tree

12 files changed

+333
-117
lines changed

12 files changed

+333
-117
lines changed

‎compiler/rustc_const_eval/src/interpret/intrinsics.rs‎

Lines changed: 113 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -518,6 +518,103 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
518518
sym::fabsf64 => self.float_abs_intrinsic::<Double>(args, dest)?,
519519
sym::fabsf128 => self.float_abs_intrinsic::<Quad>(args, dest)?,
520520

521+
sym::floorf16 => self.float_round_intrinsic::<Half>(
522+
args,
523+
dest,
524+
rustc_apfloat::Round::TowardNegative,
525+
)?,
526+
sym::floorf32 => self.float_round_intrinsic::<Single>(
527+
args,
528+
dest,
529+
rustc_apfloat::Round::TowardNegative,
530+
)?,
531+
sym::floorf64 => self.float_round_intrinsic::<Double>(
532+
args,
533+
dest,
534+
rustc_apfloat::Round::TowardNegative,
535+
)?,
536+
sym::floorf128 => self.float_round_intrinsic::<Quad>(
537+
args,
538+
dest,
539+
rustc_apfloat::Round::TowardNegative,
540+
)?,
541+
542+
sym::ceilf16 => self.float_round_intrinsic::<Half>(
543+
args,
544+
dest,
545+
rustc_apfloat::Round::TowardPositive,
546+
)?,
547+
sym::ceilf32 => self.float_round_intrinsic::<Single>(
548+
args,
549+
dest,
550+
rustc_apfloat::Round::TowardPositive,
551+
)?,
552+
sym::ceilf64 => self.float_round_intrinsic::<Double>(
553+
args,
554+
dest,
555+
rustc_apfloat::Round::TowardPositive,
556+
)?,
557+
sym::ceilf128 => self.float_round_intrinsic::<Quad>(
558+
args,
559+
dest,
560+
rustc_apfloat::Round::TowardPositive,
561+
)?,
562+
563+
sym::truncf16 => {
564+
self.float_round_intrinsic::<Half>(args, dest, rustc_apfloat::Round::TowardZero)?
565+
}
566+
sym::truncf32 => {
567+
self.float_round_intrinsic::<Single>(args, dest, rustc_apfloat::Round::TowardZero)?
568+
}
569+
sym::truncf64 => {
570+
self.float_round_intrinsic::<Double>(args, dest, rustc_apfloat::Round::TowardZero)?
571+
}
572+
sym::truncf128 => {
573+
self.float_round_intrinsic::<Quad>(args, dest, rustc_apfloat::Round::TowardZero)?
574+
}
575+
576+
sym::roundf16 => self.float_round_intrinsic::<Half>(
577+
args,
578+
dest,
579+
rustc_apfloat::Round::NearestTiesToAway,
580+
)?,
581+
sym::roundf32 => self.float_round_intrinsic::<Single>(
582+
args,
583+
dest,
584+
rustc_apfloat::Round::NearestTiesToAway,
585+
)?,
586+
sym::roundf64 => self.float_round_intrinsic::<Double>(
587+
args,
588+
dest,
589+
rustc_apfloat::Round::NearestTiesToAway,
590+
)?,
591+
sym::roundf128 => self.float_round_intrinsic::<Quad>(
592+
args,
593+
dest,
594+
rustc_apfloat::Round::NearestTiesToAway,
595+
)?,
596+
597+
sym::round_ties_even_f16 => self.float_round_intrinsic::<Half>(
598+
args,
599+
dest,
600+
rustc_apfloat::Round::NearestTiesToEven,
601+
)?,
602+
sym::round_ties_even_f32 => self.float_round_intrinsic::<Single>(
603+
args,
604+
dest,
605+
rustc_apfloat::Round::NearestTiesToEven,
606+
)?,
607+
sym::round_ties_even_f64 => self.float_round_intrinsic::<Double>(
608+
args,
609+
dest,
610+
rustc_apfloat::Round::NearestTiesToEven,
611+
)?,
612+
sym::round_ties_even_f128 => self.float_round_intrinsic::<Quad>(
613+
args,
614+
dest,
615+
rustc_apfloat::Round::NearestTiesToEven,
616+
)?,
617+
521618
// Unsupported intrinsic: skip the return_to_block below.
522619
_ => return interp_ok(false),
523620
}
@@ -900,4 +997,20 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
900997
self.write_scalar(x.abs(), dest)?;
901998
interp_ok(())
902999
}
1000+
1001+
fn float_round_intrinsic<F>(
1002+
&mut self,
1003+
args: &[OpTy<'tcx, M::Provenance>],
1004+
dest: &PlaceTy<'tcx, M::Provenance>,
1005+
mode: rustc_apfloat::Round,
1006+
) -> InterpResult<'tcx, ()>
1007+
where
1008+
F: rustc_apfloat::Float + rustc_apfloat::FloatConvert<F> + Into<Scalar<M::Provenance>>,
1009+
{
1010+
let x: F = self.read_scalar(&args[0])?.to_float()?;
1011+
let res = x.round_to_integral(mode).value;
1012+
let res = self.adjust_nan(res, &[x]);
1013+
self.write_scalar(res, dest)?;
1014+
interp_ok(())
1015+
}
9031016
}

‎library/core/src/intrinsics/mod.rs‎

Lines changed: 20 additions & 20 deletions
Original file line numberDiff line numberDiff line change
@@ -2212,86 +2212,86 @@ pub unsafe fn fmuladdf128(a: f128, b: f128, c: f128) -> f128;
22122212
/// [`f16::floor`](../../std/primitive.f16.html#method.floor)
22132213
#[rustc_intrinsic]
22142214
#[rustc_nounwind]
2215-
pub unsafe fn floorf16(x: f16) -> f16;
2215+
pub const unsafe fn floorf16(x: f16) -> f16;
22162216
/// Returns the largest integer less than or equal to an `f32`.
22172217
///
22182218
/// The stabilized version of this intrinsic is
22192219
/// [`f32::floor`](../../std/primitive.f32.html#method.floor)
22202220
#[rustc_intrinsic]
22212221
#[rustc_nounwind]
2222-
pub unsafe fn floorf32(x: f32) -> f32;
2222+
pub const unsafe fn floorf32(x: f32) -> f32;
22232223
/// Returns the largest integer less than or equal to an `f64`.
22242224
///
22252225
/// The stabilized version of this intrinsic is
22262226
/// [`f64::floor`](../../std/primitive.f64.html#method.floor)
22272227
#[rustc_intrinsic]
22282228
#[rustc_nounwind]
2229-
pub unsafe fn floorf64(x: f64) -> f64;
2229+
pub const unsafe fn floorf64(x: f64) -> f64;
22302230
/// Returns the largest integer less than or equal to an `f128`.
22312231
///
22322232
/// The stabilized version of this intrinsic is
22332233
/// [`f128::floor`](../../std/primitive.f128.html#method.floor)
22342234
#[rustc_intrinsic]
22352235
#[rustc_nounwind]
2236-
pub unsafe fn floorf128(x: f128) -> f128;
2236+
pub const unsafe fn floorf128(x: f128) -> f128;
22372237

22382238
/// Returns the smallest integer greater than or equal to an `f16`.
22392239
///
22402240
/// The stabilized version of this intrinsic is
22412241
/// [`f16::ceil`](../../std/primitive.f16.html#method.ceil)
22422242
#[rustc_intrinsic]
22432243
#[rustc_nounwind]
2244-
pub unsafe fn ceilf16(x: f16) -> f16;
2244+
pub const unsafe fn ceilf16(x: f16) -> f16;
22452245
/// Returns the smallest integer greater than or equal to an `f32`.
22462246
///
22472247
/// The stabilized version of this intrinsic is
22482248
/// [`f32::ceil`](../../std/primitive.f32.html#method.ceil)
22492249
#[rustc_intrinsic]
22502250
#[rustc_nounwind]
2251-
pub unsafe fn ceilf32(x: f32) -> f32;
2251+
pub const unsafe fn ceilf32(x: f32) -> f32;
22522252
/// Returns the smallest integer greater than or equal to an `f64`.
22532253
///
22542254
/// The stabilized version of this intrinsic is
22552255
/// [`f64::ceil`](../../std/primitive.f64.html#method.ceil)
22562256
#[rustc_intrinsic]
22572257
#[rustc_nounwind]
2258-
pub unsafe fn ceilf64(x: f64) -> f64;
2258+
pub const unsafe fn ceilf64(x: f64) -> f64;
22592259
/// Returns the smallest integer greater than or equal to an `f128`.
22602260
///
22612261
/// The stabilized version of this intrinsic is
22622262
/// [`f128::ceil`](../../std/primitive.f128.html#method.ceil)
22632263
#[rustc_intrinsic]
22642264
#[rustc_nounwind]
2265-
pub unsafe fn ceilf128(x: f128) -> f128;
2265+
pub const unsafe fn ceilf128(x: f128) -> f128;
22662266

22672267
/// Returns the integer part of an `f16`.
22682268
///
22692269
/// The stabilized version of this intrinsic is
22702270
/// [`f16::trunc`](../../std/primitive.f16.html#method.trunc)
22712271
#[rustc_intrinsic]
22722272
#[rustc_nounwind]
2273-
pub unsafe fn truncf16(x: f16) -> f16;
2273+
pub const unsafe fn truncf16(x: f16) -> f16;
22742274
/// Returns the integer part of an `f32`.
22752275
///
22762276
/// The stabilized version of this intrinsic is
22772277
/// [`f32::trunc`](../../std/primitive.f32.html#method.trunc)
22782278
#[rustc_intrinsic]
22792279
#[rustc_nounwind]
2280-
pub unsafe fn truncf32(x: f32) -> f32;
2280+
pub const unsafe fn truncf32(x: f32) -> f32;
22812281
/// Returns the integer part of an `f64`.
22822282
///
22832283
/// The stabilized version of this intrinsic is
22842284
/// [`f64::trunc`](../../std/primitive.f64.html#method.trunc)
22852285
#[rustc_intrinsic]
22862286
#[rustc_nounwind]
2287-
pub unsafe fn truncf64(x: f64) -> f64;
2287+
pub const unsafe fn truncf64(x: f64) -> f64;
22882288
/// Returns the integer part of an `f128`.
22892289
///
22902290
/// The stabilized version of this intrinsic is
22912291
/// [`f128::trunc`](../../std/primitive.f128.html#method.trunc)
22922292
#[rustc_intrinsic]
22932293
#[rustc_nounwind]
2294-
pub unsafe fn truncf128(x: f128) -> f128;
2294+
pub const unsafe fn truncf128(x: f128) -> f128;
22952295

22962296
/// Returns the nearest integer to an `f16`. Rounds half-way cases to the number with an even
22972297
/// least significant digit.
@@ -2300,7 +2300,7 @@ pub unsafe fn truncf128(x: f128) -> f128;
23002300
/// [`f16::round_ties_even`](../../std/primitive.f16.html#method.round_ties_even)
23012301
#[rustc_intrinsic]
23022302
#[rustc_nounwind]
2303-
pub fn round_ties_even_f16(x: f16) -> f16;
2303+
pub const fn round_ties_even_f16(x: f16) -> f16;
23042304

23052305
/// Returns the nearest integer to an `f32`. Rounds half-way cases to the number with an even
23062306
/// least significant digit.
@@ -2309,7 +2309,7 @@ pub fn round_ties_even_f16(x: f16) -> f16;
23092309
/// [`f32::round_ties_even`](../../std/primitive.f32.html#method.round_ties_even)
23102310
#[rustc_intrinsic]
23112311
#[rustc_nounwind]
2312-
pub fn round_ties_even_f32(x: f32) -> f32;
2312+
pub const fn round_ties_even_f32(x: f32) -> f32;
23132313

23142314
/// Returns the nearest integer to an `f64`. Rounds half-way cases to the number with an even
23152315
/// least significant digit.
@@ -2318,7 +2318,7 @@ pub fn round_ties_even_f32(x: f32) -> f32;
23182318
/// [`f64::round_ties_even`](../../std/primitive.f64.html#method.round_ties_even)
23192319
#[rustc_intrinsic]
23202320
#[rustc_nounwind]
2321-
pub fn round_ties_even_f64(x: f64) -> f64;
2321+
pub const fn round_ties_even_f64(x: f64) -> f64;
23222322

23232323
/// Returns the nearest integer to an `f128`. Rounds half-way cases to the number with an even
23242324
/// least significant digit.
@@ -2327,36 +2327,36 @@ pub fn round_ties_even_f64(x: f64) -> f64;
23272327
/// [`f128::round_ties_even`](../../std/primitive.f128.html#method.round_ties_even)
23282328
#[rustc_intrinsic]
23292329
#[rustc_nounwind]
2330-
pub fn round_ties_even_f128(x: f128) -> f128;
2330+
pub const fn round_ties_even_f128(x: f128) -> f128;
23312331

23322332
/// Returns the nearest integer to an `f16`. Rounds half-way cases away from zero.
23332333
///
23342334
/// The stabilized version of this intrinsic is
23352335
/// [`f16::round`](../../std/primitive.f16.html#method.round)
23362336
#[rustc_intrinsic]
23372337
#[rustc_nounwind]
2338-
pub unsafe fn roundf16(x: f16) -> f16;
2338+
pub const unsafe fn roundf16(x: f16) -> f16;
23392339
/// Returns the nearest integer to an `f32`. Rounds half-way cases away from zero.
23402340
///
23412341
/// The stabilized version of this intrinsic is
23422342
/// [`f32::round`](../../std/primitive.f32.html#method.round)
23432343
#[rustc_intrinsic]
23442344
#[rustc_nounwind]
2345-
pub unsafe fn roundf32(x: f32) -> f32;
2345+
pub const unsafe fn roundf32(x: f32) -> f32;
23462346
/// Returns the nearest integer to an `f64`. Rounds half-way cases away from zero.
23472347
///
23482348
/// The stabilized version of this intrinsic is
23492349
/// [`f64::round`](../../std/primitive.f64.html#method.round)
23502350
#[rustc_intrinsic]
23512351
#[rustc_nounwind]
2352-
pub unsafe fn roundf64(x: f64) -> f64;
2352+
pub const unsafe fn roundf64(x: f64) -> f64;
23532353
/// Returns the nearest integer to an `f128`. Rounds half-way cases away from zero.
23542354
///
23552355
/// The stabilized version of this intrinsic is
23562356
/// [`f128::round`](../../std/primitive.f128.html#method.round)
23572357
#[rustc_intrinsic]
23582358
#[rustc_nounwind]
2359-
pub unsafe fn roundf128(x: f128) -> f128;
2359+
pub const unsafe fn roundf128(x: f128) -> f128;
23602360

23612361
/// Float addition that allows optimizations based on algebraic rules.
23622362
/// May assume inputs are finite.

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

Lines changed: 18 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -1447,8 +1447,10 @@ impl f128 {
14471447
#[inline]
14481448
#[rustc_allow_incoherent_impl]
14491449
#[unstable(feature = "f128", issue = "116909")]
1450+
#[rustc_const_unstable(feature = "f128", issue = "116909")]
1451+
// #[rustc_const_unstable(feature = "const_float_round_methods", issue = "141555")]
14501452
#[must_use = "method returns a new number and does not mutate the original value"]
1451-
pub fn floor(self) -> f128 {
1453+
pub const fn floor(self) -> f128 {
14521454
// SAFETY: intrinsic with no preconditions
14531455
unsafe { intrinsics::floorf128(self) }
14541456
}
@@ -1477,8 +1479,10 @@ impl f128 {
14771479
#[doc(alias = "ceiling")]
14781480
#[rustc_allow_incoherent_impl]
14791481
#[unstable(feature = "f128", issue = "116909")]
1482+
#[rustc_const_unstable(feature = "f128", issue = "116909")]
1483+
// #[rustc_const_unstable(feature = "const_float_round_methods", issue = "141555")]
14801484
#[must_use = "method returns a new number and does not mutate the original value"]
1481-
pub fn ceil(self) -> f128 {
1485+
pub const fn ceil(self) -> f128 {
14821486
// SAFETY: intrinsic with no preconditions
14831487
unsafe { intrinsics::ceilf128(self) }
14841488
}
@@ -1513,8 +1517,10 @@ impl f128 {
15131517
#[inline]
15141518
#[rustc_allow_incoherent_impl]
15151519
#[unstable(feature = "f128", issue = "116909")]
1520+
#[rustc_const_unstable(feature = "f128", issue = "116909")]
1521+
// #[rustc_const_unstable(feature = "const_float_round_methods", issue = "141555")]
15161522
#[must_use = "method returns a new number and does not mutate the original value"]
1517-
pub fn round(self) -> f128 {
1523+
pub const fn round(self) -> f128 {
15181524
// SAFETY: intrinsic with no preconditions
15191525
unsafe { intrinsics::roundf128(self) }
15201526
}
@@ -1547,8 +1553,10 @@ impl f128 {
15471553
#[inline]
15481554
#[rustc_allow_incoherent_impl]
15491555
#[unstable(feature = "f128", issue = "116909")]
1556+
#[rustc_const_unstable(feature = "f128", issue = "116909")]
1557+
// #[rustc_const_unstable(feature = "const_float_round_methods", issue = "141555")]
15501558
#[must_use = "method returns a new number and does not mutate the original value"]
1551-
pub fn round_ties_even(self) -> f128 {
1559+
pub const fn round_ties_even(self) -> f128 {
15521560
intrinsics::round_ties_even_f128(self)
15531561
}
15541562

@@ -1579,8 +1587,10 @@ impl f128 {
15791587
#[doc(alias = "truncate")]
15801588
#[rustc_allow_incoherent_impl]
15811589
#[unstable(feature = "f128", issue = "116909")]
1590+
#[rustc_const_unstable(feature = "f128", issue = "116909")]
1591+
// #[rustc_const_unstable(feature = "const_float_round_methods", issue = "141555")]
15821592
#[must_use = "method returns a new number and does not mutate the original value"]
1583-
pub fn trunc(self) -> f128 {
1593+
pub const fn trunc(self) -> f128 {
15841594
// SAFETY: intrinsic with no preconditions
15851595
unsafe { intrinsics::truncf128(self) }
15861596
}
@@ -1610,8 +1620,10 @@ impl f128 {
16101620
#[inline]
16111621
#[rustc_allow_incoherent_impl]
16121622
#[unstable(feature = "f128", issue = "116909")]
1623+
#[rustc_const_unstable(feature = "f128", issue = "116909")]
1624+
// #[rustc_const_unstable(feature = "const_float_round_methods", issue = "141555")]
16131625
#[must_use = "method returns a new number and does not mutate the original value"]
1614-
pub fn fract(self) -> f128 {
1626+
pub const fn fract(self) -> f128 {
16151627
self - self.trunc()
16161628
}
16171629

0 commit comments

Comments
 (0)