Advance the port to llvm/llvm-project@768d6dd

(last APFloat-related LLVM commit from 2017).

Cargo.toml

@@ -2,7 +2,7 @@
 members = ["fuzz"]
 
 [workspace.package]
-version = "0.0.0+llvm-f3598e8fca83"
+version = "0.0.1+llvm-768d6dd08783"
 edition = "2021"
 license = "Apache-2.0 WITH LLVM-exception"
 

fuzz/build.rs

@@ -68,7 +68,7 @@ curl -sS "$llvm_project_tgz_url" | tar -C "$OUT_DIR" -xz
 llvm="$OUT_DIR"/llvm-project-"$llvm_project_git_hash"/llvm
 
 mkdir -p "$OUT_DIR"/fake-config/llvm/Config
-touch "$OUT_DIR"/fake-config/llvm/Config/{abi-breaking,llvm-config}.h
+touch "$OUT_DIR"/fake-config/llvm/Config/{abi-breaking,config,llvm-config}.h
 
 # HACK(eddyb) we want standard `assert`s to work, but `NDEBUG` also controls
 # unrelated LLVM facilities that are spread all over the place and it's harder
@@ -91,8 +91,8 @@ echo | clang++ -x c++ - -std=c++17 \
   $clang_codegen_flags \
   -I "$llvm"/include \
   -I "$OUT_DIR"/fake-config \
-  -DNDEBUG \
-  --include="$llvm"/lib/Support/{APInt,APFloat,SmallVector}.cpp \
+  -DNDEBUG -DHAVE_UNISTD_H \
+  --include="$llvm"/lib/Support/{APInt,APFloat,SmallVector,ErrorHandling}.cpp \
   --include="$OUT_DIR"/cxx_apf_fuzz.cpp \
   -c -emit-llvm -o "$OUT_DIR"/cxx_apf_fuzz.bc
 

src/ieee.rs

@@ -1003,6 +1003,8 @@ impl<S: Semantics> Float for IeeeFloat<S> {
             (Category::Infinity, _) | (_, Category::Zero) => Status::INVALID_OP.and(Self::NAN),
 
             (Category::Normal, Category::Normal) => {
+                let orig_sign = self.sign;
+
                 while self.is_finite_non_zero()
                     && rhs.is_finite_non_zero()
                     && self.cmp_abs_normal(rhs) != Ordering::Less
@@ -1017,6 +1019,9 @@ impl<S: Semantics> Float for IeeeFloat<S> {
                     self = unpack!(status=, self - v);
                     assert_eq!(status, Status::OK);
                 }
+                if self.is_zero() {
+                    self.sign = orig_sign;
+                }
                 Status::OK.and(self)
             }
         }
@@ -1182,8 +1187,8 @@ impl<S: Semantics> Float for IeeeFloat<S> {
 
         // Handle special cases.
         match s {
-            "inf" | "INFINITY" => return Ok(Status::OK.and(Self::INFINITY)),
-            "-inf" | "-INFINITY" => return Ok(Status::OK.and(-Self::INFINITY)),
+            "inf" | "INFINITY" | "+Inf" => return Ok(Status::OK.and(Self::INFINITY)),
+            "-inf" | "-INFINITY" | "-Inf" => return Ok(Status::OK.and(-Self::INFINITY)),
             "nan" | "NaN" => return Ok(Status::OK.and(Self::NAN)),
             "-nan" | "-NaN" => return Ok(Status::OK.and(-Self::NAN)),
             _ => {}

src/lib.rs

@@ -1,6 +1,6 @@
 //! Port of LLVM's APFloat software floating-point implementation from the
 //! following C++ sources (please update commit hash when backporting):
-//! https://github.com/llvm/llvm-project/commit/f3598e8fca83ccfb11f58ec7957c229e349765e3
+//! https://github.com/llvm/llvm-project/commit/768d6dd08783440606da83dac490889329619898
 //! * `llvm/include/llvm/ADT/APFloat.h` -> `Float` and `FloatConvert` traits
 //! * `llvm/lib/Support/APFloat.cpp` -> `ieee` and `ppc` modules
 //! * `llvm/unittests/ADT/APFloatTest.cpp` -> `tests` directory

src/ppc.rs

@@ -407,6 +407,10 @@ where
         self.0.category()
     }
 
+    fn is_integer(self) -> bool {
+        self.0.is_integer() && self.1.is_integer()
+    }
+
     fn get_exact_inverse(self) -> Option<Self> {
         Fallback::from(self).get_exact_inverse().map(Self::from)
     }
@@ -428,3 +432,13 @@ where
         DoubleFloat(a, b)
     }
 }
+
+// HACK(eddyb) this is here instead of in `tests/ppc.rs` because `DoubleFloat`
+// has private fields, and it's not worth it to make them public just for testing.
+#[test]
+fn is_integer() {
+    let double_from_f64 = |f: f64| ieee::Double::from_bits(f.to_bits().into());
+    assert!(DoubleFloat(double_from_f64(-0.0), double_from_f64(-0.0)).is_integer());
+    assert!(!DoubleFloat(double_from_f64(3.14159), double_from_f64(-0.0)).is_integer());
+    assert!(!DoubleFloat(double_from_f64(-0.0), double_from_f64(3.14159)).is_integer());
+}

tests/ieee.rs

@@ -860,6 +860,20 @@ fn from_decimal_string() {
     assert_eq!(2.71828, "2.71828".parse::<Double>().unwrap().to_f64());
 }
 
+#[test]
+fn from_to_string_specials() {
+    assert_eq!("+Inf", "+Inf".parse::<Double>().unwrap().to_string());
+    assert_eq!("+Inf", "INFINITY".parse::<Double>().unwrap().to_string());
+    assert_eq!("+Inf", "inf".parse::<Double>().unwrap().to_string());
+    assert_eq!("-Inf", "-Inf".parse::<Double>().unwrap().to_string());
+    assert_eq!("-Inf", "-INFINITY".parse::<Double>().unwrap().to_string());
+    assert_eq!("-Inf", "-inf".parse::<Double>().unwrap().to_string());
+    assert_eq!("NaN", "NaN".parse::<Double>().unwrap().to_string());
+    assert_eq!("NaN", "nan".parse::<Double>().unwrap().to_string());
+    assert_eq!("NaN", "-NaN".parse::<Double>().unwrap().to_string());
+    assert_eq!("NaN", "-nan".parse::<Double>().unwrap().to_string());
+}
+
 #[test]
 fn from_hexadecimal_string() {
     assert_eq!(1.0, "0x1p0".parse::<Double>().unwrap().to_f64());
@@ -3190,4 +3204,18 @@ fn modulo() {
         assert!(unpack!(status=, f1 % f2).is_nan());
         assert_eq!(status, Status::INVALID_OP);
     }
+    {
+        let f1 = "-4.0".parse::<Double>().unwrap();
+        let f2 = "-2.0".parse::<Double>().unwrap();
+        let expected = "-0.0".parse::<Double>().unwrap();
+        assert!(unpack!(status=, f1 % f2).bitwise_eq(expected));
+        assert_eq!(status, Status::OK);
+    }
+    {
+        let f1 = "-4.0".parse::<Double>().unwrap();
+        let f2 = "2.0".parse::<Double>().unwrap();
+        let expected = "-0.0".parse::<Double>().unwrap();
+        assert!(unpack!(status=, f1 % f2).bitwise_eq(expected));
+        assert_eq!(status, Status::OK);
+    }
 }