diff --git a/lib/Support/APFloat.cpp b/lib/Support/APFloat.cpp index bc8e1d0c25e..34bc6b6dd6b 100644 --- a/lib/Support/APFloat.cpp +++ b/lib/Support/APFloat.cpp @@ -1354,6 +1354,7 @@ APFloat::addOrSubtractSpecials(const APFloat &rhs, bool subtract) case PackCategoriesIntoKey(fcZero, fcNaN): case PackCategoriesIntoKey(fcNormal, fcNaN): case PackCategoriesIntoKey(fcInfinity, fcNaN): + sign = false; category = fcNaN; copySignificand(rhs); return opOK; @@ -1472,11 +1473,13 @@ APFloat::multiplySpecials(const APFloat &rhs) 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): + sign = false; category = fcNaN; copySignificand(rhs); return opOK; @@ -1510,21 +1513,20 @@ APFloat::divideSpecials(const APFloat &rhs) default: llvm_unreachable(0); - case PackCategoriesIntoKey(fcNaN, fcZero): - case PackCategoriesIntoKey(fcNaN, fcNormal): - case PackCategoriesIntoKey(fcNaN, fcInfinity): - case PackCategoriesIntoKey(fcNaN, fcNaN): - case PackCategoriesIntoKey(fcInfinity, fcZero): - case PackCategoriesIntoKey(fcInfinity, fcNormal): - case PackCategoriesIntoKey(fcZero, fcInfinity): - case PackCategoriesIntoKey(fcZero, fcNormal): - return opOK; - case PackCategoriesIntoKey(fcZero, fcNaN): case PackCategoriesIntoKey(fcNormal, fcNaN): case PackCategoriesIntoKey(fcInfinity, fcNaN): category = fcNaN; copySignificand(rhs); + case PackCategoriesIntoKey(fcNaN, fcZero): + case PackCategoriesIntoKey(fcNaN, fcNormal): + case PackCategoriesIntoKey(fcNaN, fcInfinity): + case PackCategoriesIntoKey(fcNaN, fcNaN): + sign = false; + case PackCategoriesIntoKey(fcInfinity, fcZero): + case PackCategoriesIntoKey(fcInfinity, fcNormal): + case PackCategoriesIntoKey(fcZero, fcInfinity): + case PackCategoriesIntoKey(fcZero, fcNormal): return opOK; case PackCategoriesIntoKey(fcNormal, fcInfinity): @@ -1564,6 +1566,7 @@ APFloat::modSpecials(const APFloat &rhs) case PackCategoriesIntoKey(fcZero, fcNaN): case PackCategoriesIntoKey(fcNormal, fcNaN): case PackCategoriesIntoKey(fcInfinity, fcNaN): + sign = false; category = fcNaN; copySignificand(rhs); return opOK; diff --git a/unittests/ADT/APFloatTest.cpp b/unittests/ADT/APFloatTest.cpp index 1d6d8caa321..3b69de2a52f 100644 --- a/unittests/ADT/APFloatTest.cpp +++ b/unittests/ADT/APFloatTest.cpp @@ -1523,10 +1523,6 @@ TEST(APFloatTest, add) { // 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. - // 2. It seems that add(-x, NaN) = -NaN but add(NaN, -x) = NaN. This is an - // inconsistency that should be looked into. IEEE-754R specifies that the - // interpretation of the sign of NaN is unspecified. We should always have NaN - // be positive since that is one less thing for the compiler to deal with. APFloat PInf = APFloat::getInf(APFloat::IEEEsingle, false); APFloat MInf = APFloat::getInf(APFloat::IEEEsingle, true); @@ -1576,8 +1572,7 @@ TEST(APFloatTest, add) { { MInf, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity }, { MInf, PZero, "-inf", APFloat::opOK, APFloat::fcInfinity }, { MInf, MZero, "-inf", APFloat::opOK, APFloat::fcInfinity }, - // See Note 2. - { MInf, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN }, + { MInf, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, #if 0 // See Note 1. { MInf, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, @@ -1611,8 +1606,7 @@ TEST(APFloatTest, add) { { MZero, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity }, { MZero, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero }, { MZero, MZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, - // See Note 2. - { MZero, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN }, + { MZero, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, #if 0 // See Note 1. { MZero, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, @@ -1680,8 +1674,7 @@ TEST(APFloatTest, add) { { MNormalValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity }, { MNormalValue, PZero, "-0x1p+0", APFloat::opOK, APFloat::fcNormal }, { MNormalValue, MZero, "-0x1p+0", APFloat::opOK, APFloat::fcNormal }, - // See Note 2. - { MNormalValue, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN }, + { MNormalValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, #if 0 // See Note 1. { MNormalValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, @@ -1715,8 +1708,7 @@ TEST(APFloatTest, add) { { 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 }, - // See Note 2. - { MLargestValue, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN }, + { MLargestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, #if 0 // See Note 1. { MLargestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, @@ -1750,8 +1742,7 @@ TEST(APFloatTest, add) { { MSmallestValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity }, { MSmallestValue, PZero, "-0x1p-149", APFloat::opOK, APFloat::fcNormal }, { MSmallestValue, MZero, "-0x1p-149", APFloat::opOK, APFloat::fcNormal }, - // See Note 2. - { MSmallestValue, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN }, + { MSmallestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, #if 0 // See Note 1. { MSmallestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, @@ -1785,8 +1776,7 @@ TEST(APFloatTest, add) { { MSmallestNormalized, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity }, { MSmallestNormalized, PZero, "-0x1p-126", APFloat::opOK, APFloat::fcNormal }, { MSmallestNormalized, MZero, "-0x1p-126", APFloat::opOK, APFloat::fcNormal }, - // See Note 2. - { MSmallestNormalized, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN }, + { MSmallestNormalized, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, #if 0 // See Note 1. { MSmallestNormalized, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, @@ -1821,10 +1811,6 @@ TEST(APFloatTest, subtract) { // 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. - // 2. It seems that sub(-x, NaN) = -NaN but sub(NaN, -x) = NaN. This is an - // inconsistency that should be looked into. IEEE-754R specifies that the - // interpretation of the sign of NaN is unspecified. We should always have NaN - // be positive since that is one less thing for the compiler to deal with. APFloat PInf = APFloat::getInf(APFloat::IEEEsingle, false); APFloat MInf = APFloat::getInf(APFloat::IEEEsingle, true); @@ -1874,8 +1860,7 @@ TEST(APFloatTest, subtract) { { MInf, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, { MInf, PZero, "-inf", APFloat::opOK, APFloat::fcInfinity }, { MInf, MZero, "-inf", APFloat::opOK, APFloat::fcInfinity }, - // See Note 2. - { MInf, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN }, + { MInf, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, #if 0 // See Note 1. { MInf, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, @@ -1909,8 +1894,7 @@ TEST(APFloatTest, subtract) { { MZero, MInf, "inf", APFloat::opOK, APFloat::fcInfinity }, { MZero, PZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, { MZero, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero }, - // See Note 2. - { MZero, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN }, + { MZero, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, #if 0 // See Note 1. { MZero, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, @@ -1978,8 +1962,7 @@ TEST(APFloatTest, subtract) { { MNormalValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity }, { MNormalValue, PZero, "-0x1p+0", APFloat::opOK, APFloat::fcNormal }, { MNormalValue, MZero, "-0x1p+0", APFloat::opOK, APFloat::fcNormal }, - // See Note 2. - { MNormalValue, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN }, + { MNormalValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, #if 0 // See Note 1. { MNormalValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, @@ -2013,8 +1996,7 @@ TEST(APFloatTest, subtract) { { 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 }, - // See Note 2. - { MLargestValue, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN }, + { MLargestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, #if 0 // See Note 1. { MLargestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, @@ -2048,8 +2030,7 @@ TEST(APFloatTest, subtract) { { MSmallestValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity }, { MSmallestValue, PZero, "-0x1p-149", APFloat::opOK, APFloat::fcNormal }, { MSmallestValue, MZero, "-0x1p-149", APFloat::opOK, APFloat::fcNormal }, - // See Note 2. - { MSmallestValue, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN }, + { MSmallestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, #if 0 // See Note 1. { MSmallestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, @@ -2083,8 +2064,7 @@ TEST(APFloatTest, subtract) { { MSmallestNormalized, MInf, "inf", APFloat::opOK, APFloat::fcInfinity }, { MSmallestNormalized, PZero, "-0x1p-126", APFloat::opOK, APFloat::fcNormal }, { MSmallestNormalized, MZero, "-0x1p-126", APFloat::opOK, APFloat::fcNormal }, - // See Note 2. - { MSmallestNormalized, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN }, + { MSmallestNormalized, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, #if 0 // See Note 1. { MSmallestNormalized, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, @@ -2119,9 +2099,6 @@ TEST(APFloatTest, multiply) { // 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. - // 2. It seems that multiply(-x, NaN) = multiply(NaN, -x) = -NaN. IEEE-754R - // leaves the meaning of the sign of NaNs as unspecified. To simplify things, - // we should just assume that NaN is always positive. I will fix this. APFloat PInf = APFloat::getInf(APFloat::IEEEsingle, false); APFloat MInf = APFloat::getInf(APFloat::IEEEsingle, true); @@ -2172,8 +2149,7 @@ TEST(APFloatTest, multiply) { { MInf, MInf, "inf", APFloat::opOK, APFloat::fcInfinity }, { MInf, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, { MInf, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, - // See Note 2. - { MInf, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN }, + { MInf, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, #if 0 // See Note 1. { MInf, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, @@ -2207,8 +2183,7 @@ TEST(APFloatTest, multiply) { { MZero, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, { MZero, PZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, { MZero, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero }, - // See Note 2. - { MZero, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN }, + { MZero, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, #if 0 // See Note 1. { MZero, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, @@ -2222,28 +2197,22 @@ TEST(APFloatTest, multiply) { { MZero, PSmallestNormalized, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, { MZero, MSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero }, { QNaN, PInf, "nan", APFloat::opOK, APFloat::fcNaN }, - // See Note 2. - { QNaN, MInf, "-nan", APFloat::opOK, APFloat::fcNaN }, + { QNaN, MInf, "nan", APFloat::opOK, APFloat::fcNaN }, { QNaN, PZero, "nan", APFloat::opOK, APFloat::fcNaN }, - // See Note 2. - { QNaN, MZero, "-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 }, - // See Note 2. - { QNaN, MNormalValue, "-nan", APFloat::opOK, APFloat::fcNaN }, + { QNaN, MNormalValue, "nan", APFloat::opOK, APFloat::fcNaN }, { QNaN, PLargestValue, "nan", APFloat::opOK, APFloat::fcNaN }, - // See Note 2. - { QNaN, MLargestValue, "-nan", APFloat::opOK, APFloat::fcNaN }, + { QNaN, MLargestValue, "nan", APFloat::opOK, APFloat::fcNaN }, { QNaN, PSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN }, - // See Note 2. - { QNaN, MSmallestValue, "-nan", APFloat::opOK, APFloat::fcNaN }, + { QNaN, MSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN }, { QNaN, PSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN }, - // See Note 2. - { QNaN, MSmallestNormalized, "-nan", APFloat::opOK, APFloat::fcNaN }, + { QNaN, MSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN }, #if 0 // See Note 1. { SNaN, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, @@ -2282,8 +2251,7 @@ TEST(APFloatTest, multiply) { { MNormalValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity }, { MNormalValue, PZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, { MNormalValue, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero }, - // See Note 2. - { MNormalValue, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN }, + { MNormalValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, #if 0 // See Note 1. { MNormalValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, @@ -2317,8 +2285,7 @@ TEST(APFloatTest, multiply) { { MLargestValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity }, { MLargestValue, PZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, { MLargestValue, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero }, - // See Note 2. - { MLargestValue, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN }, + { MLargestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, #if 0 // See Note 1. { MLargestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, @@ -2352,8 +2319,7 @@ TEST(APFloatTest, multiply) { { MSmallestValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity }, { MSmallestValue, PZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, { MSmallestValue, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero }, - // See Note 2. - { MSmallestValue, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN }, + { MSmallestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, #if 0 // See Note 1. { MSmallestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, @@ -2387,8 +2353,7 @@ TEST(APFloatTest, multiply) { { MSmallestNormalized, MInf, "inf", APFloat::opOK, APFloat::fcInfinity }, { MSmallestNormalized, PZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, { MSmallestNormalized, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero }, - // See Note 2. - { MSmallestNormalized, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN }, + { MSmallestNormalized, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, #if 0 // See Note 1. { MSmallestNormalized, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, @@ -2423,9 +2388,6 @@ TEST(APFloatTest, divide) { // 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. - // 2. It seems that divide(-x, NaN) = divide(NaN, -x) = -NaN. IEEE-754R - // leaves the meaning of the sign of NaNs as unspecified. To simplify things, - // we should just assume that NaN is always positive. I will fix this. APFloat PInf = APFloat::getInf(APFloat::IEEEsingle, false); APFloat MInf = APFloat::getInf(APFloat::IEEEsingle, true); @@ -2476,8 +2438,7 @@ TEST(APFloatTest, divide) { { MInf, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, { MInf, PZero, "-inf", APFloat::opOK, APFloat::fcInfinity }, { MInf, MZero, "inf", APFloat::opOK, APFloat::fcInfinity }, - // See Note 2. - { MInf, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN }, + { MInf, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, #if 0 // See Note 1. { MInf, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, @@ -2511,8 +2472,7 @@ TEST(APFloatTest, divide) { { MZero, MInf, "0x0p+0", APFloat::opOK, APFloat::fcZero }, { MZero, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, { MZero, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, - // See Note 2. - { MZero, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN }, + { MZero, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, #if 0 // See Note 1. { MZero, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, @@ -2526,28 +2486,22 @@ TEST(APFloatTest, divide) { { MZero, PSmallestNormalized, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, { MZero, MSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero }, { QNaN, PInf, "nan", APFloat::opOK, APFloat::fcNaN }, - // See Note 2. - { QNaN, MInf, "-nan", APFloat::opOK, APFloat::fcNaN }, + { QNaN, MInf, "nan", APFloat::opOK, APFloat::fcNaN }, { QNaN, PZero, "nan", APFloat::opOK, APFloat::fcNaN }, - // See Note 2. - { QNaN, MZero, "-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 }, - // See Note 2. - { QNaN, MNormalValue, "-nan", APFloat::opOK, APFloat::fcNaN }, + { QNaN, MNormalValue, "nan", APFloat::opOK, APFloat::fcNaN }, { QNaN, PLargestValue, "nan", APFloat::opOK, APFloat::fcNaN }, - // See Note 2. - { QNaN, MLargestValue, "-nan", APFloat::opOK, APFloat::fcNaN }, + { QNaN, MLargestValue, "nan", APFloat::opOK, APFloat::fcNaN }, { QNaN, PSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN }, - // See Note 2. - { QNaN, MSmallestValue, "-nan", APFloat::opOK, APFloat::fcNaN }, + { QNaN, MSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN }, { QNaN, PSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN }, - // See Note 2. - { QNaN, MSmallestNormalized, "-nan", APFloat::opOK, APFloat::fcNaN }, + { QNaN, MSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN }, #if 0 // See Note 1. { SNaN, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, @@ -2586,8 +2540,7 @@ TEST(APFloatTest, divide) { { MNormalValue, MInf, "0x0p+0", APFloat::opOK, APFloat::fcZero }, { MNormalValue, PZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity }, { MNormalValue, MZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity }, - // See Note 2. - { MNormalValue, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN }, + { MNormalValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, #if 0 // See Note 1. { MNormalValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, @@ -2621,8 +2574,7 @@ TEST(APFloatTest, divide) { { MLargestValue, MInf, "0x0p+0", APFloat::opOK, APFloat::fcZero }, { MLargestValue, PZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity }, { MLargestValue, MZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity }, - // See Note 2. - { MLargestValue, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN }, + { MLargestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, #if 0 // See Note 1. { MLargestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, @@ -2656,8 +2608,7 @@ TEST(APFloatTest, divide) { { MSmallestValue, MInf, "0x0p+0", APFloat::opOK, APFloat::fcZero }, { MSmallestValue, PZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity }, { MSmallestValue, MZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity }, - // See Note 2. - { MSmallestValue, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN }, + { MSmallestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, #if 0 // See Note 1. { MSmallestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, @@ -2691,8 +2642,7 @@ TEST(APFloatTest, divide) { { MSmallestNormalized, MInf, "0x0p+0", APFloat::opOK, APFloat::fcZero }, { MSmallestNormalized, PZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity }, { MSmallestNormalized, MZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity }, - // See Note 2. - { MSmallestNormalized, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN }, + { MSmallestNormalized, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, #if 0 // See Note 1. { MSmallestNormalized, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },