Advance the port to llvm/llvm-project@a258894

(last APFloat-related LLVM commit from June 2020, concluding the addition of BFloat16).

Author: eddyb

Cargo.toml

@@ -2,7 +2,7 @@
 members = ["fuzz"]
 
 [workspace.package]
-version = "0.0.4+llvm-b198f1f86ce0"
+version = "0.0.5+llvm-a2588948febc"
 edition = "2021"
 license = "Apache-2.0 WITH LLVM-exception"
 

fuzz/ops.rs

@@ -280,11 +280,13 @@ struct FuzzOp {
         (32, "APFloat::IEEEsingle()"),
         (64, "APFloat::IEEEdouble()"),
         (128, "APFloat::IEEEquad()"),
+        (16, "APFloat::BFloat()"),
         (80, "APFloat::x87DoubleExtended()"),
     ]
     .into_iter()
     .map(|(w, cxx_apf_semantics)| {
         let (name_prefix, uint_width) = match w {
+            16 if cxx_apf_semantics.contains("BFloat") => ("BrainF", 16),
             80 => ("X87_F", 128),
             _ => ("IEEE", w),
         };

fuzz/src/main.rs

@@ -54,6 +54,10 @@ trait FloatRepr: Copy + Default + Eq + fmt::Display {
 
     const NAME: &'static str;
 
+    // HACK(eddyb) this has to be overwritable because we have more than one
+    // format with the same `BIT_WIDTH`, so it's not unambiguous on its own.
+    const REPR_TAG: u8 = Self::BIT_WIDTH as u8;
+
     // FIXME(eddyb) these should ideally be using `[u8; Self::BYTE_LEN]`.
     fn from_le_bytes(bytes: &[u8]) -> Self;
     fn write_as_le_bytes_into(self, out_bytes: &mut Vec<u8>);
@@ -70,17 +74,24 @@ trait FloatRepr: Copy + Default + Eq + fmt::Display {
 macro_rules! float_reprs {
     ($($name:ident($repr:ty) {
         type RustcApFloat = $rs_apf_ty:ty;
+        $(const REPR_TAG = $repr_tag:expr;)?
         extern fn = $cxx_apf_eval_fuzz_op:ident;
         $(type HardFloat = $hard_float_ty:ty;)?
     })+) => {
         // HACK(eddyb) helper macro used to actually handle all types uniformly.
-        macro_rules! dispatch_all_reprs {
-            ($ty_var:ident => $e:expr) => {{
-                $({
-                    type $ty_var = $name;
-                    $e
-                })+
-            }}
+        macro_rules! dispatch_any_float_repr_by_repr_tag {
+            (match $repr_tag_value:ident { for<$ty_var:ident: FloatRepr> => $e:expr }) => {
+                // NOTE(eddyb) this doubles as an overlap check: `REPR_TAG`
+                // values across *all* `FloatRepr` `impl` *must* be unique.
+                #[deny(unreachable_patterns)]
+                match $repr_tag_value {
+                    $($name::REPR_TAG => {
+                        type $ty_var = $name;
+                        $e;
+                    })+
+                    _ => {}
+                }
+            }
         }
 
         $(
@@ -96,6 +107,8 @@ macro_rules! float_reprs {
 
                 const NAME: &'static str = stringify!($name);
 
+                $(const REPR_TAG: u8 = $repr_tag;)?
+
                 fn from_le_bytes(bytes: &[u8]) -> Self {
                     // HACK(eddyb) this allows using e.g. `u128` to hold 80 bits.
                     let mut repr_bytes = [0; std::mem::size_of::<$repr>()];
@@ -180,6 +193,13 @@ float_reprs! {
         type RustcApFloat = rustc_apfloat::ieee::Quad;
         extern fn = cxx_apf_fuzz_eval_op_ieee128;
     }
+
+    // Non-standard IEEE-like formats.
+    BrainF16(u16) {
+        type RustcApFloat = rustc_apfloat::ieee::BFloat;
+        const REPR_TAG = 16 + 1;
+        extern fn = cxx_apf_fuzz_eval_op_brainf16;
+    }
     X87_F80(u128) {
         type RustcApFloat = rustc_apfloat::ieee::X87DoubleExtended;
         extern fn = cxx_apf_fuzz_eval_op_x87_f80;
@@ -380,15 +400,16 @@ fn main() {
 
                     data.split_first()
                         .ok_or("empty file")
-                        .and_then(|(&bit_width, data)| {
-                            dispatch_all_reprs!(F => if bit_width as usize == F::BIT_WIDTH {
-                                FuzzOp::<F>::try_decode(data)
-                                    .ok()
-                                    .ok_or(std::any::type_name::<FuzzOp<F>>())?
-                                    .print_op_and_eval_outputs(&cli_args);
-                                return Ok(());
+                        .and_then(|(&repr_tag, data)| {
+                            dispatch_any_float_repr_by_repr_tag!(match repr_tag {
+                                for<F: FloatRepr> => return Ok(
+                                    FuzzOp::<F>::try_decode(data)
+                                        .ok()
+                                        .ok_or(std::any::type_name::<FuzzOp<F>>())?
+                                        .print_op_and_eval_outputs(&cli_args)
+                                )
                             });
-                            Err("first byte not valid bit width")
+                            Err("first byte not valid `FloatRepr::REPR_TAG`")
                         })
                         .unwrap_or_else(|e| println!("  invalid data ({e})"));
                 }
@@ -399,10 +420,11 @@ fn main() {
 
     #[cfg_attr(not(fuzzing), allow(unused))]
     let fuzz_one_op = |data: &[u8]| {
-        data.split_first().and_then(|(&bit_width, data)| {
-            dispatch_all_reprs!(F => if bit_width as usize == F::BIT_WIDTH {
-                FuzzOp::<F>::try_decode(data).ok()?.eval(&cli_args).assert_all_match();
-                return Some(());
+        data.split_first().and_then(|(&repr_tag, data)| {
+            dispatch_any_float_repr_by_repr_tag!(match repr_tag {
+                for<F: FloatRepr> => return Some(
+                    FuzzOp::<F>::try_decode(data).ok()?.eval(&cli_args).assert_all_match()
+                )
             });
             None
         });

src/ieee.rs

@@ -165,7 +165,7 @@ impl<S> Clone for IeeeFloat<S> {
 }
 
 macro_rules! ieee_semantics {
-    ($($name:ident = $sem:ident($bits:tt : $exp_bits:tt)),*) => {
+    ($($name:ident = $sem:ident($bits:tt : $exp_bits:tt)),* $(,)?) => {
         $(pub struct $sem;)*
         $(pub type $name = IeeeFloat<$sem>;)*
         $(impl Semantics for $sem {
@@ -180,7 +180,10 @@ ieee_semantics! {
     Half = HalfS(16:5),
     Single = SingleS(32:8),
     Double = DoubleS(64:11),
-    Quad = QuadS(128:15)
+    Quad = QuadS(128:15),
+
+    // Non-standard IEEE-like semantics.
+    BFloat = BFloatS(16:8),
 }
 
 pub struct X87DoubleExtendedS;

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/b198f1f86ce09b86825dd6d80de2c72a617e27f7
+//! https://github.com/llvm/llvm-project/commit/a2588948febccfed5ba074fc32dcb093484fa5c8
 //! * `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