[APFloat] Fix IsInteger() for DoubleAPFloat

[davide]

Summary

I'm not sure anybody was using it as the implementation would always assert (as the PR https://bugs.llvm.org/show_bug.cgi?id=34098 shows).

[davide]

Couple of notes:

1. If nobody is using this code, we might as well consider removing it from the tree (as it seems unmaintained, and partly untested).
2. I'm nowhere near an expert in floating point arithmetic, so the amended implementation might be wrong. Comments appreciated.

[scanon]

This looks fine.

[scanon]

... except, please add another test-case where the other component is not an integer as well.

[davide]

Thanks for your review. I added a test for the other case and committed in r311351.

llvm/trunk/lib/Support/APFloat.cpp

if (getCategory() != fcNormal)
     return false;
   DoubleAPFloat Tmp(*this);
   Tmp.makeLargest(this->isNegative());
   return Tmp.compare(*this) == cmpEqual;
 }
 
 bool DoubleAPFloat::isInteger() const {
   assert(Semantics == &semPPCDoubleDouble && "Unexpected Semantics");
-  APFloat Tmp(semPPCDoubleDoubleLegacy);
-  (void)Tmp.add(Floats[0], rmNearestTiesToEven);
-  (void)Tmp.add(Floats[1], rmNearestTiesToEven);
-  return Tmp.isInteger();
+  return Floats[0].isInteger() && Floats[1].isInteger();
 }
 
 void DoubleAPFloat::toString(SmallVectorImpl<char> &Str,
                              unsigned FormatPrecision,
                              unsigned FormatMaxPadding,
                              bool TruncateZero) const {
   assert(Semantics == &semPPCDoubleDouble && "Unexpected Semantics");
   APFloat(semPPCDoubleDoubleLegacy, bitcastToAPInt())

llvm/trunk/unittests/ADT/APFloatTest.cpp

TEST(APFloatTest, isInteger) {
   T = APFloat::getInf(APFloat::IEEEdouble());
   EXPECT_FALSE(T.isInteger());
   T = APFloat::getInf(APFloat::IEEEdouble(), true);
   EXPECT_FALSE(T.isInteger());
   T = APFloat::getLargest(APFloat::IEEEdouble());
   EXPECT_TRUE(T.isInteger());
 }
 
+TEST(DoubleAPFloatTest, isInteger) {
+  APFloat F1(-0.0);
+  APFloat F2(-0.0);
+  llvm::detail::DoubleAPFloat T(APFloat::PPCDoubleDouble(), std::move(F1),
+                                std::move(F2));
+  EXPECT_TRUE(T.isInteger());
+  APFloat F3(3.14159);
+  APFloat F4(-0.0);
+  llvm::detail::DoubleAPFloat T2(APFloat::PPCDoubleDouble(), std::move(F3),
+                                std::move(F4));
+  EXPECT_FALSE(T2.isInteger());
+  APFloat F5(-0.0);
+  APFloat F6(3.14159);
+  llvm::detail::DoubleAPFloat T3(APFloat::PPCDoubleDouble(), std::move(F5),
+                                std::move(F6));
+  EXPECT_FALSE(T3.isInteger());
+}
+
 TEST(APFloatTest, getLargest) {
   EXPECT_EQ(3.402823466e+38f, APFloat::getLargest(APFloat::IEEEsingle()).convertToFloat());
   EXPECT_EQ(1.7976931348623158e+308, APFloat::getLargest(APFloat::IEEEdouble()).convertToDouble());
 }
 
 TEST(APFloatTest, getSmallest) {
   APFloat test = APFloat::getSmallest(APFloat::IEEEsingle(), false);
   APFloat expected = APFloat(APFloat::IEEEsingle(), "0x0.000002p-126");