Add two additional float8 types to MLIR and APFloat.

[jakeh-gc]

Summary

Graphcore, AMD, and Qualcomm have proposed two new FP8 formats, Float8E4M3FZN and Float8E5M2FZN. These formats are presented in this paper: https://arxiv.org/abs/2206.02915. They are implemented in commercially available hardware and the ISA for this hardware is available here: https://docs.graphcore.ai/projects/isa-mk2-with-fp8/en/latest/_static/TileVertexISA-IPU21-1.3.1.pdf.

This patch adds support for these two types in MLIR and APFloat, alongside the previously added types Float8E4M3FN and Float8E5M2 (D133823, D137760, RFC).

Following the naming scheme from those existing types, the suffix "FZN" here refers to the fact that these types support finite values, positive-only zero (no negative zero), and a NaN encoding. In both types NaN has exactly one encoding 0b10000000.

To support this behaviour I have added another value to the fltNonfiniteBehavior enum to represent this specific NaN encoding. I have also added a new field (fltSignedZeroSupport) to the fltSemantics struct to describe whether signed zero is supported.

[jakeh-gc]

The build failure is for clang-format on APFloat.cpp. That file has an unusual indentation, so I don't believe I can make that pass without reformatting the whole file. I believe doing that would make this diff harder to review.

[krzysz00]

I think we have dueling patches that we should reconcile. I've put together https://reviews.llvm.org/D141863 to do the same thing. (it's just now posted because we were waiting to talk to y'all over at GraphCore to finalize naming, etc. ... but since this revision's already up I might as well go and put mine.)

[jakeh-gc]

I'm going to put up a narrower version of this based on D141863

clang/lib/AST/MicrosoftMangle.cpp

void MicrosoftCXXNameMangler::mangleFloat(llvm::APFloat Number) {
   // unlikely to conflict with MSVC's scheme.
   case APFloat::S_IEEEhalf: Out << 'V'; break;
   case APFloat::S_BFloat: Out << 'W'; break;
   case APFloat::S_x87DoubleExtended: Out << 'X'; break;
   case APFloat::S_IEEEquad: Out << 'Y'; break;
   case APFloat::S_PPCDoubleDouble: Out << 'Z'; break;
   case APFloat::S_Float8E5M2:
   case APFloat::S_Float8E4M3FN:
+  case APFloat::S_Float8E5M2FZN:
+  case APFloat::S_Float8E4M3FZN:
     llvm_unreachable("Tried to mangle unexpected APFloat semantics");
   }
 
   mangleBits(Number.bitcastToAPInt());
 }
 
 void MicrosoftCXXNameMangler::mangleBits(llvm::APInt Value) {
   if (Value == 0)

llvm/include/llvm/ADT/APFloat.h

enum Semantics {
     // 8-bit floating point number following IEEE-754 conventions with bit
     // layout S1E5M2 as described in https://arxiv.org/abs/2209.05433.
     S_Float8E5M2,
     // 8-bit floating point number mostly following IEEE-754 conventions with
     // bit layout S1E4M3 as described in https://arxiv.org/abs/2209.05433.
     // Unlike IEEE-754 types, there are no infinity values, and NaN is
     // represented with the exponent and mantissa bits set to all 1s.
     S_Float8E4M3FN,
+    // 8-bit floating point number mostly following IEEE-754 conventions with
+    // bit layout S1E5M2 as described in https://arxiv.org/abs/2206.02915.
+    // Unlike IEEE-754 types, there are no infinity values, there is no
+    // negative zero, and NaN is represented with the exponent and mantissa
+    // bits set to all 0s and the sign bit set to 1.
+    S_Float8E5M2FZN,
+    // 8-bit floating point number mostly following IEEE-754 conventions with
+    // bit layout S1E4M3 as described in https://arxiv.org/abs/2206.02915.
+    // Unlike IEEE-754 types, there are no infinity values, there is no
+    // negative zero, and NaN is represented with the exponent and mantissa
+    // bits set to all 0s and the sign bit set to 1.
+    S_Float8E4M3FZN,
     S_x87DoubleExtended,
     S_MaxSemantics = S_x87DoubleExtended,
   };
 
   static const llvm::fltSemantics &EnumToSemantics(Semantics S);
   static Semantics SemanticsToEnum(const llvm::fltSemantics &Sem);
 
   static const fltSemantics &IEEEhalf() LLVM_READNONE;
   static const fltSemantics &BFloat() LLVM_READNONE;
   static const fltSemantics &IEEEsingle() LLVM_READNONE;
   static const fltSemantics &IEEEdouble() LLVM_READNONE;
   static const fltSemantics &IEEEquad() LLVM_READNONE;
   static const fltSemantics &PPCDoubleDouble() LLVM_READNONE;
   static const fltSemantics &Float8E5M2() LLVM_READNONE;
   static const fltSemantics &Float8E4M3FN() LLVM_READNONE;
+  static const fltSemantics &Float8E5M2FZN() LLVM_READNONE;
+  static const fltSemantics &Float8E4M3FZN() LLVM_READNONE;
   static const fltSemantics &x87DoubleExtended() LLVM_READNONE;
 
   /// A Pseudo fltsemantic used to construct APFloats that cannot conflict with
   /// anything real.
   static const fltSemantics &Bogus() LLVM_READNONE;
 
   /// @}
 
private:
   APInt convertBFloatAPFloatToAPInt() const;
   APInt convertFloatAPFloatToAPInt() const;
   APInt convertDoubleAPFloatToAPInt() const;
   APInt convertQuadrupleAPFloatToAPInt() const;
   APInt convertF80LongDoubleAPFloatToAPInt() const;
   APInt convertPPCDoubleDoubleAPFloatToAPInt() const;
   APInt convertFloat8E5M2APFloatToAPInt() const;
   APInt convertFloat8E4M3FNAPFloatToAPInt() const;
+  APInt convertFloat8E5M2FZNAPFloatToAPInt() const;
+  APInt convertFloat8E4M3FZNAPFloatToAPInt() const;
   void initFromAPInt(const fltSemantics *Sem, const APInt &api);
   void initFromHalfAPInt(const APInt &api);
   void initFromBFloatAPInt(const APInt &api);
   void initFromFloatAPInt(const APInt &api);
   void initFromDoubleAPInt(const APInt &api);
   void initFromQuadrupleAPInt(const APInt &api);
   void initFromF80LongDoubleAPInt(const APInt &api);
   void initFromPPCDoubleDoubleAPInt(const APInt &api);
   void initFromFloat8E5M2APInt(const APInt &api);
   void initFromFloat8E4M3FNAPInt(const APInt &api);
+  void initFromFloat8E5M2FZNAPInt(const APInt &api);
+  void initFromFloat8E4M3FZNAPInt(const APInt &api);
 
   void assign(const IEEEFloat &);
   void copySignificand(const IEEEFloat &);
   void freeSignificand();
 
   /// Note: this must be the first data member.
   /// The semantics that this value obeys.
   const fltSemantics *semantics;

llvm/lib/Support/APFloat.cpp

enum class fltNonfiniteBehavior {
 
     // Only the Float8E5M2 has this behavior. There is no Inf representation. A
     // value is NaN if the exponent field and the mantissa field are all 1s.
     // This behavior matches the FP8 E4M3 type described in
     // https://arxiv.org/abs/2209.05433. We treat both signed and unsigned NaNs
     // as non-signalling, although the paper does not state whether the NaN
     // values are signalling or not.
     NanOnly,
+
+    // Float8E5M2FZN and Float8E4M3FZN have this behavior. There is no Inf
+    // representation. A value is NaN if the exponent field and the mantissa
+    // field are all 0s, and sign bit is 1. This behavior matches the FP8 types
+    // described in https://arxiv.org/abs/2206.02915.
+    NanOnlyS1E0M0,
+  };
+
+  // Whether both positive and negative zero or only positive zero are
+  // represented.
+  enum class fltSignedZeroSupport {
+    // Represents standard IEEE 754 behavior. Zero can be both positive and
+    // negative.
+    IEEE754,
+
+    // Float8E5M2FZN and Float8E4M3FZN have this behavior. They only support
+    // positive zero. This behavior matches the FP8 types described in
+    // https://arxiv.org/abs/2206.02915.
+    PositiveOnly,
   };
 
   /* Represents floating point arithmetic semantics.  */
   struct fltSemantics {
     /* The largest E such that 2^E is representable; this matches the
        definition of IEEE 754.  */
     APFloatBase::ExponentType maxExponent;
 
     /* The smallest E such that 2^E is a normalized number; this
        matches the definition of IEEE 754.  */
     APFloatBase::ExponentType minExponent;
 
     /* Number of bits in the significand.  This includes the integer
        bit.  */
     unsigned int precision;
 
     /* Number of bits actually used in the semantics. */
     unsigned int sizeInBits;
 
     fltNonfiniteBehavior nonFiniteBehavior = fltNonfiniteBehavior::IEEE754;
 
+    /* The supported zero encodings. */
+    fltSignedZeroSupport zeroSupport = fltSignedZeroSupport::IEEE754;
+
     // Returns true if any number described by this semantics can be precisely
     // represented by the specified semantics. Does not take into account
     // the value of fltNonfiniteBehavior.
     bool isRepresentableBy(const fltSemantics &S) const {
       return maxExponent <= S.maxExponent && minExponent >= S.minExponent &&
              precision <= S.precision;
     }
   };
 
   static const fltSemantics semIEEEhalf = {15, -14, 11, 16};
   static const fltSemantics semBFloat = {127, -126, 8, 16};
   static const fltSemantics semIEEEsingle = {127, -126, 24, 32};
   static const fltSemantics semIEEEdouble = {1023, -1022, 53, 64};
   static const fltSemantics semIEEEquad = {16383, -16382, 113, 128};
   static const fltSemantics semFloat8E5M2 = {15, -14, 3, 8};
   static const fltSemantics semFloat8E4M3FN = {8, -6, 4, 8,
                                                fltNonfiniteBehavior::NanOnly};
+  static const fltSemantics semFloat8E5M2FZN = {
+      15, -15, 3, 8,
+      fltNonfiniteBehavior::NanOnlyS1E0M0,
+      fltSignedZeroSupport::PositiveOnly};
+  static const fltSemantics semFloat8E4M3FZN = {
+      7, -7, 4, 8,
+      fltNonfiniteBehavior::NanOnlyS1E0M0,
+      fltSignedZeroSupport::PositiveOnly};
   static const fltSemantics semX87DoubleExtended = {16383, -16382, 64, 80};
   static const fltSemantics semBogus = {0, 0, 0, 0};
 
   /* The IBM double-double semantics. Such a number consists of a pair of IEEE
      64-bit doubles (Hi, Lo), where |Hi| > |Lo|, and if normal,
      (double)(Hi + Lo) == Hi. The numeric value it's modeling is Hi + Lo.
      Therefore it has two 53-bit mantissa parts that aren't necessarily adjacent
      to each other, and two 11-bit exponents.
const llvm::fltSemantics &APFloatBase::EnumToSemantics(Semantics S) {
     case S_IEEEquad:
       return IEEEquad();
     case S_PPCDoubleDouble:
       return PPCDoubleDouble();
     case S_Float8E5M2:
       return Float8E5M2();
     case S_Float8E4M3FN:
       return Float8E4M3FN();
+    case S_Float8E5M2FZN:
+      return Float8E5M2FZN();
+    case S_Float8E4M3FZN:
+      return Float8E4M3FZN();
     case S_x87DoubleExtended:
       return x87DoubleExtended();
     }
     llvm_unreachable("Unrecognised floating semantics");
   }
 
   APFloatBase::Semantics
   APFloatBase::SemanticsToEnum(const llvm::fltSemantics &Sem) {
     if (&Sem == &llvm::APFloat::IEEEhalf())
       return S_IEEEhalf;
     else if (&Sem == &llvm::APFloat::BFloat())
       return S_BFloat;
     else if (&Sem == &llvm::APFloat::IEEEsingle())
       return S_IEEEsingle;
     else if (&Sem == &llvm::APFloat::IEEEdouble())
       return S_IEEEdouble;
     else if (&Sem == &llvm::APFloat::IEEEquad())
       return S_IEEEquad;
     else if (&Sem == &llvm::APFloat::PPCDoubleDouble())
       return S_PPCDoubleDouble;
     else if (&Sem == &llvm::APFloat::Float8E5M2())
       return S_Float8E5M2;
     else if (&Sem == &llvm::APFloat::Float8E4M3FN())
       return S_Float8E4M3FN;
+    else if (&Sem == &llvm::APFloat::Float8E5M2FZN())
+      return S_Float8E5M2FZN;
+    else if (&Sem == &llvm::APFloat::Float8E4M3FZN())
+      return S_Float8E4M3FZN;
     else if (&Sem == &llvm::APFloat::x87DoubleExtended())
       return S_x87DoubleExtended;
     else
       llvm_unreachable("Unknown floating semantics");
   }
 
   const fltSemantics &APFloatBase::IEEEhalf() {
     return semIEEEhalf;
   }
   const fltSemantics &APFloatBase::BFloat() {
     return semBFloat;
   }
   const fltSemantics &APFloatBase::IEEEsingle() {
     return semIEEEsingle;
   }
   const fltSemantics &APFloatBase::IEEEdouble() {
     return semIEEEdouble;
   }
   const fltSemantics &APFloatBase::IEEEquad() { return semIEEEquad; }
   const fltSemantics &APFloatBase::PPCDoubleDouble() {
     return semPPCDoubleDouble;
   }
   const fltSemantics &APFloatBase::Float8E5M2() { return semFloat8E5M2; }
   const fltSemantics &APFloatBase::Float8E4M3FN() { return semFloat8E4M3FN; }
+  const fltSemantics &APFloatBase::Float8E5M2FZN() { return semFloat8E5M2FZN; }
+  const fltSemantics &APFloatBase::Float8E4M3FZN() { return semFloat8E4M3FZN; }
   const fltSemantics &APFloatBase::x87DoubleExtended() {
     return semX87DoubleExtended;
   }
   const fltSemantics &APFloatBase::Bogus() { return semBogus; }
 
   constexpr RoundingMode APFloatBase::rmNearestTiesToEven;
   constexpr RoundingMode APFloatBase::rmTowardPositive;
   constexpr RoundingMode APFloatBase::rmTowardNegative;
void IEEEFloat::makeNaN(bool SNaN, bool Negative, const APInt *fill) {
   if (semantics->nonFiniteBehavior == fltNonfiniteBehavior::NanOnly) {
     // The only NaN representation is where the mantissa is all 1s, which is
     // non-signalling.
     SNaN = false;
     fill_storage = APInt::getAllOnes(semantics->precision - 1);
     fill = &fill_storage;
   }
 
+  if (semantics->nonFiniteBehavior == fltNonfiniteBehavior::NanOnlyS1E0M0) {
+    // There is only one valid NaN encoding.
+    sign = 1;
+    *significand = 0;
+    return;
+  }
+
   // Set the significand bits to the fill.
   if (!fill || fill->getNumWords() < numParts)
     APInt::tcSet(significand, 0, numParts);
   if (fill) {
     APInt::tcAssign(significand, fill->getRawData(),
                     std::min(fill->getNumWords(), numParts));
 
     // Zero out the excess bits of the significand.

 /* Handle overflow.  Sign is preserved.  We either become infinity or
    the largest finite number.  */
 IEEEFloat::opStatus IEEEFloat::handleOverflow(roundingMode rounding_mode) {
   /* Infinity?  */
   if (rounding_mode == rmNearestTiesToEven ||
       rounding_mode == rmNearestTiesToAway ||
       (rounding_mode == rmTowardPositive && !sign) ||
       (rounding_mode == rmTowardNegative && sign)) {
-    if (semantics->nonFiniteBehavior == fltNonfiniteBehavior::NanOnly)
+    if (semantics->nonFiniteBehavior == fltNonfiniteBehavior::NanOnly ||
+        semantics->nonFiniteBehavior == fltNonfiniteBehavior::NanOnlyS1E0M0)
       makeNaN(false, sign);
     else
       category = fcInfinity;
     return (opStatus) (opOverflow | opInexact);
   }
 
   /* Otherwise we become the largest finite number.  */
   category = fcNormal;
if (roundAwayFromZero(rounding_mode, lost_fraction, 0)) {
     if (omsb == 0)
       exponent = semantics->minExponent;
 
     incrementSignificand();
     omsb = significandMSB() + 1;
 
     /* Did the significand increment overflow?  */
     if (omsb == (unsigned) semantics->precision + 1) {
+      // NanOnlyS1E0M0 types can't overflow to infinity.
+      if (exponent == semantics->maxExponent &&
+          semantics->nonFiniteBehavior == fltNonfiniteBehavior::NanOnlyS1E0M0) {
+        return handleOverflow(rounding_mode);
+      }
+
       /* Renormalize by incrementing the exponent and shifting our
          significand right one.  However if we already have the
          maximum exponent we overflow to infinity.  */
       if (exponent == semantics->maxExponent) {
         category = fcInfinity;
 
         return (opStatus) (opOverflow | opInexact);
       }
IEEEFloat::opStatus IEEEFloat::divideSpecials(const IEEEFloat &rhs) {
   case PackCategoriesIntoKey(fcZero, fcNormal):
     return opOK;
 
   case PackCategoriesIntoKey(fcNormal, fcInfinity):
     category = fcZero;
     return opOK;
 
   case PackCategoriesIntoKey(fcNormal, fcZero):
-    if (semantics->nonFiniteBehavior == fltNonfiniteBehavior::NanOnly)
+    if (semantics->nonFiniteBehavior == fltNonfiniteBehavior::NanOnly ||
+        semantics->nonFiniteBehavior == fltNonfiniteBehavior::NanOnlyS1E0M0)
       makeNaN(false, sign);
     else
       category = fcInfinity;
     return opDivByZero;
 
   case PackCategoriesIntoKey(fcInfinity, fcInfinity):
   case PackCategoriesIntoKey(fcZero, fcZero):
     makeNaN();
if (exponentChange < 0) {
       exponentChange = omsb + shift - 1; // leave at least one bit set
       shift -= exponentChange;
       exponent += exponentChange;
     }
   }
 
   // If this is a truncation, perform the shift before we narrow the storage.
   if (shift < 0 && (isFiniteNonZero() ||
-                    (category == fcNaN && semantics->nonFiniteBehavior !=
-                                              fltNonfiniteBehavior::NanOnly)))
+                    (category == fcNaN && semantics->nonFiniteBehavior ==
+                                              fltNonfiniteBehavior::IEEE754)))
     lostFraction = shiftRight(significandParts(), oldPartCount, -shift);
 
   // Fix the storage so it can hold to new value.
   if (newPartCount > oldPartCount) {
     // The new type requires more storage; make it available.
     integerPart *newParts;
     newParts = new integerPart[newPartCount];
     APInt::tcSet(newParts, 0, newPartCount);
     if (isFiniteNonZero() || category==fcNaN)
       APInt::tcAssign(newParts, significandParts(), oldPartCount);
     freeSignificand();
     significand.parts = newParts;
   } else if (newPartCount == 1 && oldPartCount != 1) {
     // Switch to built-in storage for a single part.
     integerPart newPart = 0;
     if (isFiniteNonZero() || category==fcNaN)
       newPart = significandParts()[0];
     freeSignificand();
     significand.part = newPart;
   }
 
+  // A bit needs to be set in the significand when converting from a
+  // NanOnlyS1E0M0 encoding, otherwise this will become a -Inf for types that
+  // follow the IEEE-754 convention.
+  if (category == fcNaN &&
+      (fromSemantics.nonFiniteBehavior == fltNonfiniteBehavior::NanOnlyS1E0M0 &&
+       toSemantics.nonFiniteBehavior != fltNonfiniteBehavior::NanOnlyS1E0M0))
+    APInt::tcSetBit(significandParts(), 1);
+
   // Now that we have the right storage, switch the semantics.
   semantics = &toSemantics;
 
   // If this is an extension, perform the shift now that the storage is
   // available.
   if (shift > 0 && (isFiniteNonZero() || category==fcNaN))
     APInt::tcShiftLeft(significandParts(), newPartCount, shift);
 
   if (isFiniteNonZero()) {
     fs = normalize(rounding_mode, lostFraction);
     *losesInfo = (fs != opOK);
   } else if (category == fcNaN) {
-    if (semantics->nonFiniteBehavior == fltNonfiniteBehavior::NanOnly) {
+    if (semantics->nonFiniteBehavior == fltNonfiniteBehavior::NanOnly ||
+        semantics->nonFiniteBehavior == fltNonfiniteBehavior::NanOnlyS1E0M0) {
       *losesInfo =
-          fromSemantics.nonFiniteBehavior != fltNonfiniteBehavior::NanOnly;
+          fromSemantics.nonFiniteBehavior != semantics->nonFiniteBehavior;
       makeNaN(false, sign);
       return is_signaling ? opInvalidOp : opOK;
     }
 
     *losesInfo = lostFraction != lfExactlyZero || X86SpecialNan;
 
     // For x87 extended precision, we want to make a NaN, not a special NaN if
     // the input wasn't special either.
     if (!X86SpecialNan && semantics == &semX87DoubleExtended)
       APInt::tcSetBit(significandParts(), semantics->precision - 1);
 
     // Convert of sNaN creates qNaN and raises an exception (invalid op).
     // This also guarantees that a sNaN does not become Inf on a truncation
     // that loses all payload bits.
     if (is_signaling) {
       makeQuiet();
       fs = opInvalidOp;
     } else {
       fs = opOK;
     }
   } else if (category == fcInfinity &&
-             semantics->nonFiniteBehavior == fltNonfiniteBehavior::NanOnly) {
+             (semantics->nonFiniteBehavior == fltNonfiniteBehavior::NanOnly ||
+              semantics->nonFiniteBehavior ==
+                  fltNonfiniteBehavior::NanOnlyS1E0M0)) {
     makeNaN(false, sign);
     *losesInfo = true;
     fs = opInexact;
   } else {
     *losesInfo = false;
     fs = opOK;
   }
 
if (isFiniteNonZero()) {
     myexponent = 0xf;
     mysignificand = (uint32_t)*significandParts();
   }
 
   return APInt(8, (((sign & 1) << 7) | ((myexponent & 0xf) << 3) |
                    (mysignificand & 0x7)));
 }
 
+APInt IEEEFloat::convertFloat8E5M2FZNAPFloatToAPInt() const {
+  assert(semantics == (const llvm::fltSemantics *)&semFloat8E5M2FZN);
+  assert(partCount() == 1);
+
+  uint32_t mysign, myexponent, mysignificand;
+
+  if (isFiniteNonZero()) {
+    mysign = sign;
+    myexponent = exponent + 16; // bias
+    mysignificand = (uint32_t)*significandParts();
+    if (myexponent == 1 && !(mysignificand & 0x4))
+      myexponent = 0; // denormal
+  } else if (category == fcZero) {
+    mysign = 0;
+    myexponent = 0;
+    mysignificand = 0;
+  } else {
+    assert(category == fcNaN && "Unknown category!");
+    mysign = 1;
+    myexponent = 0;
+    mysignificand = 0;
+  }
+
+  return APInt(8, (((mysign & 1) << 7) | ((myexponent & 0x1f) << 2) |
+                   (mysignificand & 0x3)));
+}
+
+APInt IEEEFloat::convertFloat8E4M3FZNAPFloatToAPInt() const {
+  assert(semantics == (const llvm::fltSemantics *)&semFloat8E4M3FZN);
+  assert(partCount() == 1);
+
+  uint32_t mysign, myexponent, mysignificand;
+
+  if (isFiniteNonZero()) {
+    mysign = sign;
+    myexponent = exponent + 8; // bias
+    mysignificand = (uint32_t)*significandParts();
+    if (myexponent == 1 && !(mysignificand & 0x8))
+      myexponent = 0; // denormal
+  } else if (category == fcZero) {
+    mysign = 0;
+    myexponent = 0;
+    mysignificand = 0;
+  } else {
+    assert(category == fcNaN && "Unknown category!");
+    mysign = 1;
+    myexponent = 0;
+    mysignificand = 0;
+  }
+
+  return APInt(8, (((mysign & 1) << 7) | ((myexponent & 0xf) << 3) |
+                   (mysignificand & 0x7)));
+}
+
 // This function creates an APInt that is just a bit map of the floating
 // point constant as it would appear in memory.  It is not a conversion,
 // and treating the result as a normal integer is unlikely to be useful.
 
 APInt IEEEFloat::bitcastToAPInt() const {
   if (semantics == (const llvm::fltSemantics*)&semIEEEhalf)
     return convertHalfAPFloatToAPInt();
 
if (semantics == (const llvm::fltSemantics *)&semPPCDoubleDoubleLegacy)
     return convertPPCDoubleDoubleAPFloatToAPInt();
 
   if (semantics == (const llvm::fltSemantics *)&semFloat8E5M2)
     return convertFloat8E5M2APFloatToAPInt();
 
   if (semantics == (const llvm::fltSemantics *)&semFloat8E4M3FN)
     return convertFloat8E4M3FNAPFloatToAPInt();
 
+  if (semantics == (const llvm::fltSemantics *)&semFloat8E5M2FZN)
+    return convertFloat8E5M2FZNAPFloatToAPInt();
+
+  if (semantics == (const llvm::fltSemantics *)&semFloat8E4M3FZN)
+    return convertFloat8E4M3FZNAPFloatToAPInt();
+
   assert(semantics == (const llvm::fltSemantics*)&semX87DoubleExtended &&
          "unknown format!");
   return convertF80LongDoubleAPFloatToAPInt();
 }
 
 float IEEEFloat::convertToFloat() const {
   assert(semantics == (const llvm::fltSemantics*)&semIEEEsingle &&
          "Float semantics are not IEEEsingle");
if (myexponent == 0 && mysignificand == 0) {
     *significandParts() = mysignificand;
     if (myexponent == 0) // denormal
       exponent = -6;
     else
       *significandParts() |= 0x8; // integer bit
   }
 }
 
+void IEEEFloat::initFromFloat8E5M2FZNAPInt(const APInt &api) {
+  uint32_t i = (uint32_t)*api.getRawData();
+  uint32_t mysign = (i >> 7) & 1;
+  uint32_t myexponent = (i >> 2) & 0x1f;
+  uint32_t mysignificand = i & 0x3;
+
+  initialize(&semFloat8E5M2FZN);
+  assert(partCount() == 1);
+
+  if (mysign == 0 && myexponent == 0 && mysignificand == 0) {
+    // Negative zero not supported.
+    makeZero(false);
+  } else if (mysign == 1 && myexponent == 0 && mysignificand == 0) {
+    category = fcNaN;
+    sign = 1;
+    exponent = exponentNaN();
+    *significandParts() = mysignificand;
+  } else {
+    category = fcNormal;
+    sign = mysign;
+    exponent = myexponent - 16; // bias
+    *significandParts() = mysignificand;
+
+    if (myexponent == 0) // denormal
+      exponent = -15;
+    else
+      *significandParts() |= 0x4; // integer bit
+  }
+}
+
+void IEEEFloat::initFromFloat8E4M3FZNAPInt(const APInt &api) {
+  uint32_t i = (uint32_t)*api.getRawData();
+  uint32_t mysign = (i >> 7) & 1;
+  uint32_t myexponent = (i >> 3) & 0xf;
+  uint32_t mysignificand = i & 0x7;
+
+  initialize(&semFloat8E4M3FZN);
+  assert(partCount() == 1);
+
+  if (mysign == 0 && myexponent == 0 && mysignificand == 0) {
+    // Negative zero not supported.
+    makeZero(false);
+  } else if (mysign == 1 && myexponent == 0 && mysignificand == 0) {
+    category = fcNaN;
+    sign = 1;
+    exponent = exponentNaN();
+    *significandParts() = mysignificand;
+  } else {
+    category = fcNormal;
+    sign = mysign;
+    exponent = myexponent - 8; // bias
+    *significandParts() = mysignificand;
+
+    if (myexponent == 0) // denormal
+      exponent = -7;
+    else
+      *significandParts() |= 0x8; // integer bit
+  }
+}
+
 /// Treat api as containing the bits of a floating point number.
 void IEEEFloat::initFromAPInt(const fltSemantics *Sem, const APInt &api) {
   assert(api.getBitWidth() == Sem->sizeInBits);
   if (Sem == &semIEEEhalf)
     return initFromHalfAPInt(api);
   if (Sem == &semBFloat)
     return initFromBFloatAPInt(api);
   if (Sem == &semIEEEsingle)
     return initFromFloatAPInt(api);
   if (Sem == &semIEEEdouble)
     return initFromDoubleAPInt(api);
   if (Sem == &semX87DoubleExtended)
     return initFromF80LongDoubleAPInt(api);
   if (Sem == &semIEEEquad)
     return initFromQuadrupleAPInt(api);
   if (Sem == &semPPCDoubleDoubleLegacy)
     return initFromPPCDoubleDoubleAPInt(api);
   if (Sem == &semFloat8E5M2)
     return initFromFloat8E5M2APInt(api);
   if (Sem == &semFloat8E4M3FN)
     return initFromFloat8E4M3FNAPInt(api);
+  if (Sem == &semFloat8E5M2FZN)
+    return initFromFloat8E5M2FZNAPInt(api);
+  if (Sem == &semFloat8E4M3FZN)
+    return initFromFloat8E4M3FZNAPInt(api);
 
   llvm_unreachable(nullptr);
 }
 
 /// Make this number the largest magnitude normal number in the given
 /// semantics.
 void IEEEFloat::makeLargest(bool Negative) {
   // We want (in interchange format):
bool IEEEFloat::getExactInverse(APFloat *inv) const {
   return true;
 }
 
 bool IEEEFloat::isSignaling() const {
   if (!isNaN())
     return false;
   if (semantics->nonFiniteBehavior == fltNonfiniteBehavior::NanOnly)
     return false;
+  if (semantics->nonFiniteBehavior == fltNonfiniteBehavior::NanOnlyS1E0M0)
+    return false;
 
   // IEEE-754R 2008 6.2.1: A signaling NaN bit string should be encoded with the
   // first bit of the trailing significand being 0.
   return !APInt::tcExtractBit(significandParts(), semantics->precision - 2);
 }
 
 /// IEEE-754R 2008 5.3.1: nextUp/nextDown.
 ///
case fcNormal:
     if (isSmallest() && isNegative()) {
       APInt::tcSet(significandParts(), 0, partCount());
       category = fcZero;
       exponent = 0;
       break;
     }
 
     if (isLargest() && !isNegative()) {
-      if (semantics->nonFiniteBehavior == fltNonfiniteBehavior::NanOnly) {
+      if (semantics->nonFiniteBehavior == fltNonfiniteBehavior::NanOnly ||
+          semantics->nonFiniteBehavior == fltNonfiniteBehavior::NanOnlyS1E0M0) {
         // nextUp(getLargest()) == NAN
         makeNaN();
         break;
       } else {
         // nextUp(getLargest()) == INFINITY
         APInt::tcSet(significandParts(), 0, partCount());
         category = fcInfinity;
         exponent = semantics->maxExponent + 1;
if (nextDown)
     changeSign();
 
   return result;
 }
 
 APFloatBase::ExponentType IEEEFloat::exponentNaN() const {
   if (semantics->nonFiniteBehavior == fltNonfiniteBehavior::NanOnly)
     return semantics->maxExponent;
+  if (semantics->nonFiniteBehavior == fltNonfiniteBehavior::NanOnlyS1E0M0)
+    return 0;
   return semantics->maxExponent + 1;
 }
 
 APFloatBase::ExponentType IEEEFloat::exponentInf() const {
   return semantics->maxExponent + 1;
 }
 
 APFloatBase::ExponentType IEEEFloat::exponentZero() const {
   return semantics->minExponent - 1;
 }
 
 void IEEEFloat::makeInf(bool Negative) {
-  if (semantics->nonFiniteBehavior == fltNonfiniteBehavior::NanOnly) {
+  if (semantics->nonFiniteBehavior == fltNonfiniteBehavior::NanOnly ||
+      semantics->nonFiniteBehavior == fltNonfiniteBehavior::NanOnlyS1E0M0) {
     // There is no Inf, so make NaN instead.
     makeNaN(false, Negative);
     return;
   }
   category = fcInfinity;
   sign = Negative;
   exponent = exponentInf();
   APInt::tcSet(significandParts(), 0, partCount());
 }
 
 void IEEEFloat::makeZero(bool Negative) {
+  if (semantics->zeroSupport == fltSignedZeroSupport::PositiveOnly) {
+    Negative = false;
+  }
+
   category = fcZero;
   sign = Negative;
   exponent = exponentZero();
   APInt::tcSet(significandParts(), 0, partCount());
 }
 
 void IEEEFloat::makeQuiet() {
   assert(isNaN());
-  if (semantics->nonFiniteBehavior != fltNonfiniteBehavior::NanOnly)
+  if (semantics->nonFiniteBehavior != fltNonfiniteBehavior::NanOnly &&
+      semantics->nonFiniteBehavior != fltNonfiniteBehavior::NanOnlyS1E0M0)
     APInt::tcSetBit(significandParts(), semantics->precision - 2);
 }
 
 int ilogb(const IEEEFloat &Arg) {
   if (Arg.isNaN())
     return IEEEFloat::IEK_NaN;
   if (Arg.isZero())
     return IEEEFloat::IEK_Zero;

llvm/unittests/ADT/APFloatTest.cpp

llvm::detail::DoubleAPFloat T3(APFloat::PPCDoubleDouble(), std::move(F5),
                                 std::move(F6));
   EXPECT_FALSE(T3.isInteger());
 }
 
 TEST(APFloatTest, getLargest) {
   EXPECT_EQ(3.402823466e+38f, APFloat::getLargest(APFloat::IEEEsingle()).convertToFloat());
   EXPECT_EQ(1.7976931348623158e+308, APFloat::getLargest(APFloat::IEEEdouble()).convertToDouble());
   EXPECT_EQ(448, APFloat::getLargest(APFloat::Float8E4M3FN()).convertToDouble());
+  EXPECT_EQ(57344,
+            APFloat::getLargest(APFloat::Float8E5M2FZN()).convertToDouble());
+  EXPECT_EQ(240,
+            APFloat::getLargest(APFloat::Float8E4M3FZN()).convertToDouble());
 }
 
 TEST(APFloatTest, getSmallest) {
   APFloat test = APFloat::getSmallest(APFloat::IEEEsingle(), false);
   APFloat expected = APFloat(APFloat::IEEEsingle(), "0x0.000002p-126");
   EXPECT_FALSE(test.isNegative());
   EXPECT_TRUE(test.isFiniteNonZero());
   EXPECT_TRUE(test.isDenormal());
const unsigned bitPatternLength;
       {&APFloat::PPCDoubleDouble(), false, {0, 0}, 2},
       {&APFloat::PPCDoubleDouble(), true, {0x8000000000000000ULL, 0}, 2},
       {&APFloat::x87DoubleExtended(), false, {0, 0}, 2},
       {&APFloat::x87DoubleExtended(), true, {0, 0x8000ULL}, 2},
       {&APFloat::Float8E5M2(), false, {0, 0}, 1},
       {&APFloat::Float8E5M2(), true, {0x80ULL, 0}, 1},
       {&APFloat::Float8E4M3FN(), false, {0, 0}, 1},
       {&APFloat::Float8E4M3FN(), true, {0x80ULL, 0}, 1},
+      // Not testing sign = true cases because negative zero isn't supported.
+      {&APFloat::Float8E5M2FZN(), false, {0, 0}, 1},
+      {&APFloat::Float8E4M3FZN(), false, {0, 0}, 1},
   };
-  const unsigned NumGetZeroTests = 12;
-  for (unsigned i = 0; i < NumGetZeroTests; ++i) {
+
+  for (unsigned i = 0; i < std::size(GetZeroTest); ++i) {
     APFloat test = APFloat::getZero(*GetZeroTest[i].semantics,
                                     GetZeroTest[i].sign);
     const char *pattern = GetZeroTest[i].sign? "-0x0p+0" : "0x0p+0";
     APFloat expected = APFloat(*GetZeroTest[i].semantics,
                                pattern);
     EXPECT_TRUE(test.isZero());
     EXPECT_TRUE(GetZeroTest[i].sign? test.isNegative() : !test.isNegative());
     EXPECT_TRUE(test.bitwiseIsEqual(expected));
for (int j = 0; j < 256; j++) {
       z16.remainder(y16);
       z16.convert(APFloat::Float8E4M3FN(), APFloat::rmNearestTiesToEven,
                   &losesInfo);
       EXPECT_TRUE(z.bitwiseIsEqual(z16)) << "i=" << i << ", j=" << j;
     }
   }
 }
 
+TEST(APFloatTest, Float8E4M3FZNFromString) {
+  // Exactly representable
+  EXPECT_EQ(240, APFloat(APFloat::Float8E4M3FZN(), "240").convertToDouble());
+  // Round down to maximum value
+  EXPECT_EQ(240, APFloat(APFloat::Float8E4M3FZN(), "244").convertToDouble());
+  // Round up, causing overflow to NaN
+  EXPECT_TRUE(APFloat(APFloat::Float8E4M3FZN(), "256").isNaN());
+  // Overflow without rounding
+  EXPECT_TRUE(APFloat(APFloat::Float8E4M3FZN(), "480").isNaN());
+  // Inf converted to NaN
+  EXPECT_TRUE(APFloat(APFloat::Float8E4M3FZN(), "inf").isNaN());
+  // NaN converted to NaN
+  EXPECT_TRUE(APFloat(APFloat::Float8E4M3FZN(), "nan").isNaN());
+}
+
+TEST(APFloatTest, Float8E4M3FZNAdd) {
+  APFloat QNaN = APFloat::getNaN(APFloat::Float8E4M3FZN(), false);
+
+  auto FromStr = [](StringRef S) {
+    return APFloat(APFloat::Float8E4M3FZN(), S);
+  };
+
+  struct {
+    APFloat x;
+    APFloat y;
+    const char *result;
+    int status;
+    int category;
+    APFloat::roundingMode roundingMode = APFloat::rmNearestTiesToEven;
+  } AdditionTests[] = {
+      // Test addition operations involving NaN, overflow, and the max E4M3FZN
+      // value (240) because E4M3FZN differs from IEEE-754 types in these
+      // regards
+      {FromStr("240"), FromStr("4"), "240", APFloat::opInexact,
+       APFloat::fcNormal},
+      {FromStr("240"), FromStr("8"), "NaN",
+       APFloat::opOverflow | APFloat::opInexact, APFloat::fcNaN},
+      {FromStr("240"), FromStr("16"), "NaN",
+       APFloat::opOverflow | APFloat::opInexact, APFloat::fcNaN},
+      {FromStr("-240"), FromStr("-16"), "NaN",
+       APFloat::opOverflow | APFloat::opInexact, APFloat::fcNaN},
+      {QNaN, FromStr("-240"), "NaN", APFloat::opOK, APFloat::fcNaN},
+      {FromStr("240"), FromStr("-16"), "224", APFloat::opOK, APFloat::fcNormal},
+      {FromStr("240"), FromStr("0"), "240", APFloat::opOK, APFloat::fcNormal},
+      {FromStr("240"), FromStr("32"), "240", APFloat::opInexact,
+       APFloat::fcNormal, APFloat::rmTowardZero},
+      {FromStr("240"), FromStr("240"), "240", APFloat::opInexact,
+       APFloat::fcNormal, APFloat::rmTowardZero},
+  };
+
+  for (size_t i = 0; i < std::size(AdditionTests); ++i) {
+    APFloat x(AdditionTests[i].x);
+    APFloat y(AdditionTests[i].y);
+    APFloat::opStatus status = x.add(y, AdditionTests[i].roundingMode);
+
+    APFloat result(APFloat::Float8E4M3FZN(), AdditionTests[i].result);
+
+    EXPECT_TRUE(result.bitwiseIsEqual(x));
+    EXPECT_EQ(AdditionTests[i].status, (int)status);
+    EXPECT_EQ(AdditionTests[i].category, (int)x.getCategory());
+  }
+}
+
+TEST(APFloatTest, Float8E4M3FZNDivideByZero) {
+  APFloat x(APFloat::Float8E4M3FZN(), "1");
+  APFloat zero(APFloat::Float8E4M3FZN(), "0");
+  EXPECT_EQ(x.divide(zero, APFloat::rmNearestTiesToEven), APFloat::opDivByZero);
+  EXPECT_TRUE(x.isNaN());
+}
+
+TEST(APFloatTest, Float8E4M3FZNNext) {
+  APFloat test(APFloat::Float8E4M3FZN(), APFloat::uninitialized);
+  APFloat expected(APFloat::Float8E4M3FZN(), APFloat::uninitialized);
+
+  // nextUp on positive numbers
+  for (int i = 0; i < 127; i++) {
+    test = APFloat(APFloat::Float8E4M3FZN(), APInt(8, i));
+    expected = APFloat(APFloat::Float8E4M3FZN(), APInt(8, i + 1));
+    EXPECT_EQ(test.next(false), APFloat::opOK);
+    EXPECT_TRUE(test.bitwiseIsEqual(expected));
+  }
+
+  // nextUp on negative nonzero numbers
+  for (int i = 130; i < 255; i++) {
+    test = APFloat(APFloat::Float8E4M3FZN(), APInt(8, i));
+    expected = APFloat(APFloat::Float8E4M3FZN(), APInt(8, i - 1));
+    EXPECT_EQ(test.next(false), APFloat::opOK);
+    EXPECT_TRUE(test.bitwiseIsEqual(expected)) << i;
+  }
+
+  // nextUp on NaN
+  test = APFloat::getQNaN(APFloat::Float8E4M3FZN(), false);
+  expected = APFloat::getQNaN(APFloat::Float8E4M3FZN(), false);
+  EXPECT_EQ(test.next(false), APFloat::opOK);
+  EXPECT_TRUE(test.bitwiseIsEqual(expected));
+
+  // nextDown on positive nonzero finite numbers
+  for (int i = 1; i < 127; i++) {
+    test = APFloat(APFloat::Float8E4M3FZN(), APInt(8, i));
+    expected = APFloat(APFloat::Float8E4M3FZN(), APInt(8, i - 1));
+    EXPECT_EQ(test.next(true), APFloat::opOK);
+    EXPECT_TRUE(test.bitwiseIsEqual(expected));
+  }
+
+  // nextDown on positive zero
+  test = APFloat::getZero(APFloat::Float8E4M3FZN(), true);
+  expected = APFloat::getSmallest(APFloat::Float8E4M3FZN(), true);
+  EXPECT_EQ(test.next(true), APFloat::opOK);
+  EXPECT_TRUE(test.bitwiseIsEqual(expected));
+
+  // nextDown on negative finite numbers
+  for (int i = 129; i < 255; i++) {
+    test = APFloat(APFloat::Float8E4M3FZN(), APInt(8, i));
+    expected = APFloat(APFloat::Float8E4M3FZN(), APInt(8, i + 1));
+    EXPECT_EQ(test.next(true), APFloat::opOK);
+    EXPECT_TRUE(test.bitwiseIsEqual(expected)) << i;
+  }
+
+  // nextDown on NaN
+  test = APFloat::getQNaN(APFloat::Float8E4M3FZN(), false);
+  expected = APFloat::getQNaN(APFloat::Float8E4M3FZN(), false);
+  EXPECT_EQ(test.next(true), APFloat::opOK);
+  EXPECT_TRUE(test.bitwiseIsEqual(expected));
+}
+
+TEST(APFloatTest, Float8E4M3FZNExhaustive) {
+  // Test each of the 256 Float8E4M3FZN values.
+  for (int i = 0; i < 256; i++) {
+    APFloat test(APFloat::Float8E4M3FZN(), APInt(8, i));
+    SCOPED_TRACE("i=" + std::to_string(i));
+
+    // isLargest
+    if (i == 127 || i == 255) {
+      EXPECT_TRUE(test.isLargest());
+      EXPECT_EQ(abs(test).convertToDouble(), 240.);
+    } else {
+      EXPECT_FALSE(test.isLargest());
+    }
+
+    // isSmallest
+    if (i == 1 || i == 129) {
+      EXPECT_TRUE(test.isSmallest());
+      EXPECT_EQ(abs(test).convertToDouble(), 0x1p-10);
+    } else {
+      EXPECT_FALSE(test.isSmallest());
+    }
+
+    // convert to BFloat
+    APFloat test2 = test;
+    bool loses_info;
+    APFloat::opStatus status = test2.convert(
+        APFloat::BFloat(), APFloat::rmNearestTiesToEven, &loses_info);
+    EXPECT_EQ(status, APFloat::opOK);
+    EXPECT_FALSE(loses_info);
+    if (i == 128)
+      EXPECT_TRUE(test2.isNaN());
+    else
+      EXPECT_EQ(test.convertToFloat(), test2.convertToFloat());
+
+    // bitcastToAPInt
+    EXPECT_EQ(i, test.bitcastToAPInt());
+  }
+}
+
+TEST(APFloatTest, Float8E4M3FZNExhaustivePair) {
+  // Test each pair of Float8E4M3FZN values.
+  for (int i = 0; i < 256; i++) {
+    for (int j = 0; j < 256; j++) {
+      SCOPED_TRACE("i=" + std::to_string(i) + ",j=" + std::to_string(j));
+      APFloat x(APFloat::Float8E4M3FZN(), APInt(8, i));
+      APFloat y(APFloat::Float8E4M3FZN(), APInt(8, j));
+
+      bool losesInfo;
+      APFloat x16 = x;
+      x16.convert(APFloat::IEEEsingle(), APFloat::rmNearestTiesToEven,
+                  &losesInfo);
+      EXPECT_FALSE(losesInfo);
+      APFloat y16 = y;
+      y16.convert(APFloat::IEEEsingle(), APFloat::rmNearestTiesToEven,
+                  &losesInfo);
+      EXPECT_FALSE(losesInfo);
+
+      // Add
+      APFloat z = x;
+      z.add(y, APFloat::rmNearestTiesToEven);
+      APFloat z16 = x16;
+      z16.add(y16, APFloat::rmNearestTiesToEven);
+      z16.convert(APFloat::Float8E4M3FZN(), APFloat::rmNearestTiesToEven,
+                  &losesInfo);
+      EXPECT_TRUE(z.bitwiseIsEqual(z16));
+
+      // Subtract
+      z = x;
+      z.subtract(y, APFloat::rmNearestTiesToEven);
+      z16 = x16;
+      z16.subtract(y16, APFloat::rmNearestTiesToEven);
+      z16.convert(APFloat::Float8E4M3FZN(), APFloat::rmNearestTiesToEven,
+                  &losesInfo);
+      EXPECT_TRUE(z.bitwiseIsEqual(z16));
+
+      // Multiply
+      z = x;
+      z.multiply(y, APFloat::rmNearestTiesToEven);
+      z16 = x16;
+      z16.multiply(y16, APFloat::rmNearestTiesToEven);
+      z16.convert(APFloat::Float8E4M3FZN(), APFloat::rmNearestTiesToEven,
+                  &losesInfo);
+      EXPECT_TRUE(z.bitwiseIsEqual(z16)) << "i=" << i << ", j=" << j;
+
+      // Divide
+      z = x;
+      z.divide(y, APFloat::rmNearestTiesToEven);
+      z16 = x16;
+      z16.divide(y16, APFloat::rmNearestTiesToEven);
+      z16.convert(APFloat::Float8E4M3FZN(), APFloat::rmNearestTiesToEven,
+                  &losesInfo);
+      EXPECT_TRUE(z.bitwiseIsEqual(z16)) << "i=" << i << ", j=" << j;
+
+      // Mod
+      z = x;
+      z.mod(y);
+      z16 = x16;
+      z16.mod(y16);
+      z16.convert(APFloat::Float8E4M3FZN(), APFloat::rmNearestTiesToEven,
+                  &losesInfo);
+      EXPECT_TRUE(z.bitwiseIsEqual(z16)) << "i=" << i << ", j=" << j;
+
+      // Remainder
+      z = x;
+      z.remainder(y);
+      z16 = x16;
+      z16.remainder(y16);
+      z16.convert(APFloat::Float8E4M3FZN(), APFloat::rmNearestTiesToEven,
+                  &losesInfo);
+      EXPECT_TRUE(z.bitwiseIsEqual(z16)) << "i=" << i << ", j=" << j;
+    }
+  }
+}
+
+TEST(APFloatTest, Float8E5M2FZNFromString) {
+  // Exactly representable
+  EXPECT_EQ(57344,
+            APFloat(APFloat::Float8E5M2FZN(), "57344").convertToDouble());
+  // Round down to maximum value
+  EXPECT_EQ(57344,
+            APFloat(APFloat::Float8E5M2FZN(), "59392").convertToDouble());
+  // Round up, causing overflow to NaN
+  EXPECT_TRUE(APFloat(APFloat::Float8E5M2FZN(), "61440").isNaN());
+  // Overflow without rounding
+  EXPECT_TRUE(APFloat(APFloat::Float8E5M2FZN(), "131072").isNaN());
+  // Inf converted to NaN
+  EXPECT_TRUE(APFloat(APFloat::Float8E5M2FZN(), "inf").isNaN());
+  // NaN converted to NaN
+  EXPECT_TRUE(APFloat(APFloat::Float8E5M2FZN(), "nan").isNaN());
+}
+
+TEST(APFloatTest, Float8E5M2FZNAdd) {
+  APFloat QNaN = APFloat::getNaN(APFloat::Float8E5M2FZN(), false);
+
+  auto FromStr = [](StringRef S) {
+    return APFloat(APFloat::Float8E5M2FZN(), S);
+  };
+
+  struct {
+    APFloat x;
+    APFloat y;
+    const char *result;
+    int status;
+    int category;
+    APFloat::roundingMode roundingMode = APFloat::rmNearestTiesToEven;
+  } AdditionTests[] = {
+      // Test addition operations involving NaN, overflow, and the max E5M2FZN
+      // value (57344) because E5M2FZN differs from IEEE-754 types in these
+      // regards
+      {FromStr("57344"), FromStr("2048"), "57344", APFloat::opInexact,
+       APFloat::fcNormal},
+      {FromStr("57344"), FromStr("4096"), "NaN",
+       APFloat::opOverflow | APFloat::opInexact, APFloat::fcNaN},
+      {FromStr("-57344"), FromStr("-4096"), "NaN",
+       APFloat::opOverflow | APFloat::opInexact, APFloat::fcNaN},
+      {QNaN, FromStr("-57344"), "NaN", APFloat::opOK, APFloat::fcNaN},
+      {FromStr("57344"), FromStr("-8192"), "49152", APFloat::opOK,
+       APFloat::fcNormal},
+      {FromStr("57344"), FromStr("0"), "57344", APFloat::opOK,
+       APFloat::fcNormal},
+      {FromStr("57344"), FromStr("4096"), "57344", APFloat::opInexact,
+       APFloat::fcNormal, APFloat::rmTowardZero},
+      {FromStr("57344"), FromStr("57344"), "57344", APFloat::opInexact,
+       APFloat::fcNormal, APFloat::rmTowardZero},
+  };
+
+  for (size_t i = 0; i < std::size(AdditionTests); ++i) {
+    APFloat x(AdditionTests[i].x);
+    APFloat y(AdditionTests[i].y);
+    APFloat::opStatus status = x.add(y, AdditionTests[i].roundingMode);
+
+    APFloat result(APFloat::Float8E5M2FZN(), AdditionTests[i].result);
+
+    EXPECT_TRUE(result.bitwiseIsEqual(x));
+    EXPECT_EQ(AdditionTests[i].status, (int)status);
+    EXPECT_EQ(AdditionTests[i].category, (int)x.getCategory());
+  }
+}
+
+TEST(APFloatTest, Float8E5M2FZNDivideByZero) {
+  APFloat x(APFloat::Float8E5M2FZN(), "1");
+  APFloat zero(APFloat::Float8E5M2FZN(), "0");
+  EXPECT_EQ(x.divide(zero, APFloat::rmNearestTiesToEven), APFloat::opDivByZero);
+  EXPECT_TRUE(x.isNaN());
+}
+
+TEST(APFloatTest, Float8E5M2FZNNext) {
+  APFloat test(APFloat::Float8E5M2FZN(), APFloat::uninitialized);
+  APFloat expected(APFloat::Float8E5M2FZN(), APFloat::uninitialized);
+
+  // nextUp on positive numbers
+  for (int i = 0; i < 127; i++) {
+    test = APFloat(APFloat::Float8E5M2FZN(), APInt(8, i));
+    expected = APFloat(APFloat::Float8E5M2FZN(), APInt(8, i + 1));
+    EXPECT_EQ(test.next(false), APFloat::opOK);
+    EXPECT_TRUE(test.bitwiseIsEqual(expected));
+  }
+
+  // nextUp on negative nonzero numbers
+  for (int i = 130; i < 255; i++) {
+    test = APFloat(APFloat::Float8E5M2FZN(), APInt(8, i));
+    expected = APFloat(APFloat::Float8E5M2FZN(), APInt(8, i - 1));
+    EXPECT_EQ(test.next(false), APFloat::opOK);
+    EXPECT_TRUE(test.bitwiseIsEqual(expected)) << i;
+  }
+
+  // nextUp on NaN
+  test = APFloat::getQNaN(APFloat::Float8E5M2FZN(), false);
+  expected = APFloat::getQNaN(APFloat::Float8E5M2FZN(), false);
+  EXPECT_EQ(test.next(false), APFloat::opOK);
+  EXPECT_TRUE(test.bitwiseIsEqual(expected));
+
+  // nextDown on positive nonzero finite numbers
+  for (int i = 1; i < 127; i++) {
+    test = APFloat(APFloat::Float8E5M2FZN(), APInt(8, i));
+    expected = APFloat(APFloat::Float8E5M2FZN(), APInt(8, i - 1));
+    EXPECT_EQ(test.next(true), APFloat::opOK);
+    EXPECT_TRUE(test.bitwiseIsEqual(expected));
+  }
+
+  // nextDown on positive zero
+  test = APFloat::getZero(APFloat::Float8E5M2FZN(), true);
+  expected = APFloat::getSmallest(APFloat::Float8E5M2FZN(), true);
+  EXPECT_EQ(test.next(true), APFloat::opOK);
+  EXPECT_TRUE(test.bitwiseIsEqual(expected));
+
+  // nextDown on negative finite numbers
+  for (int i = 129; i < 255; i++) {
+    test = APFloat(APFloat::Float8E5M2FZN(), APInt(8, i));
+    expected = APFloat(APFloat::Float8E5M2FZN(), APInt(8, i + 1));
+    EXPECT_EQ(test.next(true), APFloat::opOK);
+    EXPECT_TRUE(test.bitwiseIsEqual(expected)) << i;
+  }
+
+  // nextDown on NaN
+  test = APFloat::getQNaN(APFloat::Float8E5M2FZN(), false);
+  expected = APFloat::getQNaN(APFloat::Float8E5M2FZN(), false);
+  EXPECT_EQ(test.next(true), APFloat::opOK);
+  EXPECT_TRUE(test.bitwiseIsEqual(expected));
+}
+
+TEST(APFloatTest, Float8E5M2FZNExhaustive) {
+  // Test each of the 256 Float8E5M2FZN values.
+  for (int i = 0; i < 256; i++) {
+    APFloat test(APFloat::Float8E5M2FZN(), APInt(8, i));
+    SCOPED_TRACE("i=" + std::to_string(i));
+
+    // isLargest
+    if (i == 127 || i == 255) {
+      EXPECT_TRUE(test.isLargest());
+      EXPECT_EQ(abs(test).convertToDouble(), 57344);
+    } else {
+      EXPECT_FALSE(test.isLargest());
+    }
+
+    // isSmallest
+    if (i == 1 || i == 129) {
+      EXPECT_TRUE(test.isSmallest());
+      EXPECT_EQ(abs(test).convertToDouble(), 0x1p-17);
+    } else {
+      EXPECT_FALSE(test.isSmallest());
+    }
+
+    // convert to BFloat
+    APFloat test2 = test;
+    bool loses_info;
+    APFloat::opStatus status = test2.convert(
+        APFloat::BFloat(), APFloat::rmNearestTiesToEven, &loses_info);
+    EXPECT_EQ(status, APFloat::opOK);
+    EXPECT_FALSE(loses_info);
+    if (i == 128)
+      EXPECT_TRUE(test2.isNaN());
+    else
+      EXPECT_EQ(test.convertToFloat(), test2.convertToFloat());
+
+    // bitcastToAPInt
+    EXPECT_EQ(i, test.bitcastToAPInt());
+  }
+}
+
+TEST(APFloatTest, Float8E5M2FZNExhaustivePair) {
+  // Test each pair of Float8E5M2FZN values.
+  for (int i = 0; i < 256; i++) {
+    for (int j = 0; j < 256; j++) {
+      SCOPED_TRACE("i=" + std::to_string(i) + ",j=" + std::to_string(j));
+      APFloat x(APFloat::Float8E5M2FZN(), APInt(8, i));
+      APFloat y(APFloat::Float8E5M2FZN(), APInt(8, j));
+
+      bool losesInfo;
+      APFloat x16 = x;
+      x16.convert(APFloat::IEEEsingle(), APFloat::rmNearestTiesToEven,
+                  &losesInfo);
+      EXPECT_FALSE(losesInfo);
+      APFloat y16 = y;
+      y16.convert(APFloat::IEEEsingle(), APFloat::rmNearestTiesToEven,
+                  &losesInfo);
+      EXPECT_FALSE(losesInfo);
+
+      // Add
+      APFloat z = x;
+      z.add(y, APFloat::rmNearestTiesToEven);
+      APFloat z16 = x16;
+      z16.add(y16, APFloat::rmNearestTiesToEven);
+      z16.convert(APFloat::Float8E5M2FZN(), APFloat::rmNearestTiesToEven,
+                  &losesInfo);
+      EXPECT_TRUE(z.bitwiseIsEqual(z16));
+
+      // Subtract
+      z = x;
+      z.subtract(y, APFloat::rmNearestTiesToEven);
+      z16 = x16;
+      z16.subtract(y16, APFloat::rmNearestTiesToEven);
+      z16.convert(APFloat::Float8E5M2FZN(), APFloat::rmNearestTiesToEven,
+                  &losesInfo);
+      EXPECT_TRUE(z.bitwiseIsEqual(z16));
+
+      // Multiply
+      z = x;
+      z.multiply(y, APFloat::rmNearestTiesToEven);
+      z16 = x16;
+      z16.multiply(y16, APFloat::rmNearestTiesToEven);
+      z16.convert(APFloat::Float8E5M2FZN(), APFloat::rmNearestTiesToEven,
+                  &losesInfo);
+      EXPECT_TRUE(z.bitwiseIsEqual(z16)) << "i=" << i << ", j=" << j;
+
+      // Divide
+      z = x;
+      z.divide(y, APFloat::rmNearestTiesToEven);
+      z16 = x16;
+      z16.divide(y16, APFloat::rmNearestTiesToEven);
+      z16.convert(APFloat::Float8E5M2FZN(), APFloat::rmNearestTiesToEven,
+                  &losesInfo);
+      EXPECT_TRUE(z.bitwiseIsEqual(z16)) << "i=" << i << ", j=" << j;
+
+      // Mod
+      z = x;
+      z.mod(y);
+      z16 = x16;
+      z16.mod(y16);
+      z16.convert(APFloat::Float8E5M2FZN(), APFloat::rmNearestTiesToEven,
+                  &losesInfo);
+      EXPECT_TRUE(z.bitwiseIsEqual(z16)) << "i=" << i << ", j=" << j;
+
+      // Remainder
+      z = x;
+      z.remainder(y);
+      z16 = x16;
+      z16.remainder(y16);
+      z16.convert(APFloat::Float8E5M2FZN(), APFloat::rmNearestTiesToEven,
+                  &losesInfo);
+      EXPECT_TRUE(z.bitwiseIsEqual(z16)) << "i=" << i << ", j=" << j;
+    }
+  }
+}
+
 TEST(APFloatTest, F8ToString) {
   for (APFloat::Semantics S :
-       {APFloat::S_Float8E5M2, APFloat::S_Float8E4M3FN}) {
+       {APFloat::S_Float8E5M2, APFloat::S_Float8E4M3FN,
+        APFloat::S_Float8E5M2FZN, APFloat::S_Float8E4M3FZN}) {
     SCOPED_TRACE("Semantics=" + std::to_string(S));
     for (int i = 0; i < 256; i++) {
       SCOPED_TRACE("i=" + std::to_string(i));
-      APFloat test(APFloat::Float8E5M2(), APInt(8, i));
+      APFloat test(APFloat::EnumToSemantics(S), APInt(8, i));
       llvm::SmallString<128> str;
       test.toString(str);
 
       if (test.isNaN()) {
         EXPECT_EQ(str, "NaN");
       } else {
-        APFloat test2(APFloat::Float8E5M2(), str);
+        APFloat test2(APFloat::EnumToSemantics(S), str);
         EXPECT_TRUE(test.bitwiseIsEqual(test2));
       }
     }
   }
 }
 
 TEST(APFloatTest, IEEEdoubleToDouble) {
   APFloat DPosZero(0.0);
TEST(APFloatTest, Float8E4M3FNToDouble) {
   APFloat SmallestDenorm = APFloat::getSmallest(APFloat::Float8E4M3FN(), false);
   EXPECT_TRUE(SmallestDenorm.isDenormal());
   EXPECT_EQ(0x1p-9, SmallestDenorm.convertToDouble());
 
   APFloat QNaN = APFloat::getQNaN(APFloat::Float8E4M3FN());
   EXPECT_TRUE(std::isnan(QNaN.convertToDouble()));
 }
 
+TEST(APFloatTest, Float8E5M2FZNToDouble) {
+  APFloat One(APFloat::Float8E5M2FZN(), "1.0");
+  EXPECT_EQ(1.0, One.convertToDouble());
+  APFloat Two(APFloat::Float8E5M2FZN(), "2.0");
+  EXPECT_EQ(2.0, Two.convertToDouble());
+  APFloat PosLargest = APFloat::getLargest(APFloat::Float8E5M2FZN(), false);
+  EXPECT_EQ(57344., PosLargest.convertToDouble());
+  APFloat NegLargest = APFloat::getLargest(APFloat::Float8E5M2FZN(), true);
+  EXPECT_EQ(-57344., NegLargest.convertToDouble());
+  APFloat PosSmallest =
+      APFloat::getSmallestNormalized(APFloat::Float8E5M2FZN(), false);
+  EXPECT_EQ(0x1.p-15, PosSmallest.convertToDouble());
+  APFloat NegSmallest =
+      APFloat::getSmallestNormalized(APFloat::Float8E5M2FZN(), true);
+  EXPECT_EQ(-0x1.p-15, NegSmallest.convertToDouble());
+
+  APFloat SmallestDenorm =
+      APFloat::getSmallest(APFloat::Float8E5M2FZN(), false);
+  EXPECT_TRUE(SmallestDenorm.isDenormal());
+  EXPECT_EQ(0x1p-17, SmallestDenorm.convertToDouble());
+
+  APFloat QNaN = APFloat::getQNaN(APFloat::Float8E5M2FZN());
+  EXPECT_TRUE(std::isnan(QNaN.convertToDouble()));
+}
+
+TEST(APFloatTest, Float8E4M3FZNToDouble) {
+  APFloat One(APFloat::Float8E4M3FZN(), "1.0");
+  EXPECT_EQ(1.0, One.convertToDouble());
+  APFloat Two(APFloat::Float8E4M3FZN(), "2.0");
+  EXPECT_EQ(2.0, Two.convertToDouble());
+  APFloat PosLargest = APFloat::getLargest(APFloat::Float8E4M3FZN(), false);
+  EXPECT_EQ(240., PosLargest.convertToDouble());
+  APFloat NegLargest = APFloat::getLargest(APFloat::Float8E4M3FZN(), true);
+  EXPECT_EQ(-240., NegLargest.convertToDouble());
+  APFloat PosSmallest =
+      APFloat::getSmallestNormalized(APFloat::Float8E4M3FZN(), false);
+  EXPECT_EQ(0x1.p-7, PosSmallest.convertToDouble());
+  APFloat NegSmallest =
+      APFloat::getSmallestNormalized(APFloat::Float8E4M3FZN(), true);
+  EXPECT_EQ(-0x1.p-7, NegSmallest.convertToDouble());
+
+  APFloat SmallestDenorm =
+      APFloat::getSmallest(APFloat::Float8E4M3FZN(), false);
+  EXPECT_TRUE(SmallestDenorm.isDenormal());
+  EXPECT_EQ(0x1p-10, SmallestDenorm.convertToDouble());
+
+  APFloat QNaN = APFloat::getQNaN(APFloat::Float8E4M3FZN());
+  EXPECT_TRUE(std::isnan(QNaN.convertToDouble()));
+}
+
 TEST(APFloatTest, IEEEsingleToFloat) {
   APFloat FPosZero(0.0F);
   APFloat FPosZeroToFloat(FPosZero.convertToFloat());
   EXPECT_TRUE(FPosZeroToFloat.isPosZero());
   APFloat FNegZero(-0.0F);
   APFloat FNegZeroToFloat(FNegZero.convertToFloat());
   EXPECT_TRUE(FNegZeroToFloat.isNegZero());
 
TEST(APFloatTest, Float8E4M3FNToFloat) {
   APFloat SmallestDenorm = APFloat::getSmallest(APFloat::Float8E4M3FN(), false);
   EXPECT_TRUE(SmallestDenorm.isDenormal());
   EXPECT_EQ(0x1.p-9, SmallestDenorm.convertToFloat());
 
   APFloat QNaN = APFloat::getQNaN(APFloat::Float8E4M3FN());
   EXPECT_TRUE(std::isnan(QNaN.convertToFloat()));
 }
 
+TEST(APFloatTest, Float8E5M2FZNToFloat) {
+  APFloat PosZero = APFloat::getZero(APFloat::Float8E5M2FZN());
+  APFloat PosZeroToFloat(PosZero.convertToFloat());
+  EXPECT_TRUE(PosZeroToFloat.isPosZero());
+
+  // Negative zero is not supported
+  APFloat NegZero = APFloat::getZero(APFloat::Float8E5M2FZN(), true);
+  APFloat NegZeroToFloat(NegZero.convertToFloat());
+  EXPECT_TRUE(NegZeroToFloat.isPosZero());
+
+  APFloat One(APFloat::Float8E5M2FZN(), "1.0");
+  EXPECT_EQ(1.0F, One.convertToFloat());
+  APFloat Two(APFloat::Float8E5M2FZN(), "2.0");
+  EXPECT_EQ(2.0F, Two.convertToFloat());
+
+  APFloat PosLargest = APFloat::getLargest(APFloat::Float8E5M2FZN(), false);
+  EXPECT_EQ(57344., PosLargest.convertToFloat());
+  APFloat NegLargest = APFloat::getLargest(APFloat::Float8E5M2FZN(), true);
+  EXPECT_EQ(-57344., NegLargest.convertToFloat());
+  APFloat PosSmallest =
+      APFloat::getSmallestNormalized(APFloat::Float8E5M2FZN(), false);
+  EXPECT_EQ(0x1.p-15, PosSmallest.convertToFloat());
+  APFloat NegSmallest =
+      APFloat::getSmallestNormalized(APFloat::Float8E5M2FZN(), true);
+  EXPECT_EQ(-0x1.p-15, NegSmallest.convertToFloat());
+
+  APFloat SmallestDenorm =
+      APFloat::getSmallest(APFloat::Float8E5M2FZN(), false);
+  EXPECT_TRUE(SmallestDenorm.isDenormal());
+  EXPECT_EQ(0x1.p-17, SmallestDenorm.convertToFloat());
+
+  APFloat QNaN = APFloat::getQNaN(APFloat::Float8E5M2FZN());
+  EXPECT_TRUE(std::isnan(QNaN.convertToFloat()));
+}
+
+TEST(APFloatTest, Float8E4M3FZNToFloat) {
+  APFloat PosZero = APFloat::getZero(APFloat::Float8E4M3FZN());
+  APFloat PosZeroToFloat(PosZero.convertToFloat());
+  EXPECT_TRUE(PosZeroToFloat.isPosZero());
+
+  // No negative zero
+  APFloat NegZero = APFloat::getZero(APFloat::Float8E4M3FZN(), true);
+  APFloat NegZeroToFloat(NegZero.convertToFloat());
+  EXPECT_TRUE(NegZeroToFloat.isPosZero());
+
+  APFloat One(APFloat::Float8E4M3FZN(), "1.0");
+  EXPECT_EQ(1.0F, One.convertToFloat());
+  APFloat Two(APFloat::Float8E4M3FZN(), "2.0");
+  EXPECT_EQ(2.0F, Two.convertToFloat());
+
+  APFloat PosLargest = APFloat::getLargest(APFloat::Float8E4M3FZN(), false);
+  EXPECT_EQ(240., PosLargest.convertToFloat());
+  APFloat NegLargest = APFloat::getLargest(APFloat::Float8E4M3FZN(), true);
+  EXPECT_EQ(-240, NegLargest.convertToFloat());
+  APFloat PosSmallest =
+      APFloat::getSmallestNormalized(APFloat::Float8E4M3FZN(), false);
+  EXPECT_EQ(0x1.p-7, PosSmallest.convertToFloat());
+  APFloat NegSmallest =
+      APFloat::getSmallestNormalized(APFloat::Float8E4M3FZN(), true);
+  EXPECT_EQ(-0x1.p-7, NegSmallest.convertToFloat());
+
+  APFloat SmallestDenorm =
+      APFloat::getSmallest(APFloat::Float8E4M3FZN(), false);
+  EXPECT_TRUE(SmallestDenorm.isDenormal());
+  EXPECT_EQ(0x1.p-10, SmallestDenorm.convertToFloat());
+
+  APFloat QNaN = APFloat::getQNaN(APFloat::Float8E4M3FZN());
+  EXPECT_TRUE(std::isnan(QNaN.convertToFloat()));
+}
+
 } // namespace

mlir/include/mlir-c/BuiltinTypes.h

 
 /// Checks whether the given type is an f8E4M3FN type.
 MLIR_CAPI_EXPORTED bool mlirTypeIsAFloat8E4M3FN(MlirType type);
 
 /// Creates an f8E4M3FN type in the given context. The type is owned by the
 /// context.
 MLIR_CAPI_EXPORTED MlirType mlirFloat8E4M3FNTypeGet(MlirContext ctx);
 
+/// Checks whether the given type is an f8E4M3FZN type.
+MLIR_CAPI_EXPORTED bool mlirTypeIsAFloat8E4M3FZN(MlirType type);
+
+/// Creates an f8E4M3FZN type in the given context. The type is owned by the
+/// context.
+MLIR_CAPI_EXPORTED MlirType mlirFloat8E4M3FZNTypeGet(MlirContext ctx);
+
+/// Checks whether the given type is an f8E5M2FZN type.
+MLIR_CAPI_EXPORTED bool mlirTypeIsAFloat8E5M2FZN(MlirType type);
+
+/// Creates an f8E5M2FZN type in the given context. The type is owned by the
+/// context.
+MLIR_CAPI_EXPORTED MlirType mlirFloat8E5M2FZNTypeGet(MlirContext ctx);
+
 /// Checks whether the given type is a bf16 type.
 MLIR_CAPI_EXPORTED bool mlirTypeIsABF16(MlirType type);
 
 /// Creates a bf16 type in the given context. The type is owned by the
 /// context.
 MLIR_CAPI_EXPORTED MlirType mlirBF16TypeGet(MlirContext ctx);
 
 /// Checks whether the given type is an f16 type.

mlir/include/mlir/IR/Builders.h

public:
   // Locations.
   Location getUnknownLoc();
   Location getFusedLoc(ArrayRef<Location> locs,
                        Attribute metadata = Attribute());
 
   // Types.
   FloatType getFloat8E5M2Type();
   FloatType getFloat8E4M3FNType();
+  FloatType getFloat8E4M3FZNType();
+  FloatType getFloat8E5M2FZNType();
   FloatType getBF16Type();
   FloatType getF16Type();
   FloatType getF32Type();
   FloatType getF64Type();
   FloatType getF80Type();
   FloatType getF128Type();
 
   IndexType getIndexType();

mlir/include/mlir/IR/BuiltinTypes.h

public:
   static FloatType getBF16(MLIRContext *ctx);
   static FloatType getF16(MLIRContext *ctx);
   static FloatType getF32(MLIRContext *ctx);
   static FloatType getF64(MLIRContext *ctx);
   static FloatType getF80(MLIRContext *ctx);
   static FloatType getF128(MLIRContext *ctx);
   static FloatType getFloat8E5M2(MLIRContext *ctx);
   static FloatType getFloat8E4M3FN(MLIRContext *ctx);
+  static FloatType getFloat8E4M3FZN(MLIRContext *ctx);
+  static FloatType getFloat8E5M2FZN(MLIRContext *ctx);
 
   /// Methods for support type inquiry through isa, cast, and dyn_cast.
   static bool classof(Type type);
 
   /// Return the bitwidth of this float type.
   unsigned getWidth();
 
   /// Return the width of the mantissa of this type.

 
 inline bool BaseMemRefType::isValidElementType(Type type) {
   return type.isIntOrIndexOrFloat() ||
          type.isa<ComplexType, MemRefType, VectorType, UnrankedMemRefType>() ||
          type.isa<MemRefElementTypeInterface>();
 }
 
 inline bool FloatType::classof(Type type) {
-  return type.isa<Float8E5M2Type, Float8E4M3FNType, BFloat16Type, Float16Type,
-                  Float32Type, Float64Type, Float80Type, Float128Type>();
+  return type.isa<Float8E5M2Type, Float8E4M3FNType, Float8E4M3FZNType,
+                  Float8E5M2FZNType, BFloat16Type, Float16Type, Float32Type,
+                  Float64Type, Float80Type, Float128Type>();
 }
 
 inline FloatType FloatType::getFloat8E5M2(MLIRContext *ctx) {
   return Float8E5M2Type::get(ctx);
 }
 
 inline FloatType FloatType::getFloat8E4M3FN(MLIRContext *ctx) {
   return Float8E4M3FNType::get(ctx);
 }
 
+inline FloatType FloatType::getFloat8E4M3FZN(MLIRContext *ctx) {
+  return Float8E4M3FZNType::get(ctx);
+}
+
+inline FloatType FloatType::getFloat8E5M2FZN(MLIRContext *ctx) {
+  return Float8E5M2FZNType::get(ctx);
+}
+
 inline FloatType FloatType::getBF16(MLIRContext *ctx) {
   return BFloat16Type::get(ctx);
 }
 
 inline FloatType FloatType::getF16(MLIRContext *ctx) {
   return Float16Type::get(ctx);
 }
 

mlir/include/mlir/IR/BuiltinTypes.td

characteristics:
       * NaNs: supported with exponent bits and mantissa bits set to all 1s
       * denormals when exponent is 0
 
     Described in: https://arxiv.org/abs/2209.05433
   }];
 }
 
 //===----------------------------------------------------------------------===//
+// Float8E4M3FZNType
+
+def Builtin_Float8E4M3FZN : Builtin_FloatType<"Float8E4M3FZN"> {
+  let summary = "8-bit floating point with 3 bit mantissa";
+  let description = [{
+    An 8-bit floating point type with 1 sign bit, 4 bits exponent and 3 bits
+    mantissa. This is not a standard type as defined by IEEE-754, but it follows
+    similar conventions, with the exception that there are no infinity values,
+    no negative zero, and only one NaN representation. This type has the
+    following characteristics:
+
+      * bit encoding: S1E4M3
+      * exponent bias: 8
+      * infinities: Not supported
+      * NaNs: Supported with sign bit set to 1, exponent bits and mantissa bits set to all 0s
+      * denormals when exponent is 0
+
+    Described in: https://arxiv.org/abs/2209.05433
+  }];
+}
+
+//===----------------------------------------------------------------------===//
+// Float8E5M2FZNType
+
+def Builtin_Float8E5M2FZN : Builtin_FloatType<"Float8E5M2FZN"> {
+  let summary = "8-bit floating point with 2 bit mantissa";
+  let description = [{
+    An 8-bit floating point type with 1 sign bit, 5 bits exponent and 2 bits
+    mantissa. This is not a standard type as defined by IEEE-754, but it follows
+    similar conventions, with the exception that there are no infinity values,
+    no negative zero, and only one NaN representation. This type has the
+    following characteristics:
+
+      * bit encoding: S1E5M2
+      * exponent bias: 16
+      * infinities: Not supported
+      * NaNs: Supported with sign bit set to 1, exponent bits and mantissa bits set to all 0s
+      * denormals when exponent is 0
+
+    Described in: https://arxiv.org/abs/2206.02915
+  }];
+}
+
+//===----------------------------------------------------------------------===//
 // BFloat16Type
 
 def Builtin_BFloat16 : Builtin_FloatType<"BFloat16"> {
   let summary = "bfloat16 floating-point type";
 }
 
 //===----------------------------------------------------------------------===//
 // Float16Type

mlir/include/mlir/IR/OpBase.td

 def F128 : F<128>;
 
 def BF16 : Type<CPred<"$_self.isBF16()">, "bfloat16 type">,
            BuildableType<"$_builder.getBF16Type()">;
 def F8E4M3FN : Type<CPred<"$_self.isFloat8E4M3FN()">, "f8E4M3FN type">,
                BuildableType<"$_builder.getFloat8E4M3FNType()">;
 def F8E5M2 : Type<CPred<"$_self.isFloat8E5M2()">, "f8E5M2 type">,
              BuildableType<"$_builder.getFloat8E5M2Type()">;
+def F8E4M3FZN : Type<CPred<"$_self.isFloat8E4M3FZN()">, "f8E4M3FZN type">,
+                BuildableType<"$_builder.getFloat8E4M3FZNType()">;
+def F8E5M2FZN : Type<CPred<"$_self.isFloat8E5M2FZN()">, "f8E5M2FZN type">,
+                BuildableType<"$_builder.getFloat8E5M2FZNType()">;
 
 def AnyComplex : Type<CPred<"$_self.isa<::mlir::ComplexType>()">,
                       "complex-type", "::mlir::ComplexType">;
 
 class Complex<Type type>
     : ConfinedType<AnyComplex, [
           SubstLeaves<"$_self",
                       "$_self.cast<::mlir::ComplexType>().getElementType()",

mlir/include/mlir/IR/Types.h

public:
   /// Get the dialect this type is registered to.
   Dialect &getDialect() const { return impl->getAbstractType().getDialect(); }
 
   // Convenience predicates.  This is only for floating point types,
   // derived types should use isa/dyn_cast.
   bool isIndex() const;
   bool isFloat8E5M2() const;
   bool isFloat8E4M3FN() const;
+  bool isFloat8E4M3FZN() const;
+  bool isFloat8E5M2FZN() const;
   bool isBF16() const;
   bool isF16() const;
   bool isF32() const;
   bool isF64() const;
   bool isF80() const;
   bool isF128() const;
 
   /// Return true if this is an integer type with the specified width.

mlir/lib/AsmParser/TokenKinds.def

 TOK_KEYWORD(dense)
 TOK_KEYWORD(dense_resource)
 TOK_KEYWORD(f16)
 TOK_KEYWORD(f32)
 TOK_KEYWORD(f64)
 TOK_KEYWORD(f80)
 TOK_KEYWORD(f8E5M2)
 TOK_KEYWORD(f8E4M3FN)
+TOK_KEYWORD(f8E4M3FZN)
+TOK_KEYWORD(f8E5M2FZN)
 TOK_KEYWORD(f128)
 TOK_KEYWORD(false)
 TOK_KEYWORD(floordiv)
 TOK_KEYWORD(for)
 TOK_KEYWORD(func)
 TOK_KEYWORD(index)
 TOK_KEYWORD(loc)
 TOK_KEYWORD(max)

mlir/lib/AsmParser/TypeParser.cpp

OptionalParseResult Parser::parseOptionalType(Type &type) {
   case Token::kw_memref:
   case Token::kw_tensor:
   case Token::kw_complex:
   case Token::kw_tuple:
   case Token::kw_vector:
   case Token::inttype:
   case Token::kw_f8E5M2:
   case Token::kw_f8E4M3FN:
+  case Token::kw_f8E4M3FZN:
+  case Token::kw_f8E5M2FZN:
   case Token::kw_bf16:
   case Token::kw_f16:
   case Token::kw_f32:
   case Token::kw_f64:
   case Token::kw_f80:
   case Token::kw_f128:
   case Token::kw_index:
   case Token::kw_none:
Type Parser::parseNonFunctionType() {
 
   // float-type
   case Token::kw_f8E5M2:
     consumeToken(Token::kw_f8E5M2);
     return builder.getFloat8E5M2Type();
   case Token::kw_f8E4M3FN:
     consumeToken(Token::kw_f8E4M3FN);
     return builder.getFloat8E4M3FNType();
+  case Token::kw_f8E4M3FZN:
+    consumeToken(Token::kw_f8E4M3FZN);
+    return builder.getFloat8E4M3FZNType();
+  case Token::kw_f8E5M2FZN:
+    consumeToken(Token::kw_f8E5M2FZN);
+    return builder.getFloat8E5M2FZNType();
   case Token::kw_bf16:
     consumeToken(Token::kw_bf16);
     return builder.getBF16Type();
   case Token::kw_f16:
     consumeToken(Token::kw_f16);
     return builder.getF16Type();
   case Token::kw_f32:
     consumeToken(Token::kw_f32);

mlir/lib/Bindings/Python/IRTypes.cpp

c.def_static(
         [](DefaultingPyMlirContext context) {
           MlirType t = mlirFloat8E5M2TypeGet(context->get());
           return PyFloat8E5M2Type(context->getRef(), t);
         },
         py::arg("context") = py::none(), "Create a float8_e5m2 type.");
   }
 };
 
+/// Floating Point Type subclass - Float8E4M3FZN.
+class PyFloat8E4M3FZNType : public PyConcreteType<PyFloat8E4M3FZNType> {
+public:
+  static constexpr IsAFunctionTy isaFunction = mlirTypeIsAFloat8E4M3FZN;
+  static constexpr const char *pyClassName = "Float8E4M3FZNType";
+  using PyConcreteType::PyConcreteType;
+
+  static void bindDerived(ClassTy &c) {
+    c.def_static(
+        "get",
+        [](DefaultingPyMlirContext context) {
+          MlirType t = mlirFloat8E4M3FZNTypeGet(context->get());
+          return PyFloat8E4M3FZNType(context->getRef(), t);
+        },
+        py::arg("context") = py::none(), "Create a f8e4m3fnz type.");
+  }
+};
+
+/// Floating Point Type subclass - Float8E5M2FZN.
+class PyFloat8E5M2FZNType : public PyConcreteType<PyFloat8E5M2FZNType> {
+public:
+  static constexpr IsAFunctionTy isaFunction = mlirTypeIsAFloat8E5M2FZN;
+  static constexpr const char *pyClassName = "Float8E5M2FZNType";
+  using PyConcreteType::PyConcreteType;
+
+  static void bindDerived(ClassTy &c) {
+    c.def_static(
+        "get",
+        [](DefaultingPyMlirContext context) {
+          MlirType t = mlirFloat8E5M2FZNTypeGet(context->get());
+          return PyFloat8E5M2FZNType(context->getRef(), t);
+        },
+        py::arg("context") = py::none(), "Create a f8e5m2fnz type.");
+  }
+};
+
 /// Floating Point Type subclass - BF16Type.
 class PyBF16Type : public PyConcreteType<PyBF16Type> {
 public:
   static constexpr IsAFunctionTy isaFunction = mlirTypeIsABF16;
   static constexpr const char *pyClassName = "BF16Type";
   using PyConcreteType::PyConcreteType;
 
   static void bindDerived(ClassTy &c) {

 
 } // namespace
 
 void mlir::python::populateIRTypes(py::module &m) {
   PyIntegerType::bind(m);
   PyIndexType::bind(m);
   PyFloat8E4M3FNType::bind(m);
   PyFloat8E5M2Type::bind(m);
+  PyFloat8E4M3FZNType::bind(m);
+  PyFloat8E5M2FZNType::bind(m);
   PyBF16Type::bind(m);
   PyF16Type::bind(m);
   PyF32Type::bind(m);
   PyF64Type::bind(m);
   PyNoneType::bind(m);
   PyComplexType::bind(m);
   PyShapedType::bind(m);
   PyVectorType::bind(m);
   PyRankedTensorType::bind(m);
   PyUnrankedTensorType::bind(m);
   PyMemRefType::bind(m);
   PyUnrankedMemRefType::bind(m);
   PyTupleType::bind(m);
   PyFunctionType::bind(m);
   PyOpaqueType::bind(m);
 }

mlir/lib/CAPI/IR/BuiltinTypes.cpp

 bool mlirTypeIsAFloat8E4M3FN(MlirType type) {
   return unwrap(type).isFloat8E4M3FN();
 }
 
 MlirType mlirFloat8E4M3FNTypeGet(MlirContext ctx) {
   return wrap(FloatType::getFloat8E4M3FN(unwrap(ctx)));
 }
 
+bool mlirTypeIsAFloat8E4M3FZN(MlirType type) {
+  return unwrap(type).isFloat8E4M3FZN();
+}
+
+MlirType mlirFloat8E4M3FZNTypeGet(MlirContext ctx) {
+  return wrap(FloatType::getFloat8E4M3FZN(unwrap(ctx)));
+}
+
+bool mlirTypeIsAFloat8E5M2FZN(MlirType type) {
+  return unwrap(type).isFloat8E5M2FZN();
+}
+
+MlirType mlirFloat8E5M2FZNTypeGet(MlirContext ctx) {
+  return wrap(FloatType::getFloat8E5M2FZN(unwrap(ctx)));
+}
+
 bool mlirTypeIsABF16(MlirType type) { return unwrap(type).isBF16(); }
 
 MlirType mlirBF16TypeGet(MlirContext ctx) {
   return wrap(FloatType::getBF16(unwrap(ctx)));
 }
 
 bool mlirTypeIsAF16(MlirType type) { return unwrap(type).isF16(); }
 

mlir/lib/IR/AsmPrinter.cpp

void AsmPrinter::Impl::printTypeImpl(Type type) {
   TypeSwitch<Type>(type)
       .Case<OpaqueType>([&](OpaqueType opaqueTy) {
         printDialectSymbol(os, "!", opaqueTy.getDialectNamespace(),
                            opaqueTy.getTypeData());
       })
       .Case<IndexType>([&](Type) { os << "index"; })
       .Case<Float8E5M2Type>([&](Type) { os << "f8E5M2"; })
       .Case<Float8E4M3FNType>([&](Type) { os << "f8E4M3FN"; })
+      .Case<Float8E4M3FZNType>([&](Type) { os << "f8E4M3FZN"; })
+      .Case<Float8E5M2FZNType>([&](Type) { os << "f8E5M2FZN"; })
       .Case<BFloat16Type>([&](Type) { os << "bf16"; })
       .Case<Float16Type>([&](Type) { os << "f16"; })
       .Case<Float32Type>([&](Type) { os << "f32"; })
       .Case<Float64Type>([&](Type) { os << "f64"; })
       .Case<Float80Type>([&](Type) { os << "f80"; })
       .Case<Float128Type>([&](Type) { os << "f128"; })
       .Case<IntegerType>([&](IntegerType integerTy) {
         if (integerTy.isSigned())

mlir/lib/IR/Builders.cpp

 FloatType Builder::getFloat8E5M2Type() {
   return FloatType::getFloat8E5M2(context);
 }
 
 FloatType Builder::getFloat8E4M3FNType() {
   return FloatType::getFloat8E4M3FN(context);
 }
 
+FloatType Builder::getFloat8E4M3FZNType() {
+  return FloatType::getFloat8E4M3FZN(context);
+}
+
+FloatType Builder::getFloat8E5M2FZNType() {
+  return FloatType::getFloat8E5M2FZN(context);
+}
+
 FloatType Builder::getBF16Type() { return FloatType::getBF16(context); }
 
 FloatType Builder::getF16Type() { return FloatType::getF16(context); }
 
 FloatType Builder::getF32Type() { return FloatType::getF32(context); }
 
 FloatType Builder::getF64Type() { return FloatType::getF64(context); }
 

mlir/lib/IR/BuiltinTypes.cpp

IntegerType IntegerType::scaleElementBitwidth(unsigned scale) {
   return IntegerType::get(getContext(), scale * getWidth(), getSignedness());
 }
 
 //===----------------------------------------------------------------------===//
 // Float Type
 //===----------------------------------------------------------------------===//
 
 unsigned FloatType::getWidth() {
-  if (isa<Float8E5M2Type, Float8E4M3FNType>())
+  if (isa<Float8E5M2Type, Float8E4M3FNType, Float8E4M3FZNType,
+          Float8E5M2FZNType>())
     return 8;
   if (isa<Float16Type, BFloat16Type>())
     return 16;
   if (isa<Float32Type>())
     return 32;
   if (isa<Float64Type>())
     return 64;
   if (isa<Float80Type>())
     return 80;
   if (isa<Float128Type>())
     return 128;
   llvm_unreachable("unexpected float type");
 }
 
 /// Returns the floating semantics for the given type.
 const llvm::fltSemantics &FloatType::getFloatSemantics() {
   if (isa<Float8E5M2Type>())
     return APFloat::Float8E5M2();
   if (isa<Float8E4M3FNType>())
     return APFloat::Float8E4M3FN();
+  if (isa<Float8E4M3FZNType>())
+    return APFloat::Float8E4M3FZN();
+  if (isa<Float8E5M2FZNType>())
+    return APFloat::Float8E5M2FZN();
   if (isa<BFloat16Type>())
     return APFloat::BFloat();
   if (isa<Float16Type>())
     return APFloat::IEEEhalf();
   if (isa<Float32Type>())
     return APFloat::IEEEsingle();
   if (isa<Float64Type>())
     return APFloat::IEEEdouble();

mlir/lib/IR/MLIRContext.cpp

#endif
   //===--------------------------------------------------------------------===//
 
   DenseMap<TypeID, AbstractType *> registeredTypes;
   StorageUniquer typeUniquer;
 
   /// Cached Type Instances.
   Float8E5M2Type f8E5M2Ty;
   Float8E4M3FNType f8E4M3FNTy;
+  Float8E4M3FZNType f8E4M3FZNTy;
+  Float8E5M2FZNType f8E5M2FZNTy;
   BFloat16Type bf16Ty;
   Float16Type f16Ty;
   Float32Type f32Ty;
   Float64Type f64Ty;
   Float80Type f80Ty;
   Float128Type f128Ty;
   IndexType indexTy;
   IntegerType int1Ty, int8Ty, int16Ty, int32Ty, int64Ty, int128Ty;
MLIRContext::MLIRContext(const DialectRegistry &registry, Threading setting)
 
   // Initialize several common attributes and types to avoid the need to lock
   // the context when accessing them.
 
   //// Types.
   /// Floating-point Types.
   impl->f8E5M2Ty = TypeUniquer::get<Float8E5M2Type>(this);
   impl->f8E4M3FNTy = TypeUniquer::get<Float8E4M3FNType>(this);
+  impl->f8E4M3FZNTy = TypeUniquer::get<Float8E4M3FZNType>(this);
+  impl->f8E5M2FZNTy = TypeUniquer::get<Float8E5M2FZNType>(this);
   impl->bf16Ty = TypeUniquer::get<BFloat16Type>(this);
   impl->f16Ty = TypeUniquer::get<Float16Type>(this);
   impl->f32Ty = TypeUniquer::get<Float32Type>(this);
   impl->f64Ty = TypeUniquer::get<Float64Type>(this);
   impl->f80Ty = TypeUniquer::get<Float80Type>(this);
   impl->f128Ty = TypeUniquer::get<Float128Type>(this);
   /// Index Type.
   impl->indexTy = TypeUniquer::get<IndexType>(this);

 StorageUniquer &MLIRContext::getTypeUniquer() { return getImpl().typeUniquer; }
 
 Float8E5M2Type Float8E5M2Type::get(MLIRContext *context) {
   return context->getImpl().f8E5M2Ty;
 }
 Float8E4M3FNType Float8E4M3FNType::get(MLIRContext *context) {
   return context->getImpl().f8E4M3FNTy;
 }
+Float8E4M3FZNType Float8E4M3FZNType::get(MLIRContext *context) {
+  return context->getImpl().f8E4M3FZNTy;
+}
+Float8E5M2FZNType Float8E5M2FZNType::get(MLIRContext *context) {
+  return context->getImpl().f8E5M2FZNTy;
+}
 BFloat16Type BFloat16Type::get(MLIRContext *context) {
   return context->getImpl().bf16Ty;
 }
 Float16Type Float16Type::get(MLIRContext *context) {
   return context->getImpl().f16Ty;
 }
 Float32Type Float32Type::get(MLIRContext *context) {
   return context->getImpl().f32Ty;

mlir/lib/IR/Types.cpp

 //===----------------------------------------------------------------------===//
 // Type
 //===----------------------------------------------------------------------===//
 
 MLIRContext *Type::getContext() const { return getDialect().getContext(); }
 
 bool Type::isFloat8E5M2() const { return isa<Float8E5M2Type>(); }
 bool Type::isFloat8E4M3FN() const { return isa<Float8E4M3FNType>(); }
+bool Type::isFloat8E4M3FZN() const { return isa<Float8E4M3FZNType>(); }
+bool Type::isFloat8E5M2FZN() const { return isa<Float8E5M2FZNType>(); }
 bool Type::isBF16() const { return isa<BFloat16Type>(); }
 bool Type::isF16() const { return isa<Float16Type>(); }
 bool Type::isF32() const { return isa<Float32Type>(); }
 bool Type::isF64() const { return isa<Float64Type>(); }
 bool Type::isF80() const { return isa<Float80Type>(); }
 bool Type::isF128() const { return isa<Float128Type>(); }
 
 bool Type::isIndex() const { return isa<IndexType>(); }

mlir/python/mlir/_mlir_libs/_mlir/ir.pyi

__all__ = [
     "DialectDescriptor",
     "Dialects",
     "Diagnostic",
     "DiagnosticHandler",
     "DiagnosticSeverity",
     "DictAttr",
     "Float8E4M3FNType",
     "Float8E5M2Type",
+    "Float8E4M3FZNType",
+    "Float8E5M2FZNType",
     "F16Type",
     "F32Type",
     "F64Type",
     "FlatSymbolRefAttr",
     "FloatAttr",
     "FunctionType",
     "IndexType",
     "InferTypeOpInterface",

 
 class Float8E4M3FNType(Type):
     def __init__(self, cast_from_type: Type) -> None: ...
     @staticmethod
     def get(*args, **kwargs) -> Float8E4M3FNType: ...
     @staticmethod
     def isinstance(arg: Any) -> bool: ...
 
+class Float8E5M2FZNType(Type):
+    def __init__(self, cast_from_type: Type) -> None: ...
+    @staticmethod
+    def get(*args, **kwargs) -> Float8E5M2FZNType: ...
+    @staticmethod
+    def isinstance(arg: Any) -> bool: ...
+
+class Float8E4M3FZNType(Type):
+    def __init__(self, cast_from_type: Type) -> None: ...
+    @staticmethod
+    def get(*args, **kwargs) -> Float8E4M3FZNType: ...
+    @staticmethod
+    def isinstance(arg: Any) -> bool: ...
+
 class Float8E5M2Type(Type):
     def __init__(self, cast_from_type: Type) -> None: ...
     @staticmethod
     def get(*args, **kwargs) -> Float8E5M2Type: ...
     @staticmethod
     def isinstance(arg: Any) -> bool: ...
 
 # TODO: Auto-generated. Audit and fix.

mlir/test/IR/attribute.mlir

"test.float_attrs"() {
     // CHECK: float_attr = 2.000000e+00 : f8E5M2
     float_attr = 2. : f8E5M2
   } : () -> ()
   "test.float_attrs"() {
     // CHECK: float_attr = 2.000000e+00 : f8E4M3FN
     float_attr = 2. : f8E4M3FN
   } : () -> ()
   "test.float_attrs"() {
+    // CHECK: float_attr = 2.000000e+00 : f8E4M3FZN
+    float_attr = 2. : f8E4M3FZN
+  } : () -> ()
+  "test.float_attrs"() {
+    // CHECK: float_attr = 2.000000e+00 : f8E5M2FZN
+    float_attr = 2. : f8E5M2FZN
+  } : () -> ()
+  "test.float_attrs"() {
     // CHECK: float_attr = 2.000000e+00 : f16
     float_attr = 2. : f16
   } : () -> ()
   "test.float_attrs"() {
     // CHECK: float_attr = 2.000000e+00 : bf16
     float_attr = 2. : bf16
   } : () -> ()
   "test.float_attrs"() {

mlir/test/python/ir/builtin_types.py

 # CHECK-LABEL: TEST: testFloatType
 @run
 def testFloatType():
   with Context():
     # CHECK: float: f8E4M3FN
     print("float:", Float8E4M3FNType.get())
     # CHECK: float: f8E5M2
     print("float:", Float8E5M2Type.get())
+    # CHECK: float: f8E4M3FZN
+    print("float:", Float8E4M3FZNType.get())
+    # CHECK: float: f8E5M2FZN
+    print("float:", Float8E5M2FZNType.get())
     # CHECK: float: bf16
     print("float:", BF16Type.get())
     # CHECK: float: f16
     print("float:", F16Type.get())
     # CHECK: float: f32
     print("float:", F32Type.get())
     # CHECK: float: f64
     print("float:", F64Type.get())

mlir/utils/lldb-scripts/mlirDataFormatters.py

builtin_attr_type_mnemonics = {
     "mlir::StringAttr": '""...""',
     "mlir::StridedLayout": '"strided_layout"',
     "mlir::UnitAttr": '"unit"',
     "mlir::CallSiteLoc": '"loc(callsite(...))"',
     "mlir::FusedLoc": '"loc(fused<...>[...])"',
     "mlir::UnknownLoc": '"loc(unknown)"',
     "mlir::Float8E5M2Type": '"f8E5M2"',
     "mlir::Float8E4M3FNType": '"f8E4M3FN"',
+    "mlir::Float8E4M3FZNType": '"f8E4M3FZN"',
+    "mlir::Float8E5M2FZNType": '"f8E5M2FZN"',
     "mlir::BFloat16Type": '"bf16"',
     "mlir::Float16Type": '"f16"',
     "mlir::Float32Type": '"f32"',
     "mlir::Float64Type": '"f64"',
     "mlir::Float80Type": '"f80"',
     "mlir::Float128Type": '"f128"',
     "mlir::FunctionType": '"(...) -> (...)"',
     "mlir::IndexType": '"index"',