Add TF32

This floating point type is used by some accelerators (e.g., AMD and
NVIDIA GPUs).

Upstream LLVM commit: llvm/llvm-project@55c2211a233e ("[APFloat] Add
APFloat semantic support for TF32")

Mostly authored by Eddy and Eduardo, I just updated some of the denormal
tests.  Created from two commits (not in tree):

* 70fe4d8 ("Add TF32")
* 07807bf ("Port TF32 tests")

Co-authored-by: Eduardo Sánchez Muñoz <eduardosm-dev@e64.io>
Co-authored-by: Eduard-Mihai Burtescu <eddyb@lyken.rs>

Author: 3 people

Cargo.toml

@@ -2,7 +2,7 @@
 members = ["fuzz"]
 
 [workspace.package]
-version = "0.2.3+llvm-687bd77e2c26"
+version = "0.2.3+llvm-55c2211a233e"
 edition = "2021"
 license = "Apache-2.0 WITH LLVM-exception"
 

src/ieee.rs

@@ -424,6 +424,11 @@ ieee_semantics! {
         const NAN_ENCODING: NanEncoding = NanEncoding::NegativeZero;
         const MIN_EXP: ExpInt = Self::IEEE_MIN_EXP - 4;
     },
+
+    /// Floating point number that occupies 32 bits or less of storage, providing
+    /// improved range compared to half (16-bit) formats, at (potentially)
+    /// greater throughput than single precision (32-bit) formats.
+    FloatTF32 = FloatTF32S(19:8),
 }
 
 // FIXME(eddyb) consider moving X87-specific logic to a "has explicit integer bit"

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/687bd77e2c26487cba727aacfa7067dd01286be0>
+//! <https://github.com/llvm/llvm-project/commit/55c2211a233e11179048cf58778f40e5a62f444a>
 //! * `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

tests/ieee.rs

@@ -3,8 +3,8 @@ extern crate rustc_apfloat;
 
 use core::cmp::Ordering;
 use rustc_apfloat::ieee::{
-    BFloat, Double, Float8E4M3B11FNUZ, Float8E4M3FN, Float8E4M3FNUZ, Float8E5M2, Float8E5M2FNUZ, Half, Quad, Single,
-    X87DoubleExtended,
+    BFloat, Double, Float8E4M3B11FNUZ, Float8E4M3FN, Float8E4M3FNUZ, Float8E5M2, Float8E5M2FNUZ, FloatTF32, Half, Quad,
+    Single, X87DoubleExtended,
 };
 use rustc_apfloat::{Category, ExpInt, IEK_INF, IEK_NAN, IEK_ZERO};
 use rustc_apfloat::{Float, FloatConvert, Round, Status, StatusAnd};
@@ -35,6 +35,7 @@ define_for_each_float_type! {
     Float8E4M3FNUZ,
     Float8E5M2FNUZ,
     Float8E4M3B11FNUZ,
+    FloatTF32,
     X87DoubleExtended,
 
     // NOTE(eddyb) tests for this are usually in `ppc.rs` but this works too.
@@ -95,6 +96,7 @@ impl ToF32LosslessViaConvertToSingle for Float8E4M3FN {}
 impl ToF32LosslessViaConvertToSingle for Float8E4M3FNUZ {}
 impl ToF32LosslessViaConvertToSingle for Float8E5M2FNUZ {}
 impl ToF32LosslessViaConvertToSingle for Float8E4M3B11FNUZ {}
+impl ToF32LosslessViaConvertToSingle for FloatTF32 {}
 
 trait ToF64LosslessViaConvertToDouble: FloatConvert<Double> {
     fn to_f64(self) -> f64 {
@@ -849,6 +851,24 @@ fn denormal() {
         t /= Quad::from_u128(2).value;
         assert!(t.is_denormal());
     }
+
+    // Test TF32
+    {
+        let mut t = "1.17549435082228750797e-38".parse::<FloatTF32>().unwrap();
+        assert!(!t.is_denormal());
+        assert!(!FloatTF32::from_u128(0).value.is_denormal());
+
+        t /= FloatTF32::from_u128(2).value;
+        assert!(t.is_denormal());
+        assert!(t.is_sign_positive());
+
+        let mut t = "-1.17549435082228750797e-38".parse::<FloatTF32>().unwrap();
+        assert!(!t.is_denormal());
+
+        t /= FloatTF32::from_u128(2).value;
+        assert!(t.is_denormal());
+        assert!(t.is_sign_negative());
+    }
 }
 
 #[test]
@@ -1516,6 +1536,19 @@ fn nan() {
         (0x80, true, false, 0xaa),
         (0x80, true, true, 0xaa),
     ];
+    let test_tf32 = [
+        // ex.    SNaN   Neg    payload
+        (0x3fe00, false, false, 0x00000000),
+        (0x7fe00, false, true, 0x00000000),
+        (0x3feaa, false, false, 0xaa),
+        (0x3ffaa, false, false, 0xdaa),
+        (0x3ffaa, false, false, 0xfdaa),
+        (0x3fd00, true, false, 0x00000000),
+        (0x7fd00, true, true, 0x00000000),
+        (0x3fcaa, true, false, 0xaa),
+        (0x3fdaa, true, false, 0xfaa),
+        (0x3fdaa, true, false, 0x1aa),
+    ];
     for (expected, signaling, negative, payload) in tests_single {
         assert_eq!(expected, nanbits_from_u128::<Single>(signaling, negative, payload));
     }
@@ -1531,6 +1564,9 @@ fn nan() {
     for (expected, signaling, negative, payload) in tests_8e4m3b11fnuz {
         assert_eq!(expected, nanbits_from_u128::<Float8E4M3B11FNUZ>(signaling, negative, payload));
     }
+    for (expected, signaling, negative, payload) in test_tf32 {
+        assert_eq!(expected, nanbits_from_u128::<FloatTF32>(signaling, negative, payload));
+    }
 }
 
 #[test]
@@ -1888,6 +1924,7 @@ fn largest() {
     assert_eq!(240.0, Float8E4M3FNUZ::largest().to_f64());
     assert_eq!(57344.0, Float8E5M2FNUZ::largest().to_f64());
     assert_eq!(30.0, Float8E4M3B11FNUZ::largest().to_f64());
+    assert_eq!(3.40116213421e+38, FloatTF32::largest().to_f32());
 }
 
 #[test]
@@ -1940,6 +1977,13 @@ fn smallest() {
     assert!(test.is_finite_non_zero());
     assert!(test.is_denormal());
     assert!(test.bitwise_eq(expected));
+
+    let test = -FloatTF32::SMALLEST;
+    let expected = "-0x0.004p-126".parse::<FloatTF32>().unwrap();
+    assert!(test.is_negative());
+    assert!(test.is_finite_non_zero());
+    assert!(test.is_denormal());
+    assert!(test.bitwise_eq(expected));
 }
 
 #[test]
@@ -2015,6 +2059,14 @@ fn smallest_normalized() {
     assert!(!test.is_denormal());
     assert!(test.bitwise_eq(expected));
     assert!(test.is_smallest_normalized());
+
+    let test = FloatTF32::smallest_normalized();
+    let expected = "0x1p-126".parse::<FloatTF32>().unwrap();
+    assert!(!test.is_negative());
+    assert!(test.is_finite_non_zero());
+    assert!(!test.is_denormal());
+    assert!(test.bitwise_eq(expected));
+    assert!(test.is_smallest_normalized());
 }
 
 #[test]
@@ -2056,6 +2108,8 @@ fn zero() {
     test::<Float8E4M3FNUZ>(true, false, 0);
     test::<Float8E4M3B11FNUZ>(false, false, 0);
     test::<Float8E4M3B11FNUZ>(true, false, 0);
+    test::<FloatTF32>(false, true, 0);
+    test::<FloatTF32>(true, true, 0x40000);
 }
 
 #[test]
@@ -5573,6 +5627,32 @@ fn float8e4m3fnuz_to_f64() {
     assert!(qnan.to_f64().is_nan());
 }
 
+#[test]
+fn float_tf32_to_f64() {
+    let one = "1.0".parse::<FloatTF32>().unwrap();
+    assert_eq!(1.0, one.to_f64());
+    let pos_largest = FloatTF32::largest();
+    assert_eq!(3.401162134214653489792616e+38, pos_largest.to_f64());
+    let neg_largest = -FloatTF32::largest();
+    assert_eq!(-3.401162134214653489792616e+38, neg_largest.to_f64());
+    let pos_smallest = FloatTF32::smallest_normalized();
+    assert_eq!(1.1754943508222875079687e-38, pos_smallest.to_f64());
+    let neg_smallest = -FloatTF32::smallest_normalized();
+    assert_eq!(-1.1754943508222875079687e-38, neg_smallest.to_f64());
+
+    let smallest_denorm = FloatTF32::SMALLEST;
+    assert_eq!(1.1479437019748901445007e-41, smallest_denorm.to_f64());
+    let largest_denorm = "0x1.FF8p-127".parse::<FloatTF32>().unwrap();
+    assert_eq!(1.1743464071203126178242e-38, largest_denorm.to_f64());
+
+    let pos_inf = FloatTF32::INFINITY;
+    assert_eq!(f64::INFINITY, pos_inf.to_f64());
+    let neg_inf = -FloatTF32::INFINITY;
+    assert_eq!(f64::NEG_INFINITY, neg_inf.to_f64());
+    let qnan = FloatTF32::NAN;
+    assert!(qnan.to_f64().is_nan());
+}
+
 #[test]
 fn float8e5m2fnuz_to_f32() {
     let pos_zero = Float8E5M2FNUZ::ZERO;
@@ -5791,3 +5871,32 @@ fn float8e4m3fn_to_f32() {
     let qnan = Float8E4M3FN::qnan(None);
     assert!(qnan.to_f32().is_nan());
 }
+
+#[test]
+fn float_tf32_to_f32() {
+    let pos_zero = FloatTF32::ZERO;
+    assert!(Single::from_f32(pos_zero.to_f32()).is_pos_zero());
+    let neg_zero = -FloatTF32::ZERO;
+    assert!(Single::from_f32(neg_zero.to_f32()).is_neg_zero());
+
+    let one = "1.0".parse::<FloatTF32>().unwrap();
+    assert_eq!(1.0, one.to_f32());
+    let two = "2.0".parse::<FloatTF32>().unwrap();
+    assert_eq!(2.0, two.to_f32());
+
+    let pos_largest = FloatTF32::largest();
+    assert_eq!(3.40116213421e+38, pos_largest.to_f32());
+    let neg_largest = -FloatTF32::largest();
+    assert_eq!(-3.40116213421e+38, neg_largest.to_f32());
+    let pos_smallest = FloatTF32::smallest_normalized();
+    assert_eq!(/*0x1.p-126*/ 1.1754943508222875e-38, pos_smallest.to_f32());
+    let neg_smallest = -FloatTF32::smallest_normalized();
+    assert_eq!(/*-0x1.p-126*/ -1.1754943508222875e-38, neg_smallest.to_f32());
+
+    let smallest_denorm = FloatTF32::SMALLEST;
+    assert!(smallest_denorm.is_denormal());
+    assert_eq!(/*0x0.004p-126*/ 1.148e-41, smallest_denorm.to_f32());
+
+    let qnan = FloatTF32::qnan(None);
+    assert!(qnan.to_f32().is_nan());
+}