Revert "Add APFloat and MLIR type support for fp8 (e5m2)."

Breaks bots https://lab.llvm.org/buildbot/#/builders/37/builds/17086

This reverts commit 2dc68b5398258c7a0cf91f10192d058e787afcdf.

1 files changed, 14 insertions, 91 deletions

diff --git a/llvm/unittests/ADT/APFloatTest.cpp b/llvm/unittests/ADT/APFloatTest.cpp
index 90e39bf..3caa09f 100644
--- a/llvm/unittests/ADT/APFloatTest.cpp
+++ b/llvm/unittests/ADT/APFloatTest.cpp
@@ -1752,20 +1752,18 @@ TEST(APFloatTest, getZero) {
     const unsigned long long bitPattern[2];
     const unsigned bitPatternLength;
   } const GetZeroTest[] = {
-      {&APFloat::IEEEhalf(), false, {0, 0}, 1},
-      {&APFloat::IEEEhalf(), true, {0x8000ULL, 0}, 1},
-      {&APFloat::IEEEsingle(), false, {0, 0}, 1},
-      {&APFloat::IEEEsingle(), true, {0x80000000ULL, 0}, 1},
-      {&APFloat::IEEEdouble(), false, {0, 0}, 1},
-      {&APFloat::IEEEdouble(), true, {0x8000000000000000ULL, 0}, 1},
-      {&APFloat::IEEEquad(), false, {0, 0}, 2},
-      {&APFloat::IEEEquad(), true, {0, 0x8000000000000000ULL}, 2},
-      {&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::IEEEhalf(), false, {0, 0}, 1},
+    { &APFloat::IEEEhalf(), true, {0x8000ULL, 0}, 1},
+    { &APFloat::IEEEsingle(), false, {0, 0}, 1},
+    { &APFloat::IEEEsingle(), true, {0x80000000ULL, 0}, 1},
+    { &APFloat::IEEEdouble(), false, {0, 0}, 1},
+    { &APFloat::IEEEdouble(), true, {0x8000000000000000ULL, 0}, 1},
+    { &APFloat::IEEEquad(), false, {0, 0}, 2},
+    { &APFloat::IEEEquad(), true, {0, 0x8000000000000000ULL}, 2},
+    { &APFloat::PPCDoubleDouble(), false, {0, 0}, 2},
+    { &APFloat::PPCDoubleDouble(), true, {0x8000000000000000ULL, 0}, 2},
+    { &APFloat::x87DoubleExtended(), false, {0, 0}, 2},
+    { &APFloat::x87DoubleExtended(), true, {0, 0x8000ULL}, 2},
   };
   const unsigned NumGetZeroTests = 12;
   for (unsigned i = 0; i < NumGetZeroTests; ++i) {
@@ -4756,7 +4754,7 @@ TEST(APFloatTest, x87Next) {
   EXPECT_TRUE(ilogb(F) == -1);
 }
 
-TEST(APFloatTest, IEEEdoubleToDouble) {
+TEST(APFloatTest, ToDouble) {
   APFloat DPosZero(0.0);
   APFloat DPosZeroToDouble(DPosZero.convertToDouble());
   EXPECT_TRUE(DPosZeroToDouble.isPosZero());
@@ -4792,9 +4790,7 @@ TEST(APFloatTest, IEEEdoubleToDouble) {
             DNegInf.convertToDouble());
   APFloat DQNaN = APFloat::getQNaN(APFloat::IEEEdouble());
   EXPECT_TRUE(std::isnan(DQNaN.convertToDouble()));
-}
 
-TEST(APFloatTest, IEEEsingleToDouble) {
   APFloat FPosZero(0.0F);
   APFloat FPosZeroToDouble(FPosZero.convertToDouble());
   EXPECT_TRUE(FPosZeroToDouble.isPosZero());
@@ -4829,9 +4825,7 @@ TEST(APFloatTest, IEEEsingleToDouble) {
             FNegInf.convertToDouble());
   APFloat FQNaN = APFloat::getQNaN(APFloat::IEEEsingle());
   EXPECT_TRUE(std::isnan(FQNaN.convertToDouble()));
-}
 
-TEST(APFloatTest, IEEEhalfToDouble) {
   APFloat HPosZero = APFloat::getZero(APFloat::IEEEhalf());
   APFloat HPosZeroToDouble(HPosZero.convertToDouble());
   EXPECT_TRUE(HPosZeroToDouble.isPosZero());
@@ -4873,9 +4867,7 @@ TEST(APFloatTest, IEEEhalfToDouble) {
   APFloat BNegZero = APFloat::getZero(APFloat::IEEEhalf(), true);
   APFloat BNegZeroToDouble(BNegZero.convertToDouble());
   EXPECT_TRUE(BNegZeroToDouble.isNegZero());
-}
 
-TEST(APFloatTest, BFloatToDouble) {
   APFloat BOne(APFloat::BFloat(), "1.0");
   EXPECT_EQ(1.0, BOne.convertToDouble());
   APFloat BPosLargest = APFloat::getLargest(APFloat::BFloat(), false);
@@ -4909,35 +4901,7 @@ TEST(APFloatTest, BFloatToDouble) {
   EXPECT_TRUE(std::isnan(BQNaN.convertToDouble()));
 }
 
-TEST(APFloatTest, Float8E5M2ToDouble) {
-  APFloat One(APFloat::Float8E5M2(), "1.0");
-  EXPECT_EQ(1.0, One.convertToDouble());
-  APFloat Two(APFloat::Float8E5M2(), "2.0");
-  EXPECT_EQ(2.0, Two.convertToDouble());
-  APFloat PosLargest = APFloat::getLargest(APFloat::Float8E5M2(), false);
-  EXPECT_EQ(5.734400e+04, PosLargest.convertToDouble());
-  APFloat NegLargest = APFloat::getLargest(APFloat::Float8E5M2(), true);
-  EXPECT_EQ(-5.734400e+04, NegLargest.convertToDouble());
-  APFloat PosSmallest =
-      APFloat::getSmallestNormalized(APFloat::Float8E5M2(), false);
-  EXPECT_EQ(0x1.p-14, PosSmallest.convertToDouble());
-  APFloat NegSmallest =
-      APFloat::getSmallestNormalized(APFloat::Float8E5M2(), true);
-  EXPECT_EQ(-0x1.p-14, NegSmallest.convertToDouble());
-
-  APFloat SmallestDenorm = APFloat::getSmallest(APFloat::Float8E5M2(), false);
-  EXPECT_TRUE(SmallestDenorm.isDenormal());
-  EXPECT_EQ(0x1p-16, SmallestDenorm.convertToDouble());
-
-  APFloat PosInf = APFloat::getInf(APFloat::Float8E5M2());
-  EXPECT_EQ(std::numeric_limits<double>::infinity(), PosInf.convertToDouble());
-  APFloat NegInf = APFloat::getInf(APFloat::Float8E5M2(), true);
-  EXPECT_EQ(-std::numeric_limits<double>::infinity(), NegInf.convertToDouble());
-  APFloat QNaN = APFloat::getQNaN(APFloat::Float8E5M2());
-  EXPECT_TRUE(std::isnan(QNaN.convertToDouble()));
-}
-
-TEST(APFloatTest, IEEEsingleToFloat) {
+TEST(APFloatTest, ToFloat) {
   APFloat FPosZero(0.0F);
   APFloat FPosZeroToFloat(FPosZero.convertToFloat());
   EXPECT_TRUE(FPosZeroToFloat.isPosZero());
@@ -4971,9 +4935,7 @@ TEST(APFloatTest, IEEEsingleToFloat) {
   EXPECT_EQ(-std::numeric_limits<float>::infinity(), FNegInf.convertToFloat());
   APFloat FQNaN = APFloat::getQNaN(APFloat::IEEEsingle());
   EXPECT_TRUE(std::isnan(FQNaN.convertToFloat()));
-}
 
-TEST(APFloatTest, IEEEhalfToFloat) {
   APFloat HPosZero = APFloat::getZero(APFloat::IEEEhalf());
   APFloat HPosZeroToFloat(HPosZero.convertToFloat());
   EXPECT_TRUE(HPosZeroToFloat.isPosZero());
@@ -5007,9 +4969,7 @@ TEST(APFloatTest, IEEEhalfToFloat) {
   EXPECT_EQ(-std::numeric_limits<float>::infinity(), HNegInf.convertToFloat());
   APFloat HQNaN = APFloat::getQNaN(APFloat::IEEEhalf());
   EXPECT_TRUE(std::isnan(HQNaN.convertToFloat()));
-}
 
-TEST(APFloatTest, BFloatToFloat) {
   APFloat BPosZero = APFloat::getZero(APFloat::BFloat());
   APFloat BPosZeroToDouble(BPosZero.convertToFloat());
   EXPECT_TRUE(BPosZeroToDouble.isPosZero());
@@ -5048,41 +5008,4 @@ TEST(APFloatTest, BFloatToFloat) {
   APFloat BQNaN = APFloat::getQNaN(APFloat::BFloat());
   EXPECT_TRUE(std::isnan(BQNaN.convertToFloat()));
 }
-
-TEST(APFloatTest, Float8E5M2ToFloat) {
-  APFloat PosZero = APFloat::getZero(APFloat::Float8E5M2());
-  APFloat PosZeroToFloat(PosZero.convertToFloat());
-  EXPECT_TRUE(PosZeroToFloat.isPosZero());
-  APFloat NegZero = APFloat::getZero(APFloat::Float8E5M2(), true);
-  APFloat NegZeroToFloat(NegZero.convertToFloat());
-  EXPECT_TRUE(NegZeroToFloat.isNegZero());
-
-  APFloat One(APFloat::Float8E5M2(), "1.0");
-  EXPECT_EQ(1.0F, One.convertToFloat());
-  APFloat Two(APFloat::Float8E5M2(), "2.0");
-  EXPECT_EQ(2.0F, Two.convertToFloat());
-
-  APFloat PosLargest = APFloat::getLargest(APFloat::Float8E5M2(), false);
-  EXPECT_EQ(5.734400e+04, PosLargest.convertToFloat());
-  APFloat NegLargest = APFloat::getLargest(APFloat::Float8E5M2(), true);
-  EXPECT_EQ(-5.734400e+04, NegLargest.convertToFloat());
-  APFloat PosSmallest =
-      APFloat::getSmallestNormalized(APFloat::Float8E5M2(), false);
-  EXPECT_EQ(0x1.p-14, PosSmallest.convertToFloat());
-  APFloat NegSmallest =
-      APFloat::getSmallestNormalized(APFloat::Float8E5M2(), true);
-  EXPECT_EQ(-0x1.p-14, NegSmallest.convertToFloat());
-
-  APFloat SmallestDenorm = APFloat::getSmallest(APFloat::Float8E5M2(), false);
-  EXPECT_TRUE(SmallestDenorm.isDenormal());
-  EXPECT_EQ(0x1.p-16, SmallestDenorm.convertToFloat());
-
-  APFloat PosInf = APFloat::getInf(APFloat::Float8E5M2());
-  EXPECT_EQ(std::numeric_limits<float>::infinity(), PosInf.convertToFloat());
-  APFloat NegInf = APFloat::getInf(APFloat::Float8E5M2(), true);
-  EXPECT_EQ(-std::numeric_limits<float>::infinity(), NegInf.convertToFloat());
-  APFloat QNaN = APFloat::getQNaN(APFloat::Float8E5M2());
-  EXPECT_TRUE(std::isnan(QNaN.convertToFloat()));
 }
-
-} // namespace