| /// Conversions from integers to floats. |
| /// |
| /// These are hand-optimized bit twiddling code, |
| /// which unfortunately isn't the easiest kind of code to read. |
| /// |
| /// The algorithm is explained here: <https://blog.m-ou.se/floats/> |
| mod int_to_float { |
| pub fn u32_to_f32_bits(i: u32) -> u32 { |
| if i == 0 { |
| return 0; |
| } |
| let n = i.leading_zeros(); |
| let a = (i << n) >> 8; // Significant bits, with bit 24 still in tact. |
| let b = (i << n) << 24; // Insignificant bits, only relevant for rounding. |
| let m = a + ((b - (b >> 31 & !a)) >> 31); // Add one when we need to round up. Break ties to even. |
| let e = 157 - n; // Exponent plus 127, minus one. |
| (e << 23) + m // + not |, so the mantissa can overflow into the exponent. |
| } |
| |
| pub fn u32_to_f64_bits(i: u32) -> u64 { |
| if i == 0 { |
| return 0; |
| } |
| let n = i.leading_zeros(); |
| let m = (i as u64) << (21 + n); // Significant bits, with bit 53 still in tact. |
| let e = 1053 - n as u64; // Exponent plus 1023, minus one. |
| (e << 52) + m // Bit 53 of m will overflow into e. |
| } |
| |
| pub fn u64_to_f32_bits(i: u64) -> u32 { |
| let n = i.leading_zeros(); |
| let y = i.wrapping_shl(n); |
| let a = (y >> 40) as u32; // Significant bits, with bit 24 still in tact. |
| let b = (y >> 8 | y & 0xFFFF) as u32; // Insignificant bits, only relevant for rounding. |
| let m = a + ((b - (b >> 31 & !a)) >> 31); // Add one when we need to round up. Break ties to even. |
| let e = if i == 0 { 0 } else { 189 - n }; // Exponent plus 127, minus one, except for zero. |
| (e << 23) + m // + not |, so the mantissa can overflow into the exponent. |
| } |
| |
| pub fn u64_to_f64_bits(i: u64) -> u64 { |
| if i == 0 { |
| return 0; |
| } |
| let n = i.leading_zeros(); |
| let a = (i << n) >> 11; // Significant bits, with bit 53 still in tact. |
| let b = (i << n) << 53; // Insignificant bits, only relevant for rounding. |
| let m = a + ((b - (b >> 63 & !a)) >> 63); // Add one when we need to round up. Break ties to even. |
| let e = 1085 - n as u64; // Exponent plus 1023, minus one. |
| (e << 52) + m // + not |, so the mantissa can overflow into the exponent. |
| } |
| |
| pub fn u128_to_f32_bits(i: u128) -> u32 { |
| let n = i.leading_zeros(); |
| let y = i.wrapping_shl(n); |
| let a = (y >> 104) as u32; // Significant bits, with bit 24 still in tact. |
| let b = (y >> 72) as u32 | ((y << 32) >> 32 != 0) as u32; // Insignificant bits, only relevant for rounding. |
| let m = a + ((b - (b >> 31 & !a)) >> 31); // Add one when we need to round up. Break ties to even. |
| let e = if i == 0 { 0 } else { 253 - n }; // Exponent plus 127, minus one, except for zero. |
| (e << 23) + m // + not |, so the mantissa can overflow into the exponent. |
| } |
| |
| pub fn u128_to_f64_bits(i: u128) -> u64 { |
| let n = i.leading_zeros(); |
| let y = i.wrapping_shl(n); |
| let a = (y >> 75) as u64; // Significant bits, with bit 53 still in tact. |
| let b = (y >> 11 | y & 0xFFFF_FFFF) as u64; // Insignificant bits, only relevant for rounding. |
| let m = a + ((b - (b >> 63 & !a)) >> 63); // Add one when we need to round up. Break ties to even. |
| let e = if i == 0 { 0 } else { 1149 - n as u64 }; // Exponent plus 1023, minus one, except for zero. |
| (e << 52) + m // + not |, so the mantissa can overflow into the exponent. |
| } |
| } |
| |
| // Conversions from unsigned integers to floats. |
| intrinsics! { |
| #[arm_aeabi_alias = __aeabi_ui2f] |
| pub extern "C" fn __floatunsisf(i: u32) -> f32 { |
| f32::from_bits(int_to_float::u32_to_f32_bits(i)) |
| } |
| |
| #[arm_aeabi_alias = __aeabi_ui2d] |
| pub extern "C" fn __floatunsidf(i: u32) -> f64 { |
| f64::from_bits(int_to_float::u32_to_f64_bits(i)) |
| } |
| |
| #[arm_aeabi_alias = __aeabi_ul2f] |
| pub extern "C" fn __floatundisf(i: u64) -> f32 { |
| f32::from_bits(int_to_float::u64_to_f32_bits(i)) |
| } |
| |
| #[arm_aeabi_alias = __aeabi_ul2d] |
| pub extern "C" fn __floatundidf(i: u64) -> f64 { |
| f64::from_bits(int_to_float::u64_to_f64_bits(i)) |
| } |
| |
| #[cfg_attr(target_os = "uefi", unadjusted_on_win64)] |
| pub extern "C" fn __floatuntisf(i: u128) -> f32 { |
| f32::from_bits(int_to_float::u128_to_f32_bits(i)) |
| } |
| |
| #[cfg_attr(target_os = "uefi", unadjusted_on_win64)] |
| pub extern "C" fn __floatuntidf(i: u128) -> f64 { |
| f64::from_bits(int_to_float::u128_to_f64_bits(i)) |
| } |
| } |
| |
| // Conversions from signed integers to floats. |
| intrinsics! { |
| #[arm_aeabi_alias = __aeabi_i2f] |
| pub extern "C" fn __floatsisf(i: i32) -> f32 { |
| let sign_bit = ((i >> 31) as u32) << 31; |
| f32::from_bits(int_to_float::u32_to_f32_bits(i.unsigned_abs()) | sign_bit) |
| } |
| |
| #[arm_aeabi_alias = __aeabi_i2d] |
| pub extern "C" fn __floatsidf(i: i32) -> f64 { |
| let sign_bit = ((i >> 31) as u64) << 63; |
| f64::from_bits(int_to_float::u32_to_f64_bits(i.unsigned_abs()) | sign_bit) |
| } |
| |
| #[arm_aeabi_alias = __aeabi_l2f] |
| pub extern "C" fn __floatdisf(i: i64) -> f32 { |
| let sign_bit = ((i >> 63) as u32) << 31; |
| f32::from_bits(int_to_float::u64_to_f32_bits(i.unsigned_abs()) | sign_bit) |
| } |
| |
| #[arm_aeabi_alias = __aeabi_l2d] |
| pub extern "C" fn __floatdidf(i: i64) -> f64 { |
| let sign_bit = ((i >> 63) as u64) << 63; |
| f64::from_bits(int_to_float::u64_to_f64_bits(i.unsigned_abs()) | sign_bit) |
| } |
| |
| #[cfg_attr(target_os = "uefi", unadjusted_on_win64)] |
| pub extern "C" fn __floattisf(i: i128) -> f32 { |
| let sign_bit = ((i >> 127) as u32) << 31; |
| f32::from_bits(int_to_float::u128_to_f32_bits(i.unsigned_abs()) | sign_bit) |
| } |
| |
| #[cfg_attr(target_os = "uefi", unadjusted_on_win64)] |
| pub extern "C" fn __floattidf(i: i128) -> f64 { |
| let sign_bit = ((i >> 127) as u64) << 63; |
| f64::from_bits(int_to_float::u128_to_f64_bits(i.unsigned_abs()) | sign_bit) |
| } |
| } |
| |
| // Conversions from floats to unsigned integers. |
| intrinsics! { |
| #[arm_aeabi_alias = __aeabi_f2uiz] |
| pub extern "C" fn __fixunssfsi(f: f32) -> u32 { |
| let fbits = f.to_bits(); |
| if fbits < 127 << 23 { // >= 0, < 1 |
| 0 |
| } else if fbits < 159 << 23 { // >= 1, < max |
| let m = 1 << 31 | fbits << 8; // Mantissa and the implicit 1-bit. |
| let s = 158 - (fbits >> 23); // Shift based on the exponent and bias. |
| m >> s |
| } else if fbits <= 255 << 23 { // >= max (incl. inf) |
| u32::MAX |
| } else { // Negative or NaN |
| 0 |
| } |
| } |
| |
| #[arm_aeabi_alias = __aeabi_f2ulz] |
| pub extern "C" fn __fixunssfdi(f: f32) -> u64 { |
| let fbits = f.to_bits(); |
| if fbits < 127 << 23 { // >= 0, < 1 |
| 0 |
| } else if fbits < 191 << 23 { // >= 1, < max |
| let m = 1 << 63 | (fbits as u64) << 40; // Mantissa and the implicit 1-bit. |
| let s = 190 - (fbits >> 23); // Shift based on the exponent and bias. |
| m >> s |
| } else if fbits <= 255 << 23 { // >= max (incl. inf) |
| u64::MAX |
| } else { // Negative or NaN |
| 0 |
| } |
| } |
| |
| #[win64_128bit_abi_hack] |
| pub extern "C" fn __fixunssfti(f: f32) -> u128 { |
| let fbits = f.to_bits(); |
| if fbits < 127 << 23 { // >= 0, < 1 |
| 0 |
| } else if fbits < 255 << 23 { // >= 1, < inf |
| let m = 1 << 127 | (fbits as u128) << 104; // Mantissa and the implicit 1-bit. |
| let s = 254 - (fbits >> 23); // Shift based on the exponent and bias. |
| m >> s |
| } else if fbits == 255 << 23 { // == inf |
| u128::MAX |
| } else { // Negative or NaN |
| 0 |
| } |
| } |
| |
| #[arm_aeabi_alias = __aeabi_d2uiz] |
| pub extern "C" fn __fixunsdfsi(f: f64) -> u32 { |
| let fbits = f.to_bits(); |
| if fbits < 1023 << 52 { // >= 0, < 1 |
| 0 |
| } else if fbits < 1055 << 52 { // >= 1, < max |
| let m = 1 << 31 | (fbits >> 21) as u32; // Mantissa and the implicit 1-bit. |
| let s = 1054 - (fbits >> 52); // Shift based on the exponent and bias. |
| m >> s |
| } else if fbits <= 2047 << 52 { // >= max (incl. inf) |
| u32::MAX |
| } else { // Negative or NaN |
| 0 |
| } |
| } |
| |
| #[arm_aeabi_alias = __aeabi_d2ulz] |
| pub extern "C" fn __fixunsdfdi(f: f64) -> u64 { |
| let fbits = f.to_bits(); |
| if fbits < 1023 << 52 { // >= 0, < 1 |
| 0 |
| } else if fbits < 1087 << 52 { // >= 1, < max |
| let m = 1 << 63 | fbits << 11; // Mantissa and the implicit 1-bit. |
| let s = 1086 - (fbits >> 52); // Shift based on the exponent and bias. |
| m >> s |
| } else if fbits <= 2047 << 52 { // >= max (incl. inf) |
| u64::MAX |
| } else { // Negative or NaN |
| 0 |
| } |
| } |
| |
| #[win64_128bit_abi_hack] |
| pub extern "C" fn __fixunsdfti(f: f64) -> u128 { |
| let fbits = f.to_bits(); |
| if fbits < 1023 << 52 { // >= 0, < 1 |
| 0 |
| } else if fbits < 1151 << 52 { // >= 1, < max |
| let m = 1 << 127 | (fbits as u128) << 75; // Mantissa and the implicit 1-bit. |
| let s = 1150 - (fbits >> 52); // Shift based on the exponent and bias. |
| m >> s |
| } else if fbits <= 2047 << 52 { // >= max (incl. inf) |
| u128::MAX |
| } else { // Negative or NaN |
| 0 |
| } |
| } |
| } |
| |
| // Conversions from floats to signed integers. |
| intrinsics! { |
| #[arm_aeabi_alias = __aeabi_f2iz] |
| pub extern "C" fn __fixsfsi(f: f32) -> i32 { |
| let fbits = f.to_bits() & !0 >> 1; // Remove sign bit. |
| if fbits < 127 << 23 { // >= 0, < 1 |
| 0 |
| } else if fbits < 158 << 23 { // >= 1, < max |
| let m = 1 << 31 | fbits << 8; // Mantissa and the implicit 1-bit. |
| let s = 158 - (fbits >> 23); // Shift based on the exponent and bias. |
| let u = (m >> s) as i32; // Unsigned result. |
| if f.is_sign_negative() { -u } else { u } |
| } else if fbits <= 255 << 23 { // >= max (incl. inf) |
| if f.is_sign_negative() { i32::MIN } else { i32::MAX } |
| } else { // NaN |
| 0 |
| } |
| } |
| |
| #[arm_aeabi_alias = __aeabi_f2lz] |
| pub extern "C" fn __fixsfdi(f: f32) -> i64 { |
| let fbits = f.to_bits() & !0 >> 1; // Remove sign bit. |
| if fbits < 127 << 23 { // >= 0, < 1 |
| 0 |
| } else if fbits < 190 << 23 { // >= 1, < max |
| let m = 1 << 63 | (fbits as u64) << 40; // Mantissa and the implicit 1-bit. |
| let s = 190 - (fbits >> 23); // Shift based on the exponent and bias. |
| let u = (m >> s) as i64; // Unsigned result. |
| if f.is_sign_negative() { -u } else { u } |
| } else if fbits <= 255 << 23 { // >= max (incl. inf) |
| if f.is_sign_negative() { i64::MIN } else { i64::MAX } |
| } else { // NaN |
| 0 |
| } |
| } |
| |
| #[win64_128bit_abi_hack] |
| pub extern "C" fn __fixsfti(f: f32) -> i128 { |
| let fbits = f.to_bits() & !0 >> 1; // Remove sign bit. |
| if fbits < 127 << 23 { // >= 0, < 1 |
| 0 |
| } else if fbits < 254 << 23 { // >= 1, < max |
| let m = 1 << 127 | (fbits as u128) << 104; // Mantissa and the implicit 1-bit. |
| let s = 254 - (fbits >> 23); // Shift based on the exponent and bias. |
| let u = (m >> s) as i128; // Unsigned result. |
| if f.is_sign_negative() { -u } else { u } |
| } else if fbits <= 255 << 23 { // >= max (incl. inf) |
| if f.is_sign_negative() { i128::MIN } else { i128::MAX } |
| } else { // NaN |
| 0 |
| } |
| } |
| |
| #[arm_aeabi_alias = __aeabi_d2iz] |
| pub extern "C" fn __fixdfsi(f: f64) -> i32 { |
| let fbits = f.to_bits() & !0 >> 1; // Remove sign bit. |
| if fbits < 1023 << 52 { // >= 0, < 1 |
| 0 |
| } else if fbits < 1054 << 52 { // >= 1, < max |
| let m = 1 << 31 | (fbits >> 21) as u32; // Mantissa and the implicit 1-bit. |
| let s = 1054 - (fbits >> 52); // Shift based on the exponent and bias. |
| let u = (m >> s) as i32; // Unsigned result. |
| if f.is_sign_negative() { -u } else { u } |
| } else if fbits <= 2047 << 52 { // >= max (incl. inf) |
| if f.is_sign_negative() { i32::MIN } else { i32::MAX } |
| } else { // NaN |
| 0 |
| } |
| } |
| |
| #[arm_aeabi_alias = __aeabi_d2lz] |
| pub extern "C" fn __fixdfdi(f: f64) -> i64 { |
| let fbits = f.to_bits() & !0 >> 1; // Remove sign bit. |
| if fbits < 1023 << 52 { // >= 0, < 1 |
| 0 |
| } else if fbits < 1086 << 52 { // >= 1, < max |
| let m = 1 << 63 | fbits << 11; // Mantissa and the implicit 1-bit. |
| let s = 1086 - (fbits >> 52); // Shift based on the exponent and bias. |
| let u = (m >> s) as i64; // Unsigned result. |
| if f.is_sign_negative() { -u } else { u } |
| } else if fbits <= 2047 << 52 { // >= max (incl. inf) |
| if f.is_sign_negative() { i64::MIN } else { i64::MAX } |
| } else { // NaN |
| 0 |
| } |
| } |
| |
| #[win64_128bit_abi_hack] |
| pub extern "C" fn __fixdfti(f: f64) -> i128 { |
| let fbits = f.to_bits() & !0 >> 1; // Remove sign bit. |
| if fbits < 1023 << 52 { // >= 0, < 1 |
| 0 |
| } else if fbits < 1150 << 52 { // >= 1, < max |
| let m = 1 << 127 | (fbits as u128) << 75; // Mantissa and the implicit 1-bit. |
| let s = 1150 - (fbits >> 52); // Shift based on the exponent and bias. |
| let u = (m >> s) as i128; // Unsigned result. |
| if f.is_sign_negative() { -u } else { u } |
| } else if fbits <= 2047 << 52 { // >= max (incl. inf) |
| if f.is_sign_negative() { i128::MIN } else { i128::MAX } |
| } else { // NaN |
| 0 |
| } |
| } |
| } |
