[APFloat] Enlarge ExponentType to 32bit integer

[ekatz]

Summary

Enlarge the size of ExponentType from 16bit integer to 32bit. This is required to prevent exponent overflow/underflow.

Note that IEEEFloat size doesn't change in 64bit or 32bit compilation targets.

Fix PR34851.

[arsenm]

llvm/unittests/ADT/APFloatTest.cpp

2675

EXPECT_EQ

3005

EXPECT_EQ

[ekatz]

Changed to EXPECT_EQ as requested.

[efriedma]

llvm/lib/Support/APFloat.cpp

1014 ↗

(On Diff #227923)

These static_casts don't do anything.

1218 ↗

(On Diff #227923)

EXPONENT_MIN is -32768, which is more than twice as small as the smallest exponent in any format we support, right? If the exponent is smaller than that, can we "cheat", and pretend the result came out to -32768? The result is essentially zero anyway.

Do we need to handle EXPONENT_MAX?

llvm/unittests/ADT/APFloatTest.cpp

3002

Maybe check what happens with other rounding modes, where the result isn't zero?

[ekatz]

This is a simpler take for the solution.

Also, added tests for other rounding modes, as requested.

[efriedma]

llvm/include/llvm/ADT/APFloat.h

146

What's the effect of this on the size of APFloat on a 64-bit target? On a 32-bit target?

llvm/lib/Support/APFloat.cpp

994 ↗

(On Diff #229752)

Does this have some functional effect? If it does, is there a test?

[ekatz]

llvm/include/llvm/ADT/APFloat.h

146

APFloat remains the same size. I added a note about that in the description. Maybe it is not clear enough.

detail::IEEEFloat is the only record that has a field of ExponentType type. It remains the size of 24 bytes and alignment of 8 bytes (in both 32 bit and 64 bit targets).

llvm/lib/Support/APFloat.cpp

994 ↗

(On Diff #229752)

Now that I think of it, I'll just separate it into another patch. It is a bug, revealed from the tests I've made.

[ekatz]

Removed changes unrelated to topic.

[efriedma]

LGTM

llvm/include/llvm/ADT/APFloat.h

146

Okay. I missed the comment in the updated commit message.

llvm/include/llvm/ADT/APFloat.h

 // This is the common type definitions shared by APFloat and its internal
 // implementation classes. This struct should not define any non-static data
 // members.
 struct APFloatBase {
   typedef APInt::WordType integerPart;
   static const unsigned integerPartWidth = APInt::APINT_BITS_PER_WORD;
 
   /// A signed type to represent a floating point numbers unbiased exponent.
-  typedef signed short ExponentType;
+  typedef int32_t ExponentType;
 
   /// \name Floating Point Semantics.
   /// @{
   enum Semantics {
     S_IEEEhalf,
     S_IEEEsingle,
     S_IEEEdouble,
     S_x87DoubleExtended,

llvm/unittests/ADT/APFloatTest.cpp

TEST(APFloatTest, multiply) {
   APFloat SNaN = APFloat::getSNaN(APFloat::IEEEsingle(), false);
   APFloat PNormalValue = APFloat(APFloat::IEEEsingle(), "0x1p+0");
   APFloat MNormalValue = APFloat(APFloat::IEEEsingle(), "-0x1p+0");
   APFloat PLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), false);
   APFloat MLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), true);
   APFloat PSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), false);
   APFloat MSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), true);
   APFloat PSmallestNormalized =
       APFloat::getSmallestNormalized(APFloat::IEEEsingle(), false);
   APFloat MSmallestNormalized =
       APFloat::getSmallestNormalized(APFloat::IEEEsingle(), true);
 
+  APFloat MaxQuad(APFloat::IEEEquad(),
+                  "0x1.ffffffffffffffffffffffffffffp+16383");
+  APFloat MinQuad(APFloat::IEEEquad(),
+                  "0x0.0000000000000000000000000001p-16382");
+  APFloat NMinQuad(APFloat::IEEEquad(),
+                   "-0x0.0000000000000000000000000001p-16382");
+
   const int OverflowStatus = APFloat::opOverflow | APFloat::opInexact;
   const int UnderflowStatus = APFloat::opUnderflow | APFloat::opInexact;
 
-  const unsigned NumTests = 169;
   struct {
     APFloat x;
     APFloat y;
     const char *result;
     int status;
     int category;
-  } SpecialCaseTests[NumTests] = {
+    APFloat::roundingMode roundingMode = APFloat::rmNearestTiesToEven;
+  } SpecialCaseTests[] = {
     { PInf, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
     { PInf, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
     { PInf, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
     { PInf, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
     { PInf, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
 #if 0
 // See Note 1.
     { PInf, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },

 #endif
     { MSmallestNormalized, PNormalValue, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
     { MSmallestNormalized, MNormalValue, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
     { MSmallestNormalized, PLargestValue, "-0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal },
     { MSmallestNormalized, MLargestValue, "0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal },
     { MSmallestNormalized, PSmallestValue, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
     { MSmallestNormalized, MSmallestValue, "0x0p+0", UnderflowStatus, APFloat::fcZero },
     { MSmallestNormalized, PSmallestNormalized, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
-    { MSmallestNormalized, MSmallestNormalized, "0x0p+0", UnderflowStatus, APFloat::fcZero }
+    { MSmallestNormalized, MSmallestNormalized, "0x0p+0", UnderflowStatus, APFloat::fcZero },
+
+    {MaxQuad, MinQuad, "0x1.ffffffffffffffffffffffffffffp-111", APFloat::opOK,
+     APFloat::fcNormal, APFloat::rmNearestTiesToEven},
+    {MaxQuad, MinQuad, "0x1.ffffffffffffffffffffffffffffp-111", APFloat::opOK,
+     APFloat::fcNormal, APFloat::rmTowardPositive},
+    {MaxQuad, MinQuad, "0x1.ffffffffffffffffffffffffffffp-111", APFloat::opOK,
+     APFloat::fcNormal, APFloat::rmTowardNegative},
+    {MaxQuad, MinQuad, "0x1.ffffffffffffffffffffffffffffp-111", APFloat::opOK,
+     APFloat::fcNormal, APFloat::rmTowardZero},
+    {MaxQuad, MinQuad, "0x1.ffffffffffffffffffffffffffffp-111", APFloat::opOK,
+     APFloat::fcNormal, APFloat::rmNearestTiesToAway},
+
+    {MaxQuad, NMinQuad, "-0x1.ffffffffffffffffffffffffffffp-111", APFloat::opOK,
+     APFloat::fcNormal, APFloat::rmNearestTiesToEven},
+    {MaxQuad, NMinQuad, "-0x1.ffffffffffffffffffffffffffffp-111", APFloat::opOK,
+     APFloat::fcNormal, APFloat::rmTowardPositive},
+    {MaxQuad, NMinQuad, "-0x1.ffffffffffffffffffffffffffffp-111", APFloat::opOK,
+     APFloat::fcNormal, APFloat::rmTowardNegative},
+    {MaxQuad, NMinQuad, "-0x1.ffffffffffffffffffffffffffffp-111", APFloat::opOK,
+     APFloat::fcNormal, APFloat::rmTowardZero},
+    {MaxQuad, NMinQuad, "-0x1.ffffffffffffffffffffffffffffp-111", APFloat::opOK,
+     APFloat::fcNormal, APFloat::rmNearestTiesToAway},
+
+    {MaxQuad, MaxQuad, "inf", OverflowStatus, APFloat::fcInfinity,
+     APFloat::rmNearestTiesToEven},
+    {MaxQuad, MaxQuad, "inf", OverflowStatus, APFloat::fcInfinity,
+     APFloat::rmTowardPositive},
+    {MaxQuad, MaxQuad, "0x1.ffffffffffffffffffffffffffffp+16383",
+     APFloat::opInexact, APFloat::fcNormal, APFloat::rmTowardNegative},
+    {MaxQuad, MaxQuad, "0x1.ffffffffffffffffffffffffffffp+16383",
+     APFloat::opInexact, APFloat::fcNormal, APFloat::rmTowardZero},
+    {MaxQuad, MaxQuad, "inf", OverflowStatus, APFloat::fcInfinity,
+     APFloat::rmNearestTiesToAway},
+
+    {MinQuad, MinQuad, "0", UnderflowStatus, APFloat::fcZero,
+     APFloat::rmNearestTiesToEven},
+    {MinQuad, MinQuad, "0x0.0000000000000000000000000001p-16382",
+     UnderflowStatus, APFloat::fcNormal, APFloat::rmTowardPositive},
+    {MinQuad, MinQuad, "0", UnderflowStatus, APFloat::fcZero,
+     APFloat::rmTowardNegative},
+    {MinQuad, MinQuad, "0", UnderflowStatus, APFloat::fcZero,
+     APFloat::rmTowardZero},
+    {MinQuad, MinQuad, "0", UnderflowStatus, APFloat::fcZero,
+     APFloat::rmNearestTiesToAway},
+
+    {MinQuad, NMinQuad, "-0", UnderflowStatus, APFloat::fcZero,
+     APFloat::rmNearestTiesToEven},
+    {MinQuad, NMinQuad, "-0", UnderflowStatus, APFloat::fcZero,
+     APFloat::rmTowardPositive},
+    {MinQuad, NMinQuad, "-0x0.0000000000000000000000000001p-16382",
+     UnderflowStatus, APFloat::fcNormal, APFloat::rmTowardNegative},
+    {MinQuad, NMinQuad, "-0", UnderflowStatus, APFloat::fcZero,
+     APFloat::rmTowardZero},
+    {MinQuad, NMinQuad, "-0", UnderflowStatus, APFloat::fcZero,
+     APFloat::rmNearestTiesToAway},
   };
 
-  for (size_t i = 0; i < NumTests; ++i) {
+  for (size_t i = 0; i < array_lengthof(SpecialCaseTests); ++i) {
     APFloat x(SpecialCaseTests[i].x);
     APFloat y(SpecialCaseTests[i].y);
-    APFloat::opStatus status = x.multiply(y, APFloat::rmNearestTiesToEven);
+    APFloat::opStatus status = x.multiply(y, SpecialCaseTests[i].roundingMode);
 
-    APFloat result(APFloat::IEEEsingle(), SpecialCaseTests[i].result);
+    APFloat result(x.getSemantics(), SpecialCaseTests[i].result);
 
     EXPECT_TRUE(result.bitwiseIsEqual(x));
     EXPECT_TRUE((int)status == SpecialCaseTests[i].status);
     EXPECT_TRUE((int)x.getCategory() == SpecialCaseTests[i].category);
   }
 }
 
 TEST(APFloatTest, divide) {
   // Test Special Cases against each other and normal values.
 
   // TODOS/NOTES:
   // 1. Since we perform only default exception handling all operations with
   // signaling NaNs should have a result that is a quiet NaN. Currently they
   // return sNaN.
 
   APFloat PInf = APFloat::getInf(APFloat::IEEEsingle(), false);
   APFloat MInf = APFloat::getInf(APFloat::IEEEsingle(), true);
   APFloat PZero = APFloat::getZero(APFloat::IEEEsingle(), false);
   APFloat MZero = APFloat::getZero(APFloat::IEEEsingle(), true);
   APFloat QNaN = APFloat::getNaN(APFloat::IEEEsingle(), false);
   APFloat SNaN = APFloat::getSNaN(APFloat::IEEEsingle(), false);
   APFloat PNormalValue = APFloat(APFloat::IEEEsingle(), "0x1p+0");
   APFloat MNormalValue = APFloat(APFloat::IEEEsingle(), "-0x1p+0");
   APFloat PLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), false);
   APFloat MLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), true);
   APFloat PSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), false);
   APFloat MSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), true);
   APFloat PSmallestNormalized =
       APFloat::getSmallestNormalized(APFloat::IEEEsingle(), false);
   APFloat MSmallestNormalized =
       APFloat::getSmallestNormalized(APFloat::IEEEsingle(), true);
 
+  APFloat MaxQuad(APFloat::IEEEquad(),
+                  "0x1.ffffffffffffffffffffffffffffp+16383");
+  APFloat MinQuad(APFloat::IEEEquad(),
+                  "0x0.0000000000000000000000000001p-16382");
+  APFloat NMinQuad(APFloat::IEEEquad(),
+                   "-0x0.0000000000000000000000000001p-16382");
+
   const int OverflowStatus = APFloat::opOverflow | APFloat::opInexact;
   const int UnderflowStatus = APFloat::opUnderflow | APFloat::opInexact;
 
-  const unsigned NumTests = 169;
   struct {
     APFloat x;
     APFloat y;
     const char *result;
     int status;
     int category;
-  } SpecialCaseTests[NumTests] = {
+    APFloat::roundingMode roundingMode = APFloat::rmNearestTiesToEven;
+  } SpecialCaseTests[] = {
     { PInf, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
     { PInf, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
     { PInf, PZero, "inf", APFloat::opOK, APFloat::fcInfinity },
     { PInf, MZero, "-inf", APFloat::opOK, APFloat::fcInfinity },
     { PInf, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
 #if 0
 // See Note 1.
     { PInf, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
#endif
     { MSmallestNormalized, PNormalValue, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
     { MSmallestNormalized, MNormalValue, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
     { MSmallestNormalized, PLargestValue, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
     { MSmallestNormalized, MLargestValue, "0x0p+0", UnderflowStatus, APFloat::fcZero },
     { MSmallestNormalized, PSmallestValue, "-0x1p+23", APFloat::opOK, APFloat::fcNormal },
     { MSmallestNormalized, MSmallestValue, "0x1p+23", APFloat::opOK, APFloat::fcNormal },
     { MSmallestNormalized, PSmallestNormalized, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
     { MSmallestNormalized, MSmallestNormalized, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
+
+    {MaxQuad, NMinQuad, "-inf", OverflowStatus, APFloat::fcInfinity,
+     APFloat::rmNearestTiesToEven},
+    {MaxQuad, NMinQuad, "-0x1.ffffffffffffffffffffffffffffp+16383",
+     APFloat::opInexact, APFloat::fcNormal, APFloat::rmTowardPositive},
+    {MaxQuad, NMinQuad, "-inf", OverflowStatus, APFloat::fcInfinity,
+     APFloat::rmTowardNegative},
+    {MaxQuad, NMinQuad, "-0x1.ffffffffffffffffffffffffffffp+16383",
+     APFloat::opInexact, APFloat::fcNormal, APFloat::rmTowardZero},
+    {MaxQuad, NMinQuad, "-inf", OverflowStatus, APFloat::fcInfinity,
+     APFloat::rmNearestTiesToAway},
+
+    {MinQuad, MaxQuad, "0", UnderflowStatus, APFloat::fcZero,
+     APFloat::rmNearestTiesToEven},
+    {MinQuad, MaxQuad, "0x0.0000000000000000000000000001p-16382",
+     UnderflowStatus, APFloat::fcNormal, APFloat::rmTowardPositive},
+    {MinQuad, MaxQuad, "0", UnderflowStatus, APFloat::fcZero,
+     APFloat::rmTowardNegative},
+    {MinQuad, MaxQuad, "0", UnderflowStatus, APFloat::fcZero,
+     APFloat::rmTowardZero},
+    {MinQuad, MaxQuad, "0", UnderflowStatus, APFloat::fcZero,
+     APFloat::rmNearestTiesToAway},
+
+    {NMinQuad, MaxQuad, "-0", UnderflowStatus, APFloat::fcZero,
+     APFloat::rmNearestTiesToEven},
+    {NMinQuad, MaxQuad, "-0", UnderflowStatus, APFloat::fcZero,
+     APFloat::rmTowardPositive},
+    {NMinQuad, MaxQuad, "-0x0.0000000000000000000000000001p-16382",
+     UnderflowStatus, APFloat::fcNormal, APFloat::rmTowardNegative},
+    {NMinQuad, MaxQuad, "-0", UnderflowStatus, APFloat::fcZero,
+     APFloat::rmTowardZero},
+    {NMinQuad, MaxQuad, "-0", UnderflowStatus, APFloat::fcZero,
+     APFloat::rmNearestTiesToAway},
   };
 
-  for (size_t i = 0; i < NumTests; ++i) {
+  for (size_t i = 0; i < array_lengthof(SpecialCaseTests); ++i) {
     APFloat x(SpecialCaseTests[i].x);
     APFloat y(SpecialCaseTests[i].y);
-    APFloat::opStatus status = x.divide(y, APFloat::rmNearestTiesToEven);
+    APFloat::opStatus status = x.divide(y, SpecialCaseTests[i].roundingMode);
 
-    APFloat result(APFloat::IEEEsingle(), SpecialCaseTests[i].result);
+    APFloat result(x.getSemantics(), SpecialCaseTests[i].result);
 
     EXPECT_TRUE(result.bitwiseIsEqual(x));
     EXPECT_TRUE((int)status == SpecialCaseTests[i].status);
     EXPECT_TRUE((int)x.getCategory() == SpecialCaseTests[i].category);
   }
 }
 
 TEST(APFloatTest, operatorOverloads) {
   // This is mostly testing that these operator overloads compile.
   APFloat One = APFloat(APFloat::IEEEsingle(), "0x1p+0");
   APFloat Two = APFloat(APFloat::IEEEsingle(), "0x2p+0");
   EXPECT_TRUE(Two.bitwiseIsEqual(One + One));
   EXPECT_TRUE(One.bitwiseIsEqual(Two - One));
   EXPECT_TRUE(Two.bitwiseIsEqual(One * Two));
   EXPECT_TRUE(One.bitwiseIsEqual(Two / Two));
 }
 
 TEST(APFloatTest, abs) {
   APFloat PInf = APFloat::getInf(APFloat::IEEEsingle(), false);
   APFloat MInf = APFloat::getInf(APFloat::IEEEsingle(), true);
   APFloat PZero = APFloat::getZero(APFloat::IEEEsingle(), false);
   APFloat MZero = APFloat::getZero(APFloat::IEEEsingle(), true);
   APFloat PQNaN = APFloat::getNaN(APFloat::IEEEsingle(), false);
   APFloat MQNaN = APFloat::getNaN(APFloat::IEEEsingle(), true);