---

yaml
---
r: 232339
b: refs/heads/try
c: 15518a9
h: refs/heads/master
i:
  232337: 61abe54
  232335: 8bdb844
v: v3

Author: Robin Kruppe

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: edeb4f1c86cbf6af8ef9874d4b3af50f721ea1b8
 refs/heads/snap-stage3: 1af31d4974e33027a68126fa5a5a3c2c6491824f
-refs/heads/try: 82dbc2ea619cbfc98ca9ad2f9e06a5acd294cbe3
+refs/heads/try: 15518a9c0c1c5f1774503c72072c73e64411d130
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try/src/libcore/num/dec2flt/algorithm.rs

@@ -21,9 +21,8 @@ use super::num::{self, Big};
 /// Number of significand bits in Fp
 const P: u32 = 64;
 
-// We simply store the best approximation for *all* exponents, so
-// the variable "h" and the associated conditions can be omitted.
-// This trades performance for space (11 KiB versus... 5 KiB or so?)
+// We simply store the best approximation for *all* exponents, so the variable "h" and the
+// associated conditions can be omitted. This trades performance for a couple kilobytes of space.
 
 fn power_of_ten(e: i16) -> Fp {
     assert!(e >= table::MIN_E);
@@ -37,6 +36,15 @@ fn power_of_ten(e: i16) -> Fp {
 ///
 /// This is extracted into a separate function so that it can be attempted before constructing
 /// a bignum.
+///
+/// The fast path crucially depends on arithmetic being correctly rounded, so on x86
+/// without SSE or SSE2 it will be **wrong** (as in, off by one ULP occasionally), because the x87
+/// FPU stack will round to 80 bit first before rounding to 64/32 bit. However, as such hardware
+/// is extremely rare nowadays and in fact all in-tree target triples assume an SSE2-capable
+/// microarchitecture, there is little incentive to deal with that. There's a test that will fail
+/// when SSE or SSE2 is disabled, so people building their own non-SSE copy will get a heads up.
+///
+/// FIXME: It would nevertheless be nice if we had a good way to detect and deal with x87.
 pub fn fast_path<T: RawFloat>(integral: &[u8], fractional: &[u8], e: i64) -> Option<T> {
     let num_digits = integral.len() + fractional.len();
     // log_10(f64::max_sig) ~ 15.95. We compare the exact value to max_sig near the end,

branches/try/src/libcoretest/num/dec2flt/mod.rs

@@ -90,6 +90,13 @@ fn zero() {
     test_literal!(1e-500);
 }
 
+#[test]
+fn fast_path_correct() {
+    // This number triggers the fast path and is handled incorrectly when compiling on
+    // x86 without SSE2 (i.e., using the x87 FPU stack).
+    test_literal!(1.448997445238699);
+}
+
 #[test]
 fn lonely_dot() {
     assert_eq!(to_f64("."), Ok(0.0));