Index: llvm/lib/Support/APFloat.cpp
===================================================================
--- llvm/lib/Support/APFloat.cpp
+++ llvm/lib/Support/APFloat.cpp
@@ -1479,25 +1479,26 @@
   default:
     llvm_unreachable(nullptr);
 
+  case PackCategoriesIntoKey(fcZero, fcNaN):
+  case PackCategoriesIntoKey(fcNormal, fcNaN):
+  case PackCategoriesIntoKey(fcInfinity, fcNaN):
+    assign(rhs);
+    LLVM_FALLTHROUGH;
   case PackCategoriesIntoKey(fcNaN, fcZero):
   case PackCategoriesIntoKey(fcNaN, fcNormal):
   case PackCategoriesIntoKey(fcNaN, fcInfinity):
   case PackCategoriesIntoKey(fcNaN, fcNaN):
+    if (isSignaling()) {
+      makeQuiet();
+      return opInvalidOp;
+    }
+    return rhs.isSignaling() ? opInvalidOp : opOK;
+
   case PackCategoriesIntoKey(fcNormal, fcZero):
   case PackCategoriesIntoKey(fcInfinity, fcNormal):
   case PackCategoriesIntoKey(fcInfinity, fcZero):
     return opOK;
 
-  case PackCategoriesIntoKey(fcZero, fcNaN):
-  case PackCategoriesIntoKey(fcNormal, fcNaN):
-  case PackCategoriesIntoKey(fcInfinity, fcNaN):
-    // We need to be sure to flip the sign here for subtraction because we
-    // don't have a separate negate operation so -NaN becomes 0 - NaN here.
-    sign = rhs.sign ^ subtract;
-    category = fcNaN;
-    copySignificand(rhs);
-    return opOK;
-
   case PackCategoriesIntoKey(fcNormal, fcInfinity):
   case PackCategoriesIntoKey(fcZero, fcInfinity):
     category = fcInfinity;
@@ -1601,20 +1602,22 @@
   default:
     llvm_unreachable(nullptr);
 
-  case PackCategoriesIntoKey(fcNaN, fcZero):
-  case PackCategoriesIntoKey(fcNaN, fcNormal):
-  case PackCategoriesIntoKey(fcNaN, fcInfinity):
-  case PackCategoriesIntoKey(fcNaN, fcNaN):
-    sign = false;
-    return opOK;
-
   case PackCategoriesIntoKey(fcZero, fcNaN):
   case PackCategoriesIntoKey(fcNormal, fcNaN):
   case PackCategoriesIntoKey(fcInfinity, fcNaN):
+    assign(rhs);
     sign = false;
-    category = fcNaN;
-    copySignificand(rhs);
-    return opOK;
+    LLVM_FALLTHROUGH;
+  case PackCategoriesIntoKey(fcNaN, fcZero):
+  case PackCategoriesIntoKey(fcNaN, fcNormal):
+  case PackCategoriesIntoKey(fcNaN, fcInfinity):
+  case PackCategoriesIntoKey(fcNaN, fcNaN):
+    sign ^= rhs.sign; // restore the original sign
+    if (isSignaling()) {
+      makeQuiet();
+      return opInvalidOp;
+    }
+    return rhs.isSignaling() ? opInvalidOp : opOK;
 
   case PackCategoriesIntoKey(fcNormal, fcInfinity):
   case PackCategoriesIntoKey(fcInfinity, fcNormal):
@@ -1646,15 +1649,20 @@
   case PackCategoriesIntoKey(fcZero, fcNaN):
   case PackCategoriesIntoKey(fcNormal, fcNaN):
   case PackCategoriesIntoKey(fcInfinity, fcNaN):
-    category = fcNaN;
-    copySignificand(rhs);
+    assign(rhs);
+    sign = false;
     LLVM_FALLTHROUGH;
   case PackCategoriesIntoKey(fcNaN, fcZero):
   case PackCategoriesIntoKey(fcNaN, fcNormal):
   case PackCategoriesIntoKey(fcNaN, fcInfinity):
   case PackCategoriesIntoKey(fcNaN, fcNaN):
-    sign = false;
-    LLVM_FALLTHROUGH;
+    sign ^= rhs.sign; // restore the original sign
+    if (isSignaling()) {
+      makeQuiet();
+      return opInvalidOp;
+    }
+    return rhs.isSignaling() ? opInvalidOp : opOK;
+
   case PackCategoriesIntoKey(fcInfinity, fcZero):
   case PackCategoriesIntoKey(fcInfinity, fcNormal):
   case PackCategoriesIntoKey(fcZero, fcInfinity):
@@ -1684,23 +1692,26 @@
   default:
     llvm_unreachable(nullptr);
 
+  case PackCategoriesIntoKey(fcZero, fcNaN):
+  case PackCategoriesIntoKey(fcNormal, fcNaN):
+  case PackCategoriesIntoKey(fcInfinity, fcNaN):
+    assign(rhs);
+    LLVM_FALLTHROUGH;
   case PackCategoriesIntoKey(fcNaN, fcZero):
   case PackCategoriesIntoKey(fcNaN, fcNormal):
   case PackCategoriesIntoKey(fcNaN, fcInfinity):
   case PackCategoriesIntoKey(fcNaN, fcNaN):
+    if (isSignaling()) {
+      makeQuiet();
+      return opInvalidOp;
+    }
+    return rhs.isSignaling() ? opInvalidOp : opOK;
+
   case PackCategoriesIntoKey(fcZero, fcInfinity):
   case PackCategoriesIntoKey(fcZero, fcNormal):
   case PackCategoriesIntoKey(fcNormal, fcInfinity):
     return opOK;
 
-  case PackCategoriesIntoKey(fcZero, fcNaN):
-  case PackCategoriesIntoKey(fcNormal, fcNaN):
-  case PackCategoriesIntoKey(fcInfinity, fcNaN):
-    sign = false;
-    category = fcNaN;
-    copySignificand(rhs);
-    return opOK;
-
   case PackCategoriesIntoKey(fcNormal, fcZero):
   case PackCategoriesIntoKey(fcInfinity, fcZero):
   case PackCategoriesIntoKey(fcInfinity, fcNormal):
Index: llvm/unittests/ADT/APFloatTest.cpp
===================================================================
--- llvm/unittests/ADT/APFloatTest.cpp
+++ llvm/unittests/ADT/APFloatTest.cpp
@@ -1750,17 +1750,12 @@
 TEST(APFloatTest, add) {
   // 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 SNaN = APFloat(APFloat::IEEEsingle(), "snan1");
   APFloat PNormalValue = APFloat(APFloat::IEEEsingle(), "0x1p+0");
   APFloat MNormalValue = APFloat(APFloat::IEEEsingle(), "-0x1p+0");
   APFloat PLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), false);
@@ -1774,23 +1769,19 @@
 
   const int OverflowStatus = APFloat::opOverflow | APFloat::opInexact;
 
-  const unsigned NumTests = 169;
   struct {
     APFloat x;
     APFloat y;
     const char *result;
     int status;
     int category;
-  } SpecialCaseTests[NumTests] = {
+  } SpecialCaseTests[] = {
     { PInf, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
     { 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
+    { PInf, SNaN, "nan1", APFloat::opInvalidOp, APFloat::fcNaN },
     { PInf, PNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity },
     { PInf, MNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity },
     { PInf, PLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
@@ -1804,10 +1795,7 @@
     { MInf, PZero, "-inf", APFloat::opOK, APFloat::fcInfinity },
     { MInf, MZero, "-inf", APFloat::opOK, APFloat::fcInfinity },
     { MInf, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
-#if 0
-    // See Note 1.
-    { MInf, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
-#endif
+    { MInf, SNaN, "nan1", APFloat::opInvalidOp, APFloat::fcNaN },
     { MInf, PNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
     { MInf, MNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
     { MInf, PLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
@@ -1821,10 +1809,7 @@
     { PZero, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
     { PZero, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
     { PZero, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
-#if 0
-    // See Note 1.
-    { PZero, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
-#endif
+    { PZero, SNaN, "nan1", APFloat::opInvalidOp, APFloat::fcNaN },
     { PZero, PNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
     { PZero, MNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
     { PZero, PLargestValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
@@ -1838,10 +1823,7 @@
     { MZero, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
     { MZero, MZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
     { MZero, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
-#if 0
-    // See Note 1.
-    { MZero, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
-#endif
+    { MZero, SNaN, "nan1", APFloat::opInvalidOp, APFloat::fcNaN },
     { MZero, PNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
     { MZero, MNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
     { MZero, PLargestValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
@@ -1855,10 +1837,7 @@
     { QNaN, PZero, "nan", APFloat::opOK, APFloat::fcNaN },
     { QNaN, MZero, "nan", APFloat::opOK, APFloat::fcNaN },
     { QNaN, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
-#if 0
-    // See Note 1.
     { QNaN, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
-#endif
     { QNaN, PNormalValue, "nan", APFloat::opOK, APFloat::fcNaN },
     { QNaN, MNormalValue, "nan", APFloat::opOK, APFloat::fcNaN },
     { QNaN, PLargestValue, "nan", APFloat::opOK, APFloat::fcNaN },
@@ -1867,32 +1846,26 @@
     { QNaN, MSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN },
     { QNaN, PSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN },
     { QNaN, MSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN },
-#if 0
-    // See Note 1.
-    { SNaN, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
-    { SNaN, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
-    { SNaN, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
-    { SNaN, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
-    { SNaN, QNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
-    { SNaN, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
-    { SNaN, PNormalValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
-    { SNaN, MNormalValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
-    { SNaN, PLargestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
-    { SNaN, MLargestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
-    { SNaN, PSmallestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
-    { SNaN, MSmallestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
-    { SNaN, PSmallestNormalized, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
-    { SNaN, MSmallestNormalized, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
-#endif
+    { SNaN, PInf, "nan1", APFloat::opInvalidOp, APFloat::fcNaN },
+    { SNaN, MInf, "nan1", APFloat::opInvalidOp, APFloat::fcNaN },
+    { SNaN, PZero, "nan1", APFloat::opInvalidOp, APFloat::fcNaN },
+    { SNaN, MZero, "nan1", APFloat::opInvalidOp, APFloat::fcNaN },
+    { SNaN, QNaN, "nan1", APFloat::opInvalidOp, APFloat::fcNaN },
+    { SNaN, SNaN, "nan1", APFloat::opInvalidOp, APFloat::fcNaN },
+    { SNaN, PNormalValue, "nan1", APFloat::opInvalidOp, APFloat::fcNaN },
+    { SNaN, MNormalValue, "nan1", APFloat::opInvalidOp, APFloat::fcNaN },
+    { SNaN, PLargestValue, "nan1", APFloat::opInvalidOp, APFloat::fcNaN },
+    { SNaN, MLargestValue, "nan1", APFloat::opInvalidOp, APFloat::fcNaN },
+    { SNaN, PSmallestValue, "nan1", APFloat::opInvalidOp, APFloat::fcNaN },
+    { SNaN, MSmallestValue, "nan1", APFloat::opInvalidOp, APFloat::fcNaN },
+    { SNaN, PSmallestNormalized, "nan1", APFloat::opInvalidOp, APFloat::fcNaN },
+    { SNaN, MSmallestNormalized, "nan1", APFloat::opInvalidOp, APFloat::fcNaN },
     { PNormalValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
     { PNormalValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
     { PNormalValue, PZero, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
     { PNormalValue, MZero, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
     { PNormalValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
-#if 0
-    // See Note 1.
-    { PNormalValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
-#endif
+    { PNormalValue, SNaN, "nan1", APFloat::opInvalidOp, APFloat::fcNaN },
     { PNormalValue, PNormalValue, "0x1p+1", APFloat::opOK, APFloat::fcNormal },
     { PNormalValue, MNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
     { PNormalValue, PLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
@@ -1906,10 +1879,7 @@
     { MNormalValue, PZero, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
     { MNormalValue, MZero, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
     { MNormalValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
-#if 0
-    // See Note 1.
-    { MNormalValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
-#endif
+    { MNormalValue, SNaN, "nan1", APFloat::opInvalidOp, APFloat::fcNaN },
     { MNormalValue, PNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
     { MNormalValue, MNormalValue, "-0x1p+1", APFloat::opOK, APFloat::fcNormal },
     { MNormalValue, PLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
@@ -1923,10 +1893,7 @@
     { PLargestValue, PZero, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
     { PLargestValue, MZero, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
     { PLargestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
-#if 0
-    // See Note 1.
-    { PLargestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
-#endif
+    { PLargestValue, SNaN, "nan1", APFloat::opInvalidOp, APFloat::fcNaN },
     { PLargestValue, PNormalValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
     { PLargestValue, MNormalValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
     { PLargestValue, PLargestValue, "inf", OverflowStatus, APFloat::fcInfinity },
@@ -1940,10 +1907,7 @@
     { MLargestValue, PZero, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
     { MLargestValue, MZero, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
     { MLargestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
-#if 0
-    // See Note 1.
-    { MLargestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
-#endif
+    { MLargestValue, SNaN, "nan1", APFloat::opInvalidOp, APFloat::fcNaN },
     { MLargestValue, PNormalValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
     { MLargestValue, MNormalValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
     { MLargestValue, PLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
@@ -1957,10 +1921,7 @@
     { PSmallestValue, PZero, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
     { PSmallestValue, MZero, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
     { PSmallestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
-#if 0
-    // See Note 1.
-    { PSmallestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
-#endif
+    { PSmallestValue, SNaN, "nan1", APFloat::opInvalidOp, APFloat::fcNaN },
     { PSmallestValue, PNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
     { PSmallestValue, MNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
     { PSmallestValue, PLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
@@ -1974,10 +1935,7 @@
     { MSmallestValue, PZero, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
     { MSmallestValue, MZero, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
     { MSmallestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
-#if 0
-    // See Note 1.
-    { MSmallestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
-#endif
+    { MSmallestValue, SNaN, "nan1", APFloat::opInvalidOp, APFloat::fcNaN },
     { MSmallestValue, PNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
     { MSmallestValue, MNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
     { MSmallestValue, PLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
@@ -1991,10 +1949,7 @@
     { PSmallestNormalized, PZero, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
     { PSmallestNormalized, MZero, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
     { PSmallestNormalized, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
-#if 0
-// See Note 1.
-    { PSmallestNormalized, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
-#endif
+    { PSmallestNormalized, SNaN, "nan1", APFloat::opInvalidOp, APFloat::fcNaN },
     { PSmallestNormalized, PNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
     { PSmallestNormalized, MNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
     { PSmallestNormalized, PLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
@@ -2008,10 +1963,7 @@
     { MSmallestNormalized, PZero, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
     { MSmallestNormalized, MZero, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
     { MSmallestNormalized, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
-#if 0
-    // See Note 1.
-    { MSmallestNormalized, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
-#endif
+    { MSmallestNormalized, SNaN, "nan1", APFloat::opInvalidOp, APFloat::fcNaN },
     { MSmallestNormalized, PNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
     { MSmallestNormalized, MNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
     { MSmallestNormalized, PLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
@@ -2022,7 +1974,7 @@
     { MSmallestNormalized, MSmallestNormalized, "-0x1p-125", APFloat::opOK, APFloat::fcNormal }
   };
 
-  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.add(y, APFloat::rmNearestTiesToEven);
@@ -2038,17 +1990,12 @@
 TEST(APFloatTest, subtract) {
   // 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 SNaN = APFloat(APFloat::IEEEsingle(), "snan1");
   APFloat PNormalValue = APFloat(APFloat::IEEEsingle(), "0x1p+0");
   APFloat MNormalValue = APFloat(APFloat::IEEEsingle(), "-0x1p+0");
   APFloat PLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), false);
@@ -2062,23 +2009,19 @@
 
   const int OverflowStatus = APFloat::opOverflow | APFloat::opInexact;
 
-  const unsigned NumTests = 169;
   struct {
     APFloat x;
     APFloat y;
     const char *result;
     int status;
     int category;
-  } SpecialCaseTests[NumTests] = {
+  } SpecialCaseTests[] = {
     { PInf, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
     { PInf, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
     { 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
+    { PInf, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
+    { PInf, SNaN, "nan1", APFloat::opInvalidOp, APFloat::fcNaN },
     { PInf, PNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity },
     { PInf, MNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity },
     { PInf, PLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
@@ -2091,11 +2034,8 @@
     { MInf, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
     { MInf, PZero, "-inf", APFloat::opOK, APFloat::fcInfinity },
     { MInf, MZero, "-inf", APFloat::opOK, APFloat::fcInfinity },
-    { MInf, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
-#if 0
-// See Note 1.
-    { MInf, SNaN, "-nan", APFloat::opInvalidOp, APFloat::fcNaN },
-#endif
+    { MInf, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
+    { MInf, SNaN, "nan1", APFloat::opInvalidOp, APFloat::fcNaN },
     { MInf, PNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
     { MInf, MNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
     { MInf, PLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
@@ -2108,11 +2048,8 @@
     { PZero, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
     { PZero, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
     { PZero, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
-    { PZero, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
-#if 0
-// See Note 1.
-    { PZero, SNaN, "-nan", APFloat::opInvalidOp, APFloat::fcNaN },
-#endif
+    { PZero, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
+    { PZero, SNaN, "nan1", APFloat::opInvalidOp, APFloat::fcNaN },
     { PZero, PNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
     { PZero, MNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
     { PZero, PLargestValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
@@ -2125,11 +2062,8 @@
     { MZero, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
     { MZero, PZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
     { MZero, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
-    { MZero, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
-#if 0
-// See Note 1.
-    { MZero, SNaN, "-nan", APFloat::opInvalidOp, APFloat::fcNaN },
-#endif
+    { MZero, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
+    { MZero, SNaN, "nan1", APFloat::opInvalidOp, APFloat::fcNaN },
     { MZero, PNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
     { MZero, MNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
     { MZero, PLargestValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
@@ -2143,10 +2077,7 @@
     { QNaN, PZero, "nan", APFloat::opOK, APFloat::fcNaN },
     { QNaN, MZero, "nan", APFloat::opOK, APFloat::fcNaN },
     { QNaN, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
-#if 0
-// See Note 1.
     { QNaN, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
-#endif
     { QNaN, PNormalValue, "nan", APFloat::opOK, APFloat::fcNaN },
     { QNaN, MNormalValue, "nan", APFloat::opOK, APFloat::fcNaN },
     { QNaN, PLargestValue, "nan", APFloat::opOK, APFloat::fcNaN },
@@ -2155,32 +2086,26 @@
     { QNaN, MSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN },
     { QNaN, PSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN },
     { QNaN, MSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN },
-#if 0
-// See Note 1.
-    { SNaN, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
-    { SNaN, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
-    { SNaN, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
-    { SNaN, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
-    { SNaN, QNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
-    { SNaN, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
-    { SNaN, PNormalValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
-    { SNaN, MNormalValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
-    { SNaN, PLargestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
-    { SNaN, MLargestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
-    { SNaN, PSmallestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
-    { SNaN, MSmallestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
-    { SNaN, PSmallestNormalized, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
-    { SNaN, MSmallestNormalized, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
-#endif
+    { SNaN, PInf, "nan1", APFloat::opInvalidOp, APFloat::fcNaN },
+    { SNaN, MInf, "nan1", APFloat::opInvalidOp, APFloat::fcNaN },
+    { SNaN, PZero, "nan1", APFloat::opInvalidOp, APFloat::fcNaN },
+    { SNaN, MZero, "nan1", APFloat::opInvalidOp, APFloat::fcNaN },
+    { SNaN, QNaN, "nan1", APFloat::opInvalidOp, APFloat::fcNaN },
+    { SNaN, SNaN, "nan1", APFloat::opInvalidOp, APFloat::fcNaN },
+    { SNaN, PNormalValue, "nan1", APFloat::opInvalidOp, APFloat::fcNaN },
+    { SNaN, MNormalValue, "nan1", APFloat::opInvalidOp, APFloat::fcNaN },
+    { SNaN, PLargestValue, "nan1", APFloat::opInvalidOp, APFloat::fcNaN },
+    { SNaN, MLargestValue, "nan1", APFloat::opInvalidOp, APFloat::fcNaN },
+    { SNaN, PSmallestValue, "nan1", APFloat::opInvalidOp, APFloat::fcNaN },
+    { SNaN, MSmallestValue, "nan1", APFloat::opInvalidOp, APFloat::fcNaN },
+    { SNaN, PSmallestNormalized, "nan1", APFloat::opInvalidOp, APFloat::fcNaN },
+    { SNaN, MSmallestNormalized, "nan1", APFloat::opInvalidOp, APFloat::fcNaN },
     { PNormalValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
     { PNormalValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
     { PNormalValue, PZero, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
     { PNormalValue, MZero, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
-    { PNormalValue, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
-#if 0
-// See Note 1.
-    { PNormalValue, SNaN, "-nan", APFloat::opInvalidOp, APFloat::fcNaN },
-#endif
+    { PNormalValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
+    { PNormalValue, SNaN, "nan1", APFloat::opInvalidOp, APFloat::fcNaN },
     { PNormalValue, PNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
     { PNormalValue, MNormalValue, "0x1p+1", APFloat::opOK, APFloat::fcNormal },
     { PNormalValue, PLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
@@ -2193,11 +2118,8 @@
     { MNormalValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
     { MNormalValue, PZero, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
     { MNormalValue, MZero, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
-    { MNormalValue, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
-#if 0
-// See Note 1.
-    { MNormalValue, SNaN, "-nan", APFloat::opInvalidOp, APFloat::fcNaN },
-#endif
+    { MNormalValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
+    { MNormalValue, SNaN, "nan1", APFloat::opInvalidOp, APFloat::fcNaN },
     { MNormalValue, PNormalValue, "-0x1p+1", APFloat::opOK, APFloat::fcNormal },
     { MNormalValue, MNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
     { MNormalValue, PLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
@@ -2210,11 +2132,8 @@
     { PLargestValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
     { PLargestValue, PZero, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
     { PLargestValue, MZero, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
-    { PLargestValue, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
-#if 0
-// See Note 1.
-    { PLargestValue, SNaN, "-nan", APFloat::opInvalidOp, APFloat::fcNaN },
-#endif
+    { PLargestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
+    { PLargestValue, SNaN, "nan1", APFloat::opInvalidOp, APFloat::fcNaN },
     { PLargestValue, PNormalValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
     { PLargestValue, MNormalValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
     { PLargestValue, PLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
@@ -2227,11 +2146,8 @@
     { MLargestValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
     { MLargestValue, PZero, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
     { MLargestValue, MZero, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
-    { MLargestValue, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
-#if 0
-// See Note 1.
-    { MLargestValue, SNaN, "-nan", APFloat::opInvalidOp, APFloat::fcNaN },
-#endif
+    { MLargestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
+    { MLargestValue, SNaN, "nan1", APFloat::opInvalidOp, APFloat::fcNaN },
     { MLargestValue, PNormalValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
     { MLargestValue, MNormalValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
     { MLargestValue, PLargestValue, "-inf", OverflowStatus, APFloat::fcInfinity },
@@ -2244,11 +2160,8 @@
     { PSmallestValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
     { PSmallestValue, PZero, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
     { PSmallestValue, MZero, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
-    { PSmallestValue, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
-#if 0
-// See Note 1.
-    { PSmallestValue, SNaN, "-nan", APFloat::opInvalidOp, APFloat::fcNaN },
-#endif
+    { PSmallestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
+    { PSmallestValue, SNaN, "nan1", APFloat::opInvalidOp, APFloat::fcNaN },
     { PSmallestValue, PNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
     { PSmallestValue, MNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
     { PSmallestValue, PLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
@@ -2261,11 +2174,8 @@
     { MSmallestValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
     { MSmallestValue, PZero, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
     { MSmallestValue, MZero, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
-    { MSmallestValue, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
-#if 0
-// See Note 1.
-    { MSmallestValue, SNaN, "-nan", APFloat::opInvalidOp, APFloat::fcNaN },
-#endif
+    { MSmallestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
+    { MSmallestValue, SNaN, "nan1", APFloat::opInvalidOp, APFloat::fcNaN },
     { MSmallestValue, PNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
     { MSmallestValue, MNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
     { MSmallestValue, PLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
@@ -2278,11 +2188,8 @@
     { PSmallestNormalized, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
     { PSmallestNormalized, PZero, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
     { PSmallestNormalized, MZero, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
-    { PSmallestNormalized, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
-#if 0
-// See Note 1.
-    { PSmallestNormalized, SNaN, "-nan", APFloat::opInvalidOp, APFloat::fcNaN },
-#endif
+    { PSmallestNormalized, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
+    { PSmallestNormalized, SNaN, "nan1", APFloat::opInvalidOp, APFloat::fcNaN },
     { PSmallestNormalized, PNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
     { PSmallestNormalized, MNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
     { PSmallestNormalized, PLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
@@ -2295,11 +2202,8 @@
     { MSmallestNormalized, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
     { MSmallestNormalized, PZero, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
     { MSmallestNormalized, MZero, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
-    { MSmallestNormalized, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
-#if 0
-// See Note 1.
-    { MSmallestNormalized, SNaN, "-nan", APFloat::opInvalidOp, APFloat::fcNaN },
-#endif
+    { MSmallestNormalized, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
+    { MSmallestNormalized, SNaN, "nan1", APFloat::opInvalidOp, APFloat::fcNaN },
     { MSmallestNormalized, PNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
     { MSmallestNormalized, MNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
     { MSmallestNormalized, PLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
@@ -2310,7 +2214,7 @@
     { MSmallestNormalized, MSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero }
   };
 
-  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.subtract(y, APFloat::rmNearestTiesToEven);
@@ -2326,17 +2230,12 @@
 TEST(APFloatTest, multiply) {
   // 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 SNaN = APFloat(APFloat::IEEEsingle(), "snan1");
   APFloat PNormalValue = APFloat(APFloat::IEEEsingle(), "0x1p+0");
   APFloat MNormalValue = APFloat(APFloat::IEEEsingle(), "-0x1p+0");
   APFloat PLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), false);
@@ -2351,23 +2250,19 @@
   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] = {
+  } 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
+    { PInf, SNaN, "nan1", APFloat::opInvalidOp, APFloat::fcNaN },
     { PInf, PNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity },
     { PInf, MNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
     { PInf, PLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
@@ -2381,10 +2276,7 @@
     { MInf, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
     { MInf, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
     { MInf, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
-#if 0
-// See Note 1.
-    { MInf, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
-#endif
+    { MInf, SNaN, "nan1", APFloat::opInvalidOp, APFloat::fcNaN },
     { MInf, PNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
     { MInf, MNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity },
     { MInf, PLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
@@ -2398,10 +2290,7 @@
     { PZero, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
     { PZero, MZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
     { PZero, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
-#if 0
-// See Note 1.
-    { PZero, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
-#endif
+    { PZero, SNaN, "nan1", APFloat::opInvalidOp, APFloat::fcNaN },
     { PZero, PNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
     { PZero, MNormalValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
     { PZero, PLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
@@ -2415,10 +2304,7 @@
     { MZero, PZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
     { MZero, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
     { MZero, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
-#if 0
-// See Note 1.
-    { MZero, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
-#endif
+    { MZero, SNaN, "nan1", APFloat::opInvalidOp, APFloat::fcNaN },
     { MZero, PNormalValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
     { MZero, MNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
     { MZero, PLargestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
@@ -2432,10 +2318,7 @@
     { QNaN, PZero, "nan", APFloat::opOK, APFloat::fcNaN },
     { QNaN, MZero, "nan", APFloat::opOK, APFloat::fcNaN },
     { QNaN, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
-#if 0
-// See Note 1.
     { QNaN, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
-#endif
     { QNaN, PNormalValue, "nan", APFloat::opOK, APFloat::fcNaN },
     { QNaN, MNormalValue, "nan", APFloat::opOK, APFloat::fcNaN },
     { QNaN, PLargestValue, "nan", APFloat::opOK, APFloat::fcNaN },
@@ -2444,32 +2327,26 @@
     { QNaN, MSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN },
     { QNaN, PSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN },
     { QNaN, MSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN },
-#if 0
-// See Note 1.
-    { SNaN, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
-    { SNaN, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
-    { SNaN, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
-    { SNaN, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
-    { SNaN, QNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
-    { SNaN, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
-    { SNaN, PNormalValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
-    { SNaN, MNormalValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
-    { SNaN, PLargestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
-    { SNaN, MLargestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
-    { SNaN, PSmallestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
-    { SNaN, MSmallestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
-    { SNaN, PSmallestNormalized, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
-    { SNaN, MSmallestNormalized, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
-#endif
+    { SNaN, PInf, "nan1", APFloat::opInvalidOp, APFloat::fcNaN },
+    { SNaN, MInf, "nan1", APFloat::opInvalidOp, APFloat::fcNaN },
+    { SNaN, PZero, "nan1", APFloat::opInvalidOp, APFloat::fcNaN },
+    { SNaN, MZero, "nan1", APFloat::opInvalidOp, APFloat::fcNaN },
+    { SNaN, QNaN, "nan1", APFloat::opInvalidOp, APFloat::fcNaN },
+    { SNaN, SNaN, "nan1", APFloat::opInvalidOp, APFloat::fcNaN },
+    { SNaN, PNormalValue, "nan1", APFloat::opInvalidOp, APFloat::fcNaN },
+    { SNaN, MNormalValue, "nan1", APFloat::opInvalidOp, APFloat::fcNaN },
+    { SNaN, PLargestValue, "nan1", APFloat::opInvalidOp, APFloat::fcNaN },
+    { SNaN, MLargestValue, "nan1", APFloat::opInvalidOp, APFloat::fcNaN },
+    { SNaN, PSmallestValue, "nan1", APFloat::opInvalidOp, APFloat::fcNaN },
+    { SNaN, MSmallestValue, "nan1", APFloat::opInvalidOp, APFloat::fcNaN },
+    { SNaN, PSmallestNormalized, "nan1", APFloat::opInvalidOp, APFloat::fcNaN },
+    { SNaN, MSmallestNormalized, "nan1", APFloat::opInvalidOp, APFloat::fcNaN },
     { PNormalValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
     { PNormalValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
     { PNormalValue, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
     { PNormalValue, MZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
     { PNormalValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
-#if 0
-// See Note 1.
-    { PNormalValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
-#endif
+    { PNormalValue, SNaN, "nan1", APFloat::opInvalidOp, APFloat::fcNaN },
     { PNormalValue, PNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
     { PNormalValue, MNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
     { PNormalValue, PLargestValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
@@ -2483,10 +2360,7 @@
     { MNormalValue, PZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
     { MNormalValue, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
     { MNormalValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
-#if 0
-// See Note 1.
-    { MNormalValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
-#endif
+    { MNormalValue, SNaN, "nan1", APFloat::opInvalidOp, APFloat::fcNaN },
     { MNormalValue, PNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
     { MNormalValue, MNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
     { MNormalValue, PLargestValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
@@ -2500,10 +2374,7 @@
     { PLargestValue, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
     { PLargestValue, MZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
     { PLargestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
-#if 0
-// See Note 1.
-    { PLargestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
-#endif
+    { PLargestValue, SNaN, "nan1", APFloat::opInvalidOp, APFloat::fcNaN },
     { PLargestValue, PNormalValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
     { PLargestValue, MNormalValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
     { PLargestValue, PLargestValue, "inf", OverflowStatus, APFloat::fcInfinity },
@@ -2517,10 +2388,7 @@
     { MLargestValue, PZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
     { MLargestValue, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
     { MLargestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
-#if 0
-// See Note 1.
-    { MLargestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
-#endif
+    { MLargestValue, SNaN, "nan1", APFloat::opInvalidOp, APFloat::fcNaN },
     { MLargestValue, PNormalValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
     { MLargestValue, MNormalValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
     { MLargestValue, PLargestValue, "-inf", OverflowStatus, APFloat::fcInfinity },
@@ -2534,10 +2402,7 @@
     { PSmallestValue, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
     { PSmallestValue, MZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
     { PSmallestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
-#if 0
-// See Note 1.
-    { PSmallestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
-#endif
+    { PSmallestValue, SNaN, "nan1", APFloat::opInvalidOp, APFloat::fcNaN },
     { PSmallestValue, PNormalValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
     { PSmallestValue, MNormalValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
     { PSmallestValue, PLargestValue, "0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal },
@@ -2551,10 +2416,7 @@
     { MSmallestValue, PZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
     { MSmallestValue, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
     { MSmallestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
-#if 0
-// See Note 1.
-    { MSmallestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
-#endif
+    { MSmallestValue, SNaN, "nan1", APFloat::opInvalidOp, APFloat::fcNaN },
     { MSmallestValue, PNormalValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
     { MSmallestValue, MNormalValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
     { MSmallestValue, PLargestValue, "-0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal },
@@ -2568,10 +2430,7 @@
     { PSmallestNormalized, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
     { PSmallestNormalized, MZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
     { PSmallestNormalized, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
-#if 0
-// See Note 1.
-    { PSmallestNormalized, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
-#endif
+    { PSmallestNormalized, SNaN, "nan1", APFloat::opInvalidOp, APFloat::fcNaN },
     { PSmallestNormalized, PNormalValue, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
     { PSmallestNormalized, MNormalValue, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
     { PSmallestNormalized, PLargestValue, "0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal },
@@ -2585,10 +2444,7 @@
     { MSmallestNormalized, PZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
     { MSmallestNormalized, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
     { MSmallestNormalized, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
-#if 0
-// See Note 1.
-    { MSmallestNormalized, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
-#endif
+    { MSmallestNormalized, SNaN, "nan1", APFloat::opInvalidOp, APFloat::fcNaN },
     { 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 },
@@ -2599,7 +2455,7 @@
     { MSmallestNormalized, MSmallestNormalized, "0x0p+0", UnderflowStatus, APFloat::fcZero }
   };
 
-  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);
@@ -2626,17 +2482,12 @@
 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 SNaN = APFloat(APFloat::IEEEsingle(), "snan1");
   APFloat PNormalValue = APFloat(APFloat::IEEEsingle(), "0x1p+0");
   APFloat MNormalValue = APFloat(APFloat::IEEEsingle(), "-0x1p+0");
   APFloat PLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), false);
@@ -2651,23 +2502,19 @@
   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] = {
+  } 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
+    { PInf, SNaN, "nan1", APFloat::opInvalidOp, APFloat::fcNaN },
     { PInf, PNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity },
     { PInf, MNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
     { PInf, PLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
@@ -2681,10 +2528,7 @@
     { MInf, PZero, "-inf", APFloat::opOK, APFloat::fcInfinity },
     { MInf, MZero, "inf", APFloat::opOK, APFloat::fcInfinity },
     { MInf, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
-#if 0
-// See Note 1.
-    { MInf, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
-#endif
+    { MInf, SNaN, "nan1", APFloat::opInvalidOp, APFloat::fcNaN },
     { MInf, PNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
     { MInf, MNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity },
     { MInf, PLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
@@ -2698,10 +2542,7 @@
     { PZero, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
     { PZero, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
     { PZero, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
-#if 0
-// See Note 1.
-    { PZero, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
-#endif
+    { PZero, SNaN, "nan1", APFloat::opInvalidOp, APFloat::fcNaN },
     { PZero, PNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
     { PZero, MNormalValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
     { PZero, PLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
@@ -2715,10 +2556,7 @@
     { MZero, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
     { MZero, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
     { MZero, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
-#if 0
-// See Note 1.
-    { MZero, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
-#endif
+    { MZero, SNaN, "nan1", APFloat::opInvalidOp, APFloat::fcNaN },
     { MZero, PNormalValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
     { MZero, MNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
     { MZero, PLargestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
@@ -2732,10 +2570,7 @@
     { QNaN, PZero, "nan", APFloat::opOK, APFloat::fcNaN },
     { QNaN, MZero, "nan", APFloat::opOK, APFloat::fcNaN },
     { QNaN, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
-#if 0
-// See Note 1.
     { QNaN, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
-#endif
     { QNaN, PNormalValue, "nan", APFloat::opOK, APFloat::fcNaN },
     { QNaN, MNormalValue, "nan", APFloat::opOK, APFloat::fcNaN },
     { QNaN, PLargestValue, "nan", APFloat::opOK, APFloat::fcNaN },
@@ -2744,32 +2579,26 @@
     { QNaN, MSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN },
     { QNaN, PSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN },
     { QNaN, MSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN },
-#if 0
-// See Note 1.
-    { SNaN, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
-    { SNaN, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
-    { SNaN, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
-    { SNaN, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
-    { SNaN, QNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
-    { SNaN, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
-    { SNaN, PNormalValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
-    { SNaN, MNormalValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
-    { SNaN, PLargestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
-    { SNaN, MLargestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
-    { SNaN, PSmallestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
-    { SNaN, MSmallestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
-    { SNaN, PSmallestNormalized, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
-    { SNaN, MSmallestNormalized, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
-#endif
+    { SNaN, PInf, "nan1", APFloat::opInvalidOp, APFloat::fcNaN },
+    { SNaN, MInf, "nan1", APFloat::opInvalidOp, APFloat::fcNaN },
+    { SNaN, PZero, "nan1", APFloat::opInvalidOp, APFloat::fcNaN },
+    { SNaN, MZero, "nan1", APFloat::opInvalidOp, APFloat::fcNaN },
+    { SNaN, QNaN, "nan1", APFloat::opInvalidOp, APFloat::fcNaN },
+    { SNaN, SNaN, "nan1", APFloat::opInvalidOp, APFloat::fcNaN },
+    { SNaN, PNormalValue, "nan1", APFloat::opInvalidOp, APFloat::fcNaN },
+    { SNaN, MNormalValue, "nan1", APFloat::opInvalidOp, APFloat::fcNaN },
+    { SNaN, PLargestValue, "nan1", APFloat::opInvalidOp, APFloat::fcNaN },
+    { SNaN, MLargestValue, "nan1", APFloat::opInvalidOp, APFloat::fcNaN },
+    { SNaN, PSmallestValue, "nan1", APFloat::opInvalidOp, APFloat::fcNaN },
+    { SNaN, MSmallestValue, "nan1", APFloat::opInvalidOp, APFloat::fcNaN },
+    { SNaN, PSmallestNormalized, "nan1", APFloat::opInvalidOp, APFloat::fcNaN },
+    { SNaN, MSmallestNormalized, "nan1", APFloat::opInvalidOp, APFloat::fcNaN },
     { PNormalValue, PInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
     { PNormalValue, MInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
     { PNormalValue, PZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity },
     { PNormalValue, MZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity },
     { PNormalValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
-#if 0
-// See Note 1.
-    { PNormalValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
-#endif
+    { PNormalValue, SNaN, "nan1", APFloat::opInvalidOp, APFloat::fcNaN },
     { PNormalValue, PNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
     { PNormalValue, MNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
     { PNormalValue, PLargestValue, "0x1p-128", UnderflowStatus, APFloat::fcNormal },
@@ -2783,10 +2612,7 @@
     { MNormalValue, PZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity },
     { MNormalValue, MZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity },
     { MNormalValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
-#if 0
-// See Note 1.
-    { MNormalValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
-#endif
+    { MNormalValue, SNaN, "nan1", APFloat::opInvalidOp, APFloat::fcNaN },
     { MNormalValue, PNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
     { MNormalValue, MNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
     { MNormalValue, PLargestValue, "-0x1p-128", UnderflowStatus, APFloat::fcNormal },
@@ -2800,10 +2626,7 @@
     { PLargestValue, PZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity },
     { PLargestValue, MZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity },
     { PLargestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
-#if 0
-// See Note 1.
-    { PLargestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
-#endif
+    { PLargestValue, SNaN, "nan1", APFloat::opInvalidOp, APFloat::fcNaN },
     { PLargestValue, PNormalValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
     { PLargestValue, MNormalValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
     { PLargestValue, PLargestValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
@@ -2817,10 +2640,7 @@
     { MLargestValue, PZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity },
     { MLargestValue, MZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity },
     { MLargestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
-#if 0
-// See Note 1.
-    { MLargestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
-#endif
+    { MLargestValue, SNaN, "nan1", APFloat::opInvalidOp, APFloat::fcNaN },
     { MLargestValue, PNormalValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
     { MLargestValue, MNormalValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
     { MLargestValue, PLargestValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
@@ -2834,10 +2654,7 @@
     { PSmallestValue, PZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity },
     { PSmallestValue, MZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity },
     { PSmallestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
-#if 0
-// See Note 1.
-    { PSmallestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
-#endif
+    { PSmallestValue, SNaN, "nan1", APFloat::opInvalidOp, APFloat::fcNaN },
     { PSmallestValue, PNormalValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
     { PSmallestValue, MNormalValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
     { PSmallestValue, PLargestValue, "0x0p+0", UnderflowStatus, APFloat::fcZero },
@@ -2851,10 +2668,7 @@
     { MSmallestValue, PZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity },
     { MSmallestValue, MZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity },
     { MSmallestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
-#if 0
-// See Note 1.
-    { MSmallestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
-#endif
+    { MSmallestValue, SNaN, "nan1", APFloat::opInvalidOp, APFloat::fcNaN },
     { MSmallestValue, PNormalValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
     { MSmallestValue, MNormalValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
     { MSmallestValue, PLargestValue, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
@@ -2868,10 +2682,7 @@
     { PSmallestNormalized, PZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity },
     { PSmallestNormalized, MZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity },
     { PSmallestNormalized, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
-#if 0
-// See Note 1.
-    { PSmallestNormalized, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
-#endif
+    { PSmallestNormalized, SNaN, "nan1", APFloat::opInvalidOp, APFloat::fcNaN },
     { PSmallestNormalized, PNormalValue, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
     { PSmallestNormalized, MNormalValue, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
     { PSmallestNormalized, PLargestValue, "0x0p+0", UnderflowStatus, APFloat::fcZero },
@@ -2885,10 +2696,7 @@
     { MSmallestNormalized, PZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity },
     { MSmallestNormalized, MZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity },
     { MSmallestNormalized, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
-#if 0
-// See Note 1.
-    { MSmallestNormalized, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
-#endif
+    { MSmallestNormalized, SNaN, "nan1", APFloat::opInvalidOp, APFloat::fcNaN },
     { MSmallestNormalized, PNormalValue, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
     { MSmallestNormalized, MNormalValue, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
     { MSmallestNormalized, PLargestValue, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
@@ -2899,7 +2707,7 @@
     { MSmallestNormalized, MSmallestNormalized, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
   };
 
-  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);