Skip to content

Commit a538fe7

Browse files
borsbors
committed
Auto merge of #46931 - clarcharr:float_bits_core, r=alexcrichton
Expose float from_bits and to_bits in libcore. These methods have no dependencies on libm and thus should be offered in libcore.
2 parents fdecb05 + 556fb02 commit a538fe7

File tree

6 files changed

+73
-56
lines changed

6 files changed

+73
-56
lines changed

‎src/libcore/num/dec2flt/rawfp.rs

+24-36
Original file line numberDiff line numberDiff line change
@@ -27,11 +27,10 @@
2727
//! Many functions in this module only handle normal numbers. The dec2flt routines conservatively
2828
//! take the universally-correct slow path (Algorithm M) for very small and very large numbers.
2929
//! That algorithm needs only next_float() which does handle subnormals and zeros.
30-
use u32;
3130
use cmp::Ordering::{Less, Equal, Greater};
32-
use ops::{Mul, Div, Neg};
31+
use convert::{TryFrom, TryInto};
32+
use ops::{Add, Mul, Div, Neg};
3333
use fmt::{Debug, LowerExp};
34-
use mem::transmute;
3534
use num::diy_float::Fp;
3635
use num::FpCategory::{Infinite, Zero, Subnormal, Normal, Nan};
3736
use num::Float;
@@ -56,22 +55,27 @@ impl Unpacked {
5655
///
5756
/// Should **never ever** be implemented for other types or be used outside the dec2flt module.
5857
/// Inherits from `Float` because there is some overlap, but all the reused methods are trivial.
59-
pub trait RawFloat : Float + Copy + Debug + LowerExp
60-
+ Mul<Output=Self> + Div<Output=Self> + Neg<Output=Self>
58+
pub trait RawFloat
59+
: Float
60+
+ Copy
61+
+ Debug
62+
+ LowerExp
63+
+ Mul<Output=Self>
64+
+ Div<Output=Self>
65+
+ Neg<Output=Self>
66+
where
67+
Self: Float<Bits = <Self as RawFloat>::RawBits>
6168
{
6269
const INFINITY: Self;
6370
const NAN: Self;
6471
const ZERO: Self;
6572

73+
/// Same as `Float::Bits` with extra traits.
74+
type RawBits: Add<Output = Self::RawBits> + From<u8> + TryFrom<u64>;
75+
6676
/// Returns the mantissa, exponent and sign as integers.
6777
fn integer_decode(self) -> (u64, i16, i8);
6878

69-
/// Get the raw binary representation of the float.
70-
fn transmute(self) -> u64;
71-
72-
/// Transmute the raw binary representation into a float.
73-
fn from_bits(bits: u64) -> Self;
74-
7579
/// Decode the float.
7680
fn unpack(self) -> Unpacked;
7781

@@ -149,6 +153,8 @@ macro_rules! other_constants {
149153
}
150154

151155
impl RawFloat for f32 {
156+
type RawBits = u32;
157+
152158
const SIG_BITS: u8 = 24;
153159
const EXP_BITS: u8 = 8;
154160
const CEIL_LOG5_OF_MAX_SIG: i16 = 11;
@@ -159,7 +165,7 @@ impl RawFloat for f32 {
159165

160166
/// Returns the mantissa, exponent and sign as integers.
161167
fn integer_decode(self) -> (u64, i16, i8) {
162-
let bits: u32 = unsafe { transmute(self) };
168+
let bits = self.to_bits();
163169
let sign: i8 = if bits >> 31 == 0 { 1 } else { -1 };
164170
let mut exponent: i16 = ((bits >> 23) & 0xff) as i16;
165171
let mantissa = if exponent == 0 {
@@ -172,16 +178,6 @@ impl RawFloat for f32 {
172178
(mantissa as u64, exponent, sign)
173179
}
174180

175-
fn transmute(self) -> u64 {
176-
let bits: u32 = unsafe { transmute(self) };
177-
bits as u64
178-
}
179-
180-
fn from_bits(bits: u64) -> f32 {
181-
assert!(bits < u32::MAX as u64, "f32::from_bits: too many bits");
182-
unsafe { transmute(bits as u32) }
183-
}
184-
185181
fn unpack(self) -> Unpacked {
186182
let (sig, exp, _sig) = self.integer_decode();
187183
Unpacked::new(sig, exp)
@@ -200,6 +196,8 @@ impl RawFloat for f32 {
200196

201197

202198
impl RawFloat for f64 {
199+
type RawBits = u64;
200+
203201
const SIG_BITS: u8 = 53;
204202
const EXP_BITS: u8 = 11;
205203
const CEIL_LOG5_OF_MAX_SIG: i16 = 23;
@@ -210,7 +208,7 @@ impl RawFloat for f64 {
210208

211209
/// Returns the mantissa, exponent and sign as integers.
212210
fn integer_decode(self) -> (u64, i16, i8) {
213-
let bits: u64 = unsafe { transmute(self) };
211+
let bits = self.to_bits();
214212
let sign: i8 = if bits >> 63 == 0 { 1 } else { -1 };
215213
let mut exponent: i16 = ((bits >> 52) & 0x7ff) as i16;
216214
let mantissa = if exponent == 0 {
@@ -223,15 +221,6 @@ impl RawFloat for f64 {
223221
(mantissa, exponent, sign)
224222
}
225223

226-
fn transmute(self) -> u64 {
227-
let bits: u64 = unsafe { transmute(self) };
228-
bits
229-
}
230-
231-
fn from_bits(bits: u64) -> f64 {
232-
unsafe { transmute(bits) }
233-
}
234-
235224
fn unpack(self) -> Unpacked {
236225
let (sig, exp, _sig) = self.integer_decode();
237226
Unpacked::new(sig, exp)
@@ -296,14 +285,14 @@ pub fn encode_normal<T: RawFloat>(x: Unpacked) -> T {
296285
"encode_normal: exponent out of range");
297286
// Leave sign bit at 0 ("+"), our numbers are all positive
298287
let bits = (k_enc as u64) << T::EXPLICIT_SIG_BITS | sig_enc;
299-
T::from_bits(bits)
288+
T::from_bits(bits.try_into().unwrap_or_else(|_| unreachable!()))
300289
}
301290

302291
/// Construct a subnormal. A mantissa of 0 is allowed and constructs zero.
303292
pub fn encode_subnormal<T: RawFloat>(significand: u64) -> T {
304293
assert!(significand < T::MIN_SIG, "encode_subnormal: not actually subnormal");
305294
// Encoded exponent is 0, the sign bit is 0, so we just have to reinterpret the bits.
306-
T::from_bits(significand)
295+
T::from_bits(significand.try_into().unwrap_or_else(|_| unreachable!()))
307296
}
308297

309298
/// Approximate a bignum with an Fp. Rounds within 0.5 ULP with half-to-even.
@@ -363,8 +352,7 @@ pub fn next_float<T: RawFloat>(x: T) -> T {
363352
// too is exactly what we want!
364353
// Finally, f64::MAX + 1 = 7eff...f + 1 = 7ff0...0 = f64::INFINITY.
365354
Zero | Subnormal | Normal => {
366-
let bits: u64 = x.transmute();
367-
T::from_bits(bits + 1)
355+
T::from_bits(x.to_bits() + T::Bits::from(1u8))
368356
}
369357
}
370358
}

‎src/libcore/num/f32.rs

+17-7
Original file line numberDiff line numberDiff line change
@@ -145,6 +145,8 @@ pub mod consts {
145145
reason = "stable interface is via `impl f{32,64}` in later crates",
146146
issue = "32110")]
147147
impl Float for f32 {
148+
type Bits = u32;
149+
148150
/// Returns `true` if the number is NaN.
149151
#[inline]
150152
fn is_nan(self) -> bool {
@@ -176,7 +178,7 @@ impl Float for f32 {
176178
const EXP_MASK: u32 = 0x7f800000;
177179
const MAN_MASK: u32 = 0x007fffff;
178180

179-
let bits: u32 = unsafe { mem::transmute(self) };
181+
let bits = self.to_bits();
180182
match (bits & MAN_MASK, bits & EXP_MASK) {
181183
(0, 0) => Fp::Zero,
182184
(_, 0) => Fp::Subnormal,
@@ -220,12 +222,7 @@ impl Float for f32 {
220222
fn is_sign_negative(self) -> bool {
221223
// IEEE754 says: isSignMinus(x) is true if and only if x has negative sign. isSignMinus
222224
// applies to zeros and NaNs as well.
223-
#[repr(C)]
224-
union F32Bytes {
225-
f: f32,
226-
b: u32
227-
}
228-
unsafe { F32Bytes { f: self }.b & 0x8000_0000 != 0 }
225+
self.to_bits() & 0x8000_0000 != 0
229226
}
230227

231228
/// Returns the reciprocal (multiplicative inverse) of the number.
@@ -279,4 +276,17 @@ impl Float for f32 {
279276
// multiplying by 1.0. Should switch to the `canonicalize` when it works.
280277
(if other.is_nan() || self < other { self } else { other }) * 1.0
281278
}
279+
280+
/// Raw transmutation to `u32`.
281+
#[inline]
282+
fn to_bits(self) -> u32 {
283+
unsafe { mem::transmute(self) }
284+
}
285+
286+
/// Raw transmutation from `u32`.
287+
#[inline]
288+
fn from_bits(v: u32) -> Self {
289+
// It turns out the safety issues with sNaN were overblown! Hooray!
290+
unsafe { mem::transmute(v) }
291+
}
282292
}

‎src/libcore/num/f64.rs

+17-7
Original file line numberDiff line numberDiff line change
@@ -145,6 +145,8 @@ pub mod consts {
145145
reason = "stable interface is via `impl f{32,64}` in later crates",
146146
issue = "32110")]
147147
impl Float for f64 {
148+
type Bits = u64;
149+
148150
/// Returns `true` if the number is NaN.
149151
#[inline]
150152
fn is_nan(self) -> bool {
@@ -176,7 +178,7 @@ impl Float for f64 {
176178
const EXP_MASK: u64 = 0x7ff0000000000000;
177179
const MAN_MASK: u64 = 0x000fffffffffffff;
178180

179-
let bits: u64 = unsafe { mem::transmute(self) };
181+
let bits = self.to_bits();
180182
match (bits & MAN_MASK, bits & EXP_MASK) {
181183
(0, 0) => Fp::Zero,
182184
(_, 0) => Fp::Subnormal,
@@ -218,12 +220,7 @@ impl Float for f64 {
218220
/// negative sign bit and negative infinity.
219221
#[inline]
220222
fn is_sign_negative(self) -> bool {
221-
#[repr(C)]
222-
union F64Bytes {
223-
f: f64,
224-
b: u64
225-
}
226-
unsafe { F64Bytes { f: self }.b & 0x8000_0000_0000_0000 != 0 }
223+
self.to_bits() & 0x8000_0000_0000_0000 != 0
227224
}
228225

229226
/// Returns the reciprocal (multiplicative inverse) of the number.
@@ -277,4 +274,17 @@ impl Float for f64 {
277274
// multiplying by 1.0. Should switch to the `canonicalize` when it works.
278275
(if other.is_nan() || self < other { self } else { other }) * 1.0
279276
}
277+
278+
/// Raw transmutation to `u64`.
279+
#[inline]
280+
fn to_bits(self) -> u64 {
281+
unsafe { mem::transmute(self) }
282+
}
283+
284+
/// Raw transmutation from `u64`.
285+
#[inline]
286+
fn from_bits(v: u64) -> Self {
287+
// It turns out the safety issues with sNaN were overblown! Hooray!
288+
unsafe { mem::transmute(v) }
289+
}
280290
}

‎src/libcore/num/mod.rs

+11
Original file line numberDiff line numberDiff line change
@@ -2880,6 +2880,10 @@ pub enum FpCategory {
28802880
reason = "stable interface is via `impl f{32,64}` in later crates",
28812881
issue = "32110")]
28822882
pub trait Float: Sized {
2883+
/// Type used by `to_bits` and `from_bits`.
2884+
#[stable(feature = "core_float_bits", since = "1.24.0")]
2885+
type Bits;
2886+
28832887
/// Returns `true` if this value is NaN and false otherwise.
28842888
#[stable(feature = "core", since = "1.6.0")]
28852889
fn is_nan(self) -> bool;
@@ -2941,6 +2945,13 @@ pub trait Float: Sized {
29412945
/// Returns the minimum of the two numbers.
29422946
#[stable(feature = "core_float_min_max", since="1.20.0")]
29432947
fn min(self, other: Self) -> Self;
2948+
2949+
/// Raw transmutation to integer.
2950+
#[stable(feature = "core_float_bits", since="1.24.0")]
2951+
fn to_bits(self) -> Self::Bits;
2952+
/// Raw transmutation from integer.
2953+
#[stable(feature = "core_float_bits", since="1.24.0")]
2954+
fn from_bits(v: Self::Bits) -> Self;
29442955
}
29452956

29462957
macro_rules! from_str_radix_int_impl {

‎src/libstd/f32.rs

+2-3
Original file line numberDiff line numberDiff line change
@@ -1015,7 +1015,7 @@ impl f32 {
10151015
#[stable(feature = "float_bits_conv", since = "1.20.0")]
10161016
#[inline]
10171017
pub fn to_bits(self) -> u32 {
1018-
unsafe { ::mem::transmute(self) }
1018+
num::Float::to_bits(self)
10191019
}
10201020

10211021
/// Raw transmutation from `u32`.
@@ -1059,8 +1059,7 @@ impl f32 {
10591059
#[stable(feature = "float_bits_conv", since = "1.20.0")]
10601060
#[inline]
10611061
pub fn from_bits(v: u32) -> Self {
1062-
// It turns out the safety issues with sNaN were overblown! Hooray!
1063-
unsafe { ::mem::transmute(v) }
1062+
num::Float::from_bits(v)
10641063
}
10651064
}
10661065

‎src/libstd/f64.rs

+2-3
Original file line numberDiff line numberDiff line change
@@ -970,7 +970,7 @@ impl f64 {
970970
#[stable(feature = "float_bits_conv", since = "1.20.0")]
971971
#[inline]
972972
pub fn to_bits(self) -> u64 {
973-
unsafe { ::mem::transmute(self) }
973+
num::Float::to_bits(self)
974974
}
975975

976976
/// Raw transmutation from `u64`.
@@ -1014,8 +1014,7 @@ impl f64 {
10141014
#[stable(feature = "float_bits_conv", since = "1.20.0")]
10151015
#[inline]
10161016
pub fn from_bits(v: u64) -> Self {
1017-
// It turns out the safety issues with sNaN were overblown! Hooray!
1018-
unsafe { ::mem::transmute(v) }
1017+
num::Float::from_bits(v)
10191018
}
10201019
}
10211020

0 commit comments

Comments
 (0)