unittests/ADT/APFloatTest.cpp

   1 //===- llvm/unittest/ADT/APFloat.cpp - APFloat unit tests ---------------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #include "llvm/ADT/APFloat.h"
  11 #include "llvm/ADT/APSInt.h"
  12 #include "llvm/ADT/SmallVector.h"
  13 #include "llvm/Support/FormatVariadic.h"
  14 #include "llvm/Support/raw_ostream.h"
  15 #include "gtest/gtest.h"
  16 #include <cmath>
  17 #include <ostream>
  18 #include <string>
  19 #include <tuple>
  20
  21 using namespace llvm;
  22
  23 static double convertToDoubleFromString(const char *Str) {
  24   llvm::APFloat F(0.0);
  25   F.convertFromString(Str, llvm::APFloat::rmNearestTiesToEven);
  26   return F.convertToDouble();
  27 }
  28
  29 static std::string convertToString(double d, unsigned Prec, unsigned Pad) {
  30   llvm::SmallVector<char, 100> Buffer;
  31   llvm::APFloat F(d);
  32   F.toString(Buffer, Prec, Pad);
  33   return std::string(Buffer.data(), Buffer.size());
  34 }
  35
  36 namespace {
  37
  38 TEST(APFloatTest, isSignaling) {
  39   // We test qNaN, -qNaN, +sNaN, -sNaN with and without payloads. *NOTE* The
  40   // positive/negative distinction is included only since the getQNaN/getSNaN
  41   // API provides the option.
  42   APInt payload = APInt::getOneBitSet(4, 2);
  43   EXPECT_FALSE(APFloat::getQNaN(APFloat::IEEEsingle(), false).isSignaling());
  44   EXPECT_FALSE(APFloat::getQNaN(APFloat::IEEEsingle(), true).isSignaling());
  45   EXPECT_FALSE(APFloat::getQNaN(APFloat::IEEEsingle(), false, &payload).isSignaling());
  46   EXPECT_FALSE(APFloat::getQNaN(APFloat::IEEEsingle(), true, &payload).isSignaling());
  47   EXPECT_TRUE(APFloat::getSNaN(APFloat::IEEEsingle(), false).isSignaling());
  48   EXPECT_TRUE(APFloat::getSNaN(APFloat::IEEEsingle(), true).isSignaling());
  49   EXPECT_TRUE(APFloat::getSNaN(APFloat::IEEEsingle(), false, &payload).isSignaling());
  50   EXPECT_TRUE(APFloat::getSNaN(APFloat::IEEEsingle(), true, &payload).isSignaling());
  51 }
  52
  53 TEST(APFloatTest, next) {
  54
  55   APFloat test(APFloat::IEEEquad(), APFloat::uninitialized);
  56   APFloat expected(APFloat::IEEEquad(), APFloat::uninitialized);
  57
  58   // 1. Test Special Cases Values.
  59   //
  60   // Test all special values for nextUp and nextDown perscribed by IEEE-754R
  61   // 2008. These are:
  62   //   1.  +inf
  63   //   2.  -inf
  64   //   3.  getLargest()
  65   //   4.  -getLargest()
  66   //   5.  getSmallest()
  67   //   6.  -getSmallest()
  68   //   7.  qNaN
  69   //   8.  sNaN
  70   //   9.  +0
  71   //   10. -0
  72
  73   // nextUp(+inf) = +inf.
  74   test = APFloat::getInf(APFloat::IEEEquad(), false);
  75   expected = APFloat::getInf(APFloat::IEEEquad(), false);
  76   EXPECT_EQ(test.next(false), APFloat::opOK);
  77   EXPECT_TRUE(test.isInfinity());
  78   EXPECT_TRUE(!test.isNegative());
  79   EXPECT_TRUE(test.bitwiseIsEqual(expected));
  80
  81   // nextDown(+inf) = -nextUp(-inf) = -(-getLargest()) = getLargest()
  82   test = APFloat::getInf(APFloat::IEEEquad(), false);
  83   expected = APFloat::getLargest(APFloat::IEEEquad(), false);
  84   EXPECT_EQ(test.next(true), APFloat::opOK);
  85   EXPECT_TRUE(!test.isNegative());
  86   EXPECT_TRUE(test.bitwiseIsEqual(expected));
  87
  88   // nextUp(-inf) = -getLargest()
  89   test = APFloat::getInf(APFloat::IEEEquad(), true);
  90   expected = APFloat::getLargest(APFloat::IEEEquad(), true);
  91   EXPECT_EQ(test.next(false), APFloat::opOK);
  92   EXPECT_TRUE(test.isNegative());
  93   EXPECT_TRUE(test.bitwiseIsEqual(expected));
  94
  95   // nextDown(-inf) = -nextUp(+inf) = -(+inf) = -inf.
  96   test = APFloat::getInf(APFloat::IEEEquad(), true);
  97   expected = APFloat::getInf(APFloat::IEEEquad(), true);
  98   EXPECT_EQ(test.next(true), APFloat::opOK);
  99   EXPECT_TRUE(test.isInfinity() && test.isNegative());
 100   EXPECT_TRUE(test.bitwiseIsEqual(expected));
 101
 102   // nextUp(getLargest()) = +inf
 103   test = APFloat::getLargest(APFloat::IEEEquad(), false);
 104   expected = APFloat::getInf(APFloat::IEEEquad(), false);
 105   EXPECT_EQ(test.next(false), APFloat::opOK);
 106   EXPECT_TRUE(test.isInfinity() && !test.isNegative());
 107   EXPECT_TRUE(test.bitwiseIsEqual(expected));
 108
 109   // nextDown(getLargest()) = -nextUp(-getLargest())
 110   //                        = -(-getLargest() + inc)
 111   //                        = getLargest() - inc.
 112   test = APFloat::getLargest(APFloat::IEEEquad(), false);
 113   expected = APFloat(APFloat::IEEEquad(),
 114                      "0x1.fffffffffffffffffffffffffffep+16383");
 115   EXPECT_EQ(test.next(true), APFloat::opOK);
 116   EXPECT_TRUE(!test.isInfinity() && !test.isNegative());
 117   EXPECT_TRUE(test.bitwiseIsEqual(expected));
 118
 119   // nextUp(-getLargest()) = -getLargest() + inc.
 120   test = APFloat::getLargest(APFloat::IEEEquad(), true);
 121   expected = APFloat(APFloat::IEEEquad(),
 122                      "-0x1.fffffffffffffffffffffffffffep+16383");
 123   EXPECT_EQ(test.next(false), APFloat::opOK);
 124   EXPECT_TRUE(test.bitwiseIsEqual(expected));
 125
 126   // nextDown(-getLargest()) = -nextUp(getLargest()) = -(inf) = -inf.
 127   test = APFloat::getLargest(APFloat::IEEEquad(), true);
 128   expected = APFloat::getInf(APFloat::IEEEquad(), true);
 129   EXPECT_EQ(test.next(true), APFloat::opOK);
 130   EXPECT_TRUE(test.isInfinity() && test.isNegative());
 131   EXPECT_TRUE(test.bitwiseIsEqual(expected));
 132
 133   // nextUp(getSmallest()) = getSmallest() + inc.
 134   test = APFloat(APFloat::IEEEquad(), "0x0.0000000000000000000000000001p-16382");
 135   expected = APFloat(APFloat::IEEEquad(),
 136                      "0x0.0000000000000000000000000002p-16382");
 137   EXPECT_EQ(test.next(false), APFloat::opOK);
 138   EXPECT_TRUE(test.bitwiseIsEqual(expected));
 139
 140   // nextDown(getSmallest()) = -nextUp(-getSmallest()) = -(-0) = +0.
 141   test = APFloat(APFloat::IEEEquad(), "0x0.0000000000000000000000000001p-16382");
 142   expected = APFloat::getZero(APFloat::IEEEquad(), false);
 143   EXPECT_EQ(test.next(true), APFloat::opOK);
 144   EXPECT_TRUE(test.isPosZero());
 145   EXPECT_TRUE(test.bitwiseIsEqual(expected));
 146
 147   // nextUp(-getSmallest()) = -0.
 148   test = APFloat(APFloat::IEEEquad(), "-0x0.0000000000000000000000000001p-16382");
 149   expected = APFloat::getZero(APFloat::IEEEquad(), true);
 150   EXPECT_EQ(test.next(false), APFloat::opOK);
 151   EXPECT_TRUE(test.isNegZero());
 152   EXPECT_TRUE(test.bitwiseIsEqual(expected));
 153
 154   // nextDown(-getSmallest()) = -nextUp(getSmallest()) = -getSmallest() - inc.
 155   test = APFloat(APFloat::IEEEquad(), "-0x0.0000000000000000000000000001p-16382");
 156   expected = APFloat(APFloat::IEEEquad(),
 157                      "-0x0.0000000000000000000000000002p-16382");
 158   EXPECT_EQ(test.next(true), APFloat::opOK);
 159   EXPECT_TRUE(test.bitwiseIsEqual(expected));
 160
 161   // nextUp(qNaN) = qNaN
 162   test = APFloat::getQNaN(APFloat::IEEEquad(), false);
 163   expected = APFloat::getQNaN(APFloat::IEEEquad(), false);
 164   EXPECT_EQ(test.next(false), APFloat::opOK);
 165   EXPECT_TRUE(test.bitwiseIsEqual(expected));
 166
 167   // nextDown(qNaN) = qNaN
 168   test = APFloat::getQNaN(APFloat::IEEEquad(), false);
 169   expected = APFloat::getQNaN(APFloat::IEEEquad(), false);
 170   EXPECT_EQ(test.next(true), APFloat::opOK);
 171   EXPECT_TRUE(test.bitwiseIsEqual(expected));
 172
 173   // nextUp(sNaN) = qNaN
 174   test = APFloat::getSNaN(APFloat::IEEEquad(), false);
 175   expected = APFloat::getQNaN(APFloat::IEEEquad(), false);
 176   EXPECT_EQ(test.next(false), APFloat::opInvalidOp);
 177   EXPECT_TRUE(test.bitwiseIsEqual(expected));
 178
 179   // nextDown(sNaN) = qNaN
 180   test = APFloat::getSNaN(APFloat::IEEEquad(), false);
 181   expected = APFloat::getQNaN(APFloat::IEEEquad(), false);
 182   EXPECT_EQ(test.next(true), APFloat::opInvalidOp);
 183   EXPECT_TRUE(test.bitwiseIsEqual(expected));
 184
 185   // nextUp(+0) = +getSmallest()
 186   test = APFloat::getZero(APFloat::IEEEquad(), false);
 187   expected = APFloat::getSmallest(APFloat::IEEEquad(), false);
 188   EXPECT_EQ(test.next(false), APFloat::opOK);
 189   EXPECT_TRUE(test.bitwiseIsEqual(expected));
 190
 191   // nextDown(+0) = -nextUp(-0) = -getSmallest()
 192   test = APFloat::getZero(APFloat::IEEEquad(), false);
 193   expected = APFloat::getSmallest(APFloat::IEEEquad(), true);
 194   EXPECT_EQ(test.next(true), APFloat::opOK);
 195   EXPECT_TRUE(test.bitwiseIsEqual(expected));
 196
 197   // nextUp(-0) = +getSmallest()
 198   test = APFloat::getZero(APFloat::IEEEquad(), true);
 199   expected = APFloat::getSmallest(APFloat::IEEEquad(), false);
 200   EXPECT_EQ(test.next(false), APFloat::opOK);
 201   EXPECT_TRUE(test.bitwiseIsEqual(expected));
 202
 203   // nextDown(-0) = -nextUp(0) = -getSmallest()
 204   test = APFloat::getZero(APFloat::IEEEquad(), true);
 205   expected = APFloat::getSmallest(APFloat::IEEEquad(), true);
 206   EXPECT_EQ(test.next(true), APFloat::opOK);
 207   EXPECT_TRUE(test.bitwiseIsEqual(expected));
 208
 209   // 2. Binade Boundary Tests.
 210
 211   // 2a. Test denormal <-> normal binade boundaries.
 212   //     * nextUp(+Largest Denormal) -> +Smallest Normal.
 213   //     * nextDown(-Largest Denormal) -> -Smallest Normal.
 214   //     * nextUp(-Smallest Normal) -> -Largest Denormal.
 215   //     * nextDown(+Smallest Normal) -> +Largest Denormal.
 216
 217   // nextUp(+Largest Denormal) -> +Smallest Normal.
 218   test = APFloat(APFloat::IEEEquad(), "0x0.ffffffffffffffffffffffffffffp-16382");
 219   expected = APFloat(APFloat::IEEEquad(),
 220                      "0x1.0000000000000000000000000000p-16382");
 221   EXPECT_EQ(test.next(false), APFloat::opOK);
 222   EXPECT_FALSE(test.isDenormal());
 223   EXPECT_TRUE(test.bitwiseIsEqual(expected));
 224
 225   // nextDown(-Largest Denormal) -> -Smallest Normal.
 226   test = APFloat(APFloat::IEEEquad(),
 227                  "-0x0.ffffffffffffffffffffffffffffp-16382");
 228   expected = APFloat(APFloat::IEEEquad(),
 229                      "-0x1.0000000000000000000000000000p-16382");
 230   EXPECT_EQ(test.next(true), APFloat::opOK);
 231   EXPECT_FALSE(test.isDenormal());
 232   EXPECT_TRUE(test.bitwiseIsEqual(expected));
 233
 234   // nextUp(-Smallest Normal) -> -LargestDenormal.
 235   test = APFloat(APFloat::IEEEquad(),
 236                  "-0x1.0000000000000000000000000000p-16382");
 237   expected = APFloat(APFloat::IEEEquad(),
 238                      "-0x0.ffffffffffffffffffffffffffffp-16382");
 239   EXPECT_EQ(test.next(false), APFloat::opOK);
 240   EXPECT_TRUE(test.isDenormal());
 241   EXPECT_TRUE(test.bitwiseIsEqual(expected));
 242
 243   // nextDown(+Smallest Normal) -> +Largest Denormal.
 244   test = APFloat(APFloat::IEEEquad(),
 245                  "+0x1.0000000000000000000000000000p-16382");
 246   expected = APFloat(APFloat::IEEEquad(),
 247                      "+0x0.ffffffffffffffffffffffffffffp-16382");
 248   EXPECT_EQ(test.next(true), APFloat::opOK);
 249   EXPECT_TRUE(test.isDenormal());
 250   EXPECT_TRUE(test.bitwiseIsEqual(expected));
 251
 252   // 2b. Test normal <-> normal binade boundaries.
 253   //     * nextUp(-Normal Binade Boundary) -> -Normal Binade Boundary + 1.
 254   //     * nextDown(+Normal Binade Boundary) -> +Normal Binade Boundary - 1.
 255   //     * nextUp(+Normal Binade Boundary - 1) -> +Normal Binade Boundary.
 256   //     * nextDown(-Normal Binade Boundary + 1) -> -Normal Binade Boundary.
 257
 258   // nextUp(-Normal Binade Boundary) -> -Normal Binade Boundary + 1.
 259   test = APFloat(APFloat::IEEEquad(), "-0x1p+1");
 260   expected = APFloat(APFloat::IEEEquad(),
 261                      "-0x1.ffffffffffffffffffffffffffffp+0");
 262   EXPECT_EQ(test.next(false), APFloat::opOK);
 263   EXPECT_TRUE(test.bitwiseIsEqual(expected));
 264
 265   // nextDown(+Normal Binade Boundary) -> +Normal Binade Boundary - 1.
 266   test = APFloat(APFloat::IEEEquad(), "0x1p+1");
 267   expected = APFloat(APFloat::IEEEquad(), "0x1.ffffffffffffffffffffffffffffp+0");
 268   EXPECT_EQ(test.next(true), APFloat::opOK);
 269   EXPECT_TRUE(test.bitwiseIsEqual(expected));
 270
 271   // nextUp(+Normal Binade Boundary - 1) -> +Normal Binade Boundary.
 272   test = APFloat(APFloat::IEEEquad(), "0x1.ffffffffffffffffffffffffffffp+0");
 273   expected = APFloat(APFloat::IEEEquad(), "0x1p+1");
 274   EXPECT_EQ(test.next(false), APFloat::opOK);
 275   EXPECT_TRUE(test.bitwiseIsEqual(expected));
 276
 277   // nextDown(-Normal Binade Boundary + 1) -> -Normal Binade Boundary.
 278   test = APFloat(APFloat::IEEEquad(), "-0x1.ffffffffffffffffffffffffffffp+0");
 279   expected = APFloat(APFloat::IEEEquad(), "-0x1p+1");
 280   EXPECT_EQ(test.next(true), APFloat::opOK);
 281   EXPECT_TRUE(test.bitwiseIsEqual(expected));
 282
 283   // 2c. Test using next at binade boundaries with a direction away from the
 284   // binade boundary. Away from denormal <-> normal boundaries.
 285   //
 286   // This is to make sure that even though we are at a binade boundary, since
 287   // we are rounding away, we do not trigger the binade boundary code. Thus we
 288   // test:
 289   //   * nextUp(-Largest Denormal) -> -Largest Denormal + inc.
 290   //   * nextDown(+Largest Denormal) -> +Largest Denormal - inc.
 291   //   * nextUp(+Smallest Normal) -> +Smallest Normal + inc.
 292   //   * nextDown(-Smallest Normal) -> -Smallest Normal - inc.
 293
 294   // nextUp(-Largest Denormal) -> -Largest Denormal + inc.
 295   test = APFloat(APFloat::IEEEquad(), "-0x0.ffffffffffffffffffffffffffffp-16382");
 296   expected = APFloat(APFloat::IEEEquad(),
 297                      "-0x0.fffffffffffffffffffffffffffep-16382");
 298   EXPECT_EQ(test.next(false), APFloat::opOK);
 299   EXPECT_TRUE(test.isDenormal());
 300   EXPECT_TRUE(test.isNegative());
 301   EXPECT_TRUE(test.bitwiseIsEqual(expected));
 302
 303   // nextDown(+Largest Denormal) -> +Largest Denormal - inc.
 304   test = APFloat(APFloat::IEEEquad(), "0x0.ffffffffffffffffffffffffffffp-16382");
 305   expected = APFloat(APFloat::IEEEquad(),
 306                      "0x0.fffffffffffffffffffffffffffep-16382");
 307   EXPECT_EQ(test.next(true), APFloat::opOK);
 308   EXPECT_TRUE(test.isDenormal());
 309   EXPECT_TRUE(!test.isNegative());
 310   EXPECT_TRUE(test.bitwiseIsEqual(expected));
 311
 312   // nextUp(+Smallest Normal) -> +Smallest Normal + inc.
 313   test = APFloat(APFloat::IEEEquad(), "0x1.0000000000000000000000000000p-16382");
 314   expected = APFloat(APFloat::IEEEquad(),
 315                      "0x1.0000000000000000000000000001p-16382");
 316   EXPECT_EQ(test.next(false), APFloat::opOK);
 317   EXPECT_TRUE(!test.isDenormal());
 318   EXPECT_TRUE(!test.isNegative());
 319   EXPECT_TRUE(test.bitwiseIsEqual(expected));
 320
 321   // nextDown(-Smallest Normal) -> -Smallest Normal - inc.
 322   test = APFloat(APFloat::IEEEquad(), "-0x1.0000000000000000000000000000p-16382");
 323   expected = APFloat(APFloat::IEEEquad(),
 324                      "-0x1.0000000000000000000000000001p-16382");
 325   EXPECT_EQ(test.next(true), APFloat::opOK);
 326   EXPECT_TRUE(!test.isDenormal());
 327   EXPECT_TRUE(test.isNegative());
 328   EXPECT_TRUE(test.bitwiseIsEqual(expected));
 329
 330   // 2d. Test values which cause our exponent to go to min exponent. This
 331   // is to ensure that guards in the code to check for min exponent
 332   // trigger properly.
 333   //     * nextUp(-0x1p-16381) -> -0x1.ffffffffffffffffffffffffffffp-16382
 334   //     * nextDown(-0x1.ffffffffffffffffffffffffffffp-16382) ->
 335   //         -0x1p-16381
 336   //     * nextUp(0x1.ffffffffffffffffffffffffffffp-16382) -> 0x1p-16382
 337   //     * nextDown(0x1p-16382) -> 0x1.ffffffffffffffffffffffffffffp-16382
 338
 339   // nextUp(-0x1p-16381) -> -0x1.ffffffffffffffffffffffffffffp-16382
 340   test = APFloat(APFloat::IEEEquad(), "-0x1p-16381");
 341   expected = APFloat(APFloat::IEEEquad(),
 342                      "-0x1.ffffffffffffffffffffffffffffp-16382");
 343   EXPECT_EQ(test.next(false), APFloat::opOK);
 344   EXPECT_TRUE(test.bitwiseIsEqual(expected));
 345
 346   // nextDown(-0x1.ffffffffffffffffffffffffffffp-16382) ->
 347   //         -0x1p-16381
 348   test = APFloat(APFloat::IEEEquad(), "-0x1.ffffffffffffffffffffffffffffp-16382");
 349   expected = APFloat(APFloat::IEEEquad(), "-0x1p-16381");
 350   EXPECT_EQ(test.next(true), APFloat::opOK);
 351   EXPECT_TRUE(test.bitwiseIsEqual(expected));
 352
 353   // nextUp(0x1.ffffffffffffffffffffffffffffp-16382) -> 0x1p-16381
 354   test = APFloat(APFloat::IEEEquad(), "0x1.ffffffffffffffffffffffffffffp-16382");
 355   expected = APFloat(APFloat::IEEEquad(), "0x1p-16381");
 356   EXPECT_EQ(test.next(false), APFloat::opOK);
 357   EXPECT_TRUE(test.bitwiseIsEqual(expected));
 358
 359   // nextDown(0x1p-16381) -> 0x1.ffffffffffffffffffffffffffffp-16382
 360   test = APFloat(APFloat::IEEEquad(), "0x1p-16381");
 361   expected = APFloat(APFloat::IEEEquad(),
 362                      "0x1.ffffffffffffffffffffffffffffp-16382");
 363   EXPECT_EQ(test.next(true), APFloat::opOK);
 364   EXPECT_TRUE(test.bitwiseIsEqual(expected));
 365
 366   // 3. Now we test both denormal/normal computation which will not cause us
 367   // to go across binade boundaries. Specifically we test:
 368   //   * nextUp(+Denormal) -> +Denormal.
 369   //   * nextDown(+Denormal) -> +Denormal.
 370   //   * nextUp(-Denormal) -> -Denormal.
 371   //   * nextDown(-Denormal) -> -Denormal.
 372   //   * nextUp(+Normal) -> +Normal.
 373   //   * nextDown(+Normal) -> +Normal.
 374   //   * nextUp(-Normal) -> -Normal.
 375   //   * nextDown(-Normal) -> -Normal.
 376
 377   // nextUp(+Denormal) -> +Denormal.
 378   test = APFloat(APFloat::IEEEquad(),
 379                  "0x0.ffffffffffffffffffffffff000cp-16382");
 380   expected = APFloat(APFloat::IEEEquad(),
 381                  "0x0.ffffffffffffffffffffffff000dp-16382");
 382   EXPECT_EQ(test.next(false), APFloat::opOK);
 383   EXPECT_TRUE(test.isDenormal());
 384   EXPECT_TRUE(!test.isNegative());
 385   EXPECT_TRUE(test.bitwiseIsEqual(expected));
 386
 387   // nextDown(+Denormal) -> +Denormal.
 388   test = APFloat(APFloat::IEEEquad(),
 389                  "0x0.ffffffffffffffffffffffff000cp-16382");
 390   expected = APFloat(APFloat::IEEEquad(),
 391                  "0x0.ffffffffffffffffffffffff000bp-16382");
 392   EXPECT_EQ(test.next(true), APFloat::opOK);
 393   EXPECT_TRUE(test.isDenormal());
 394   EXPECT_TRUE(!test.isNegative());
 395   EXPECT_TRUE(test.bitwiseIsEqual(expected));
 396
 397   // nextUp(-Denormal) -> -Denormal.
 398   test = APFloat(APFloat::IEEEquad(),
 399                  "-0x0.ffffffffffffffffffffffff000cp-16382");
 400   expected = APFloat(APFloat::IEEEquad(),
 401                  "-0x0.ffffffffffffffffffffffff000bp-16382");
 402   EXPECT_EQ(test.next(false), APFloat::opOK);
 403   EXPECT_TRUE(test.isDenormal());
 404   EXPECT_TRUE(test.isNegative());
 405   EXPECT_TRUE(test.bitwiseIsEqual(expected));
 406
 407   // nextDown(-Denormal) -> -Denormal
 408   test = APFloat(APFloat::IEEEquad(),
 409                  "-0x0.ffffffffffffffffffffffff000cp-16382");
 410   expected = APFloat(APFloat::IEEEquad(),
 411                  "-0x0.ffffffffffffffffffffffff000dp-16382");
 412   EXPECT_EQ(test.next(true), APFloat::opOK);
 413   EXPECT_TRUE(test.isDenormal());
 414   EXPECT_TRUE(test.isNegative());
 415   EXPECT_TRUE(test.bitwiseIsEqual(expected));
 416
 417   // nextUp(+Normal) -> +Normal.
 418   test = APFloat(APFloat::IEEEquad(),
 419                  "0x1.ffffffffffffffffffffffff000cp-16000");
 420   expected = APFloat(APFloat::IEEEquad(),
 421                  "0x1.ffffffffffffffffffffffff000dp-16000");
 422   EXPECT_EQ(test.next(false), APFloat::opOK);
 423   EXPECT_TRUE(!test.isDenormal());
 424   EXPECT_TRUE(!test.isNegative());
 425   EXPECT_TRUE(test.bitwiseIsEqual(expected));
 426
 427   // nextDown(+Normal) -> +Normal.
 428   test = APFloat(APFloat::IEEEquad(),
 429                  "0x1.ffffffffffffffffffffffff000cp-16000");
 430   expected = APFloat(APFloat::IEEEquad(),
 431                  "0x1.ffffffffffffffffffffffff000bp-16000");
 432   EXPECT_EQ(test.next(true), APFloat::opOK);
 433   EXPECT_TRUE(!test.isDenormal());
 434   EXPECT_TRUE(!test.isNegative());
 435   EXPECT_TRUE(test.bitwiseIsEqual(expected));
 436
 437   // nextUp(-Normal) -> -Normal.
 438   test = APFloat(APFloat::IEEEquad(),
 439                  "-0x1.ffffffffffffffffffffffff000cp-16000");
 440   expected = APFloat(APFloat::IEEEquad(),
 441                  "-0x1.ffffffffffffffffffffffff000bp-16000");
 442   EXPECT_EQ(test.next(false), APFloat::opOK);
 443   EXPECT_TRUE(!test.isDenormal());
 444   EXPECT_TRUE(test.isNegative());
 445   EXPECT_TRUE(test.bitwiseIsEqual(expected));
 446
 447   // nextDown(-Normal) -> -Normal.
 448   test = APFloat(APFloat::IEEEquad(),
 449                  "-0x1.ffffffffffffffffffffffff000cp-16000");
 450   expected = APFloat(APFloat::IEEEquad(),
 451                  "-0x1.ffffffffffffffffffffffff000dp-16000");
 452   EXPECT_EQ(test.next(true), APFloat::opOK);
 453   EXPECT_TRUE(!test.isDenormal());
 454   EXPECT_TRUE(test.isNegative());
 455   EXPECT_TRUE(test.bitwiseIsEqual(expected));
 456 }
 457
 458 TEST(APFloatTest, FMA) {
 459   APFloat::roundingMode rdmd = APFloat::rmNearestTiesToEven;
 460
 461   {
 462     APFloat f1(14.5f);
 463     APFloat f2(-14.5f);
 464     APFloat f3(225.0f);
 465     f1.fusedMultiplyAdd(f2, f3, APFloat::rmNearestTiesToEven);
 466     EXPECT_EQ(14.75f, f1.convertToFloat());
 467   }
 468
 469   {
 470     APFloat Val2(2.0f);
 471     APFloat f1((float)1.17549435e-38F);
 472     APFloat f2((float)1.17549435e-38F);
 473     f1.divide(Val2, rdmd);
 474     f2.divide(Val2, rdmd);
 475     APFloat f3(12.0f);
 476     f1.fusedMultiplyAdd(f2, f3, APFloat::rmNearestTiesToEven);
 477     EXPECT_EQ(12.0f, f1.convertToFloat());
 478   }
 479
 480   // Test for correct zero sign when answer is exactly zero.
 481   // fma(1.0, -1.0, 1.0) -> +ve 0.
 482   {
 483     APFloat f1(1.0);
 484     APFloat f2(-1.0);
 485     APFloat f3(1.0);
 486     f1.fusedMultiplyAdd(f2, f3, APFloat::rmNearestTiesToEven);
 487     EXPECT_TRUE(!f1.isNegative() && f1.isZero());
 488   }
 489
 490   // Test for correct zero sign when answer is exactly zero and rounding towards
 491   // negative.
 492   // fma(1.0, -1.0, 1.0) -> +ve 0.
 493   {
 494     APFloat f1(1.0);
 495     APFloat f2(-1.0);
 496     APFloat f3(1.0);
 497     f1.fusedMultiplyAdd(f2, f3, APFloat::rmTowardNegative);
 498     EXPECT_TRUE(f1.isNegative() && f1.isZero());
 499   }
 500
 501   // Test for correct (in this case -ve) sign when adding like signed zeros.
 502   // Test fma(0.0, -0.0, -0.0) -> -ve 0.
 503   {
 504     APFloat f1(0.0);
 505     APFloat f2(-0.0);
 506     APFloat f3(-0.0);
 507     f1.fusedMultiplyAdd(f2, f3, APFloat::rmNearestTiesToEven);
 508     EXPECT_TRUE(f1.isNegative() && f1.isZero());
 509   }
 510
 511   // Test -ve sign preservation when small negative results underflow.
 512   {
 513     APFloat f1(APFloat::IEEEdouble(),  "-0x1p-1074");
 514     APFloat f2(APFloat::IEEEdouble(), "+0x1p-1074");
 515     APFloat f3(0.0);
 516     f1.fusedMultiplyAdd(f2, f3, APFloat::rmNearestTiesToEven);
 517     EXPECT_TRUE(f1.isNegative() && f1.isZero());
 518   }
 519
 520   // Test x87 extended precision case from http://llvm.org/PR20728.
 521   {
 522     APFloat M1(APFloat::x87DoubleExtended(), 1.0);
 523     APFloat M2(APFloat::x87DoubleExtended(), 1.0);
 524     APFloat A(APFloat::x87DoubleExtended(), 3.0);
 525
 526     bool losesInfo = false;
 527     M1.fusedMultiplyAdd(M1, A, APFloat::rmNearestTiesToEven);
 528     M1.convert(APFloat::IEEEsingle(), APFloat::rmNearestTiesToEven, &losesInfo);
 529     EXPECT_FALSE(losesInfo);
 530     EXPECT_EQ(4.0f, M1.convertToFloat());
 531   }
 532 }
 533
 534 TEST(APFloatTest, MinNum) {
 535   APFloat f1(1.0);
 536   APFloat f2(2.0);
 537   APFloat nan = APFloat::getNaN(APFloat::IEEEdouble());
 538
 539   EXPECT_EQ(1.0, minnum(f1, f2).convertToDouble());
 540   EXPECT_EQ(1.0, minnum(f2, f1).convertToDouble());
 541   EXPECT_EQ(1.0, minnum(f1, nan).convertToDouble());
 542   EXPECT_EQ(1.0, minnum(nan, f1).convertToDouble());
 543 }
 544
 545 TEST(APFloatTest, MaxNum) {
 546   APFloat f1(1.0);
 547   APFloat f2(2.0);
 548   APFloat nan = APFloat::getNaN(APFloat::IEEEdouble());
 549
 550   EXPECT_EQ(2.0, maxnum(f1, f2).convertToDouble());
 551   EXPECT_EQ(2.0, maxnum(f2, f1).convertToDouble());
 552   EXPECT_EQ(1.0, maxnum(f1, nan).convertToDouble());
 553   EXPECT_EQ(1.0, minnum(nan, f1).convertToDouble());
 554 }
 555
 556 TEST(APFloatTest, Denormal) {
 557   APFloat::roundingMode rdmd = APFloat::rmNearestTiesToEven;
 558
 559   // Test single precision
 560   {
 561     const char *MinNormalStr = "1.17549435082228750797e-38";
 562     EXPECT_FALSE(APFloat(APFloat::IEEEsingle(), MinNormalStr).isDenormal());
 563     EXPECT_FALSE(APFloat(APFloat::IEEEsingle(), 0.0).isDenormal());
 564
 565     APFloat Val2(APFloat::IEEEsingle(), 2.0e0);
 566     APFloat T(APFloat::IEEEsingle(), MinNormalStr);
 567     T.divide(Val2, rdmd);
 568     EXPECT_TRUE(T.isDenormal());
 569   }
 570
 571   // Test double precision
 572   {
 573     const char *MinNormalStr = "2.22507385850720138309e-308";
 574     EXPECT_FALSE(APFloat(APFloat::IEEEdouble(), MinNormalStr).isDenormal());
 575     EXPECT_FALSE(APFloat(APFloat::IEEEdouble(), 0.0).isDenormal());
 576
 577     APFloat Val2(APFloat::IEEEdouble(), 2.0e0);
 578     APFloat T(APFloat::IEEEdouble(), MinNormalStr);
 579     T.divide(Val2, rdmd);
 580     EXPECT_TRUE(T.isDenormal());
 581   }
 582
 583   // Test Intel double-ext
 584   {
 585     const char *MinNormalStr = "3.36210314311209350626e-4932";
 586     EXPECT_FALSE(APFloat(APFloat::x87DoubleExtended(), MinNormalStr).isDenormal());
 587     EXPECT_FALSE(APFloat(APFloat::x87DoubleExtended(), 0.0).isDenormal());
 588
 589     APFloat Val2(APFloat::x87DoubleExtended(), 2.0e0);
 590     APFloat T(APFloat::x87DoubleExtended(), MinNormalStr);
 591     T.divide(Val2, rdmd);
 592     EXPECT_TRUE(T.isDenormal());
 593   }
 594
 595   // Test quadruple precision
 596   {
 597     const char *MinNormalStr = "3.36210314311209350626267781732175260e-4932";
 598     EXPECT_FALSE(APFloat(APFloat::IEEEquad(), MinNormalStr).isDenormal());
 599     EXPECT_FALSE(APFloat(APFloat::IEEEquad(), 0.0).isDenormal());
 600
 601     APFloat Val2(APFloat::IEEEquad(), 2.0e0);
 602     APFloat T(APFloat::IEEEquad(), MinNormalStr);
 603     T.divide(Val2, rdmd);
 604     EXPECT_TRUE(T.isDenormal());
 605   }
 606 }
 607
 608 TEST(APFloatTest, Zero) {
 609   EXPECT_EQ(0.0f,  APFloat(0.0f).convertToFloat());
 610   EXPECT_EQ(-0.0f, APFloat(-0.0f).convertToFloat());
 611   EXPECT_TRUE(APFloat(-0.0f).isNegative());
 612
 613   EXPECT_EQ(0.0,  APFloat(0.0).convertToDouble());
 614   EXPECT_EQ(-0.0, APFloat(-0.0).convertToDouble());
 615   EXPECT_TRUE(APFloat(-0.0).isNegative());
 616 }
 617
 618 TEST(APFloatTest, DecimalStringsWithoutNullTerminators) {
 619   // Make sure that we can parse strings without null terminators.
 620   // rdar://14323230.
 621   APFloat Val(APFloat::IEEEdouble());
 622   Val.convertFromString(StringRef("0.00", 3),
 623                         llvm::APFloat::rmNearestTiesToEven);
 624   EXPECT_EQ(Val.convertToDouble(), 0.0);
 625   Val.convertFromString(StringRef("0.01", 3),
 626                         llvm::APFloat::rmNearestTiesToEven);
 627   EXPECT_EQ(Val.convertToDouble(), 0.0);
 628   Val.convertFromString(StringRef("0.09", 3),
 629                         llvm::APFloat::rmNearestTiesToEven);
 630   EXPECT_EQ(Val.convertToDouble(), 0.0);
 631   Val.convertFromString(StringRef("0.095", 4),
 632                         llvm::APFloat::rmNearestTiesToEven);
 633   EXPECT_EQ(Val.convertToDouble(), 0.09);
 634   Val.convertFromString(StringRef("0.00e+3", 7),
 635                         llvm::APFloat::rmNearestTiesToEven);
 636   EXPECT_EQ(Val.convertToDouble(), 0.00);
 637   Val.convertFromString(StringRef("0e+3", 4),
 638                         llvm::APFloat::rmNearestTiesToEven);
 639   EXPECT_EQ(Val.convertToDouble(), 0.00);
 640
 641 }
 642
 643 TEST(APFloatTest, fromZeroDecimalString) {
 644   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(),  "0").convertToDouble());
 645   EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0").convertToDouble());
 646   EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0").convertToDouble());
 647
 648   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(),  "0.").convertToDouble());
 649   EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0.").convertToDouble());
 650   EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0.").convertToDouble());
 651
 652   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(),  ".0").convertToDouble());
 653   EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+.0").convertToDouble());
 654   EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-.0").convertToDouble());
 655
 656   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(),  "0.0").convertToDouble());
 657   EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0.0").convertToDouble());
 658   EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0.0").convertToDouble());
 659
 660   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(),  "00000.").convertToDouble());
 661   EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+00000.").convertToDouble());
 662   EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-00000.").convertToDouble());
 663
 664   EXPECT_EQ(0.0,  APFloat(APFloat::IEEEdouble(), ".00000").convertToDouble());
 665   EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+.00000").convertToDouble());
 666   EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-.00000").convertToDouble());
 667
 668   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(),  "0000.00000").convertToDouble());
 669   EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0000.00000").convertToDouble());
 670   EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0000.00000").convertToDouble());
 671 }
 672
 673 TEST(APFloatTest, fromZeroDecimalSingleExponentString) {
 674   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(),   "0e1").convertToDouble());
 675   EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(),  "+0e1").convertToDouble());
 676   EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(),  "-0e1").convertToDouble());
 677
 678   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(),  "0e+1").convertToDouble());
 679   EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0e+1").convertToDouble());
 680   EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0e+1").convertToDouble());
 681
 682   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(),  "0e-1").convertToDouble());
 683   EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0e-1").convertToDouble());
 684   EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0e-1").convertToDouble());
 685
 686
 687   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(),   "0.e1").convertToDouble());
 688   EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(),  "+0.e1").convertToDouble());
 689   EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(),  "-0.e1").convertToDouble());
 690
 691   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(),  "0.e+1").convertToDouble());
 692   EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0.e+1").convertToDouble());
 693   EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0.e+1").convertToDouble());
 694
 695   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(),  "0.e-1").convertToDouble());
 696   EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0.e-1").convertToDouble());
 697   EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0.e-1").convertToDouble());
 698
 699   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(),   ".0e1").convertToDouble());
 700   EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(),  "+.0e1").convertToDouble());
 701   EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(),  "-.0e1").convertToDouble());
 702
 703   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(),  ".0e+1").convertToDouble());
 704   EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+.0e+1").convertToDouble());
 705   EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-.0e+1").convertToDouble());
 706
 707   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(),  ".0e-1").convertToDouble());
 708   EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+.0e-1").convertToDouble());
 709   EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-.0e-1").convertToDouble());
 710
 711
 712   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(),   "0.0e1").convertToDouble());
 713   EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(),  "+0.0e1").convertToDouble());
 714   EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(),  "-0.0e1").convertToDouble());
 715
 716   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(),  "0.0e+1").convertToDouble());
 717   EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0.0e+1").convertToDouble());
 718   EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0.0e+1").convertToDouble());
 719
 720   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(),  "0.0e-1").convertToDouble());
 721   EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0.0e-1").convertToDouble());
 722   EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0.0e-1").convertToDouble());
 723
 724
 725   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(),  "000.0000e1").convertToDouble());
 726   EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+000.0000e+1").convertToDouble());
 727   EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-000.0000e+1").convertToDouble());
 728 }
 729
 730 TEST(APFloatTest, fromZeroDecimalLargeExponentString) {
 731   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(),  "0e1234").convertToDouble());
 732   EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0e1234").convertToDouble());
 733   EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0e1234").convertToDouble());
 734
 735   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(),  "0e+1234").convertToDouble());
 736   EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0e+1234").convertToDouble());
 737   EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0e+1234").convertToDouble());
 738
 739   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(),  "0e-1234").convertToDouble());
 740   EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0e-1234").convertToDouble());
 741   EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0e-1234").convertToDouble());
 742
 743   EXPECT_EQ(0.0,  APFloat(APFloat::IEEEdouble(), "000.0000e1234").convertToDouble());
 744   EXPECT_EQ(0.0,  APFloat(APFloat::IEEEdouble(), "000.0000e-1234").convertToDouble());
 745
 746   EXPECT_EQ(0.0,  APFloat(APFloat::IEEEdouble(), StringRef("0e1234\02", 6)).convertToDouble());
 747 }
 748
 749 TEST(APFloatTest, fromZeroHexadecimalString) {
 750   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(),  "0x0p1").convertToDouble());
 751   EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0x0p1").convertToDouble());
 752   EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0x0p1").convertToDouble());
 753
 754   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(),  "0x0p+1").convertToDouble());
 755   EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0x0p+1").convertToDouble());
 756   EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0x0p+1").convertToDouble());
 757
 758   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(),  "0x0p-1").convertToDouble());
 759   EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0x0p-1").convertToDouble());
 760   EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0x0p-1").convertToDouble());
 761
 762
 763   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(),  "0x0.p1").convertToDouble());
 764   EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0x0.p1").convertToDouble());
 765   EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0x0.p1").convertToDouble());
 766
 767   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(),  "0x0.p+1").convertToDouble());
 768   EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0x0.p+1").convertToDouble());
 769   EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0x0.p+1").convertToDouble());
 770
 771   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(),  "0x0.p-1").convertToDouble());
 772   EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0x0.p-1").convertToDouble());
 773   EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0x0.p-1").convertToDouble());
 774
 775
 776   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(),  "0x.0p1").convertToDouble());
 777   EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0x.0p1").convertToDouble());
 778   EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0x.0p1").convertToDouble());
 779
 780   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(),  "0x.0p+1").convertToDouble());
 781   EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0x.0p+1").convertToDouble());
 782   EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0x.0p+1").convertToDouble());
 783
 784   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(),  "0x.0p-1").convertToDouble());
 785   EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0x.0p-1").convertToDouble());
 786   EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0x.0p-1").convertToDouble());
 787
 788
 789   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(),  "0x0.0p1").convertToDouble());
 790   EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0x0.0p1").convertToDouble());
 791   EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0x0.0p1").convertToDouble());
 792
 793   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(),  "0x0.0p+1").convertToDouble());
 794   EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0x0.0p+1").convertToDouble());
 795   EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0x0.0p+1").convertToDouble());
 796
 797   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(),  "0x0.0p-1").convertToDouble());
 798   EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0x0.0p-1").convertToDouble());
 799   EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0x0.0p-1").convertToDouble());
 800
 801
 802   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x00000.p1").convertToDouble());
 803   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x0000.00000p1").convertToDouble());
 804   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x.00000p1").convertToDouble());
 805   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x0.p1").convertToDouble());
 806   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x0p1234").convertToDouble());
 807   EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0x0p1234").convertToDouble());
 808   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x00000.p1234").convertToDouble());
 809   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x0000.00000p1234").convertToDouble());
 810   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x.00000p1234").convertToDouble());
 811   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x0.p1234").convertToDouble());
 812 }
 813
 814 TEST(APFloatTest, fromDecimalString) {
 815   EXPECT_EQ(1.0,      APFloat(APFloat::IEEEdouble(), "1").convertToDouble());
 816   EXPECT_EQ(2.0,      APFloat(APFloat::IEEEdouble(), "2.").convertToDouble());
 817   EXPECT_EQ(0.5,      APFloat(APFloat::IEEEdouble(), ".5").convertToDouble());
 818   EXPECT_EQ(1.0,      APFloat(APFloat::IEEEdouble(), "1.0").convertToDouble());
 819   EXPECT_EQ(-2.0,     APFloat(APFloat::IEEEdouble(), "-2").convertToDouble());
 820   EXPECT_EQ(-4.0,     APFloat(APFloat::IEEEdouble(), "-4.").convertToDouble());
 821   EXPECT_EQ(-0.5,     APFloat(APFloat::IEEEdouble(), "-.5").convertToDouble());
 822   EXPECT_EQ(-1.5,     APFloat(APFloat::IEEEdouble(), "-1.5").convertToDouble());
 823   EXPECT_EQ(1.25e12,  APFloat(APFloat::IEEEdouble(), "1.25e12").convertToDouble());
 824   EXPECT_EQ(1.25e+12, APFloat(APFloat::IEEEdouble(), "1.25e+12").convertToDouble());
 825   EXPECT_EQ(1.25e-12, APFloat(APFloat::IEEEdouble(), "1.25e-12").convertToDouble());
 826   EXPECT_EQ(1024.0,   APFloat(APFloat::IEEEdouble(), "1024.").convertToDouble());
 827   EXPECT_EQ(1024.05,  APFloat(APFloat::IEEEdouble(), "1024.05000").convertToDouble());
 828   EXPECT_EQ(0.05,     APFloat(APFloat::IEEEdouble(), ".05000").convertToDouble());
 829   EXPECT_EQ(2.0,      APFloat(APFloat::IEEEdouble(), "2.").convertToDouble());
 830   EXPECT_EQ(2.0e2,    APFloat(APFloat::IEEEdouble(), "2.e2").convertToDouble());
 831   EXPECT_EQ(2.0e+2,   APFloat(APFloat::IEEEdouble(), "2.e+2").convertToDouble());
 832   EXPECT_EQ(2.0e-2,   APFloat(APFloat::IEEEdouble(), "2.e-2").convertToDouble());
 833   EXPECT_EQ(2.05e2,    APFloat(APFloat::IEEEdouble(), "002.05000e2").convertToDouble());
 834   EXPECT_EQ(2.05e+2,   APFloat(APFloat::IEEEdouble(), "002.05000e+2").convertToDouble());
 835   EXPECT_EQ(2.05e-2,   APFloat(APFloat::IEEEdouble(), "002.05000e-2").convertToDouble());
 836   EXPECT_EQ(2.05e12,   APFloat(APFloat::IEEEdouble(), "002.05000e12").convertToDouble());
 837   EXPECT_EQ(2.05e+12,  APFloat(APFloat::IEEEdouble(), "002.05000e+12").convertToDouble());
 838   EXPECT_EQ(2.05e-12,  APFloat(APFloat::IEEEdouble(), "002.05000e-12").convertToDouble());
 839
 840   // These are "carefully selected" to overflow the fast log-base
 841   // calculations in APFloat.cpp
 842   EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "99e99999").isInfinity());
 843   EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "-99e99999").isInfinity());
 844   EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "1e-99999").isPosZero());
 845   EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "-1e-99999").isNegZero());
 846
 847   EXPECT_EQ(2.71828, convertToDoubleFromString("2.71828"));
 848 }
 849
 850 TEST(APFloatTest, fromHexadecimalString) {
 851   EXPECT_EQ( 1.0, APFloat(APFloat::IEEEdouble(),  "0x1p0").convertToDouble());
 852   EXPECT_EQ(+1.0, APFloat(APFloat::IEEEdouble(), "+0x1p0").convertToDouble());
 853   EXPECT_EQ(-1.0, APFloat(APFloat::IEEEdouble(), "-0x1p0").convertToDouble());
 854
 855   EXPECT_EQ( 1.0, APFloat(APFloat::IEEEdouble(),  "0x1p+0").convertToDouble());
 856   EXPECT_EQ(+1.0, APFloat(APFloat::IEEEdouble(), "+0x1p+0").convertToDouble());
 857   EXPECT_EQ(-1.0, APFloat(APFloat::IEEEdouble(), "-0x1p+0").convertToDouble());
 858
 859   EXPECT_EQ( 1.0, APFloat(APFloat::IEEEdouble(),  "0x1p-0").convertToDouble());
 860   EXPECT_EQ(+1.0, APFloat(APFloat::IEEEdouble(), "+0x1p-0").convertToDouble());
 861   EXPECT_EQ(-1.0, APFloat(APFloat::IEEEdouble(), "-0x1p-0").convertToDouble());
 862
 863
 864   EXPECT_EQ( 2.0, APFloat(APFloat::IEEEdouble(),  "0x1p1").convertToDouble());
 865   EXPECT_EQ(+2.0, APFloat(APFloat::IEEEdouble(), "+0x1p1").convertToDouble());
 866   EXPECT_EQ(-2.0, APFloat(APFloat::IEEEdouble(), "-0x1p1").convertToDouble());
 867
 868   EXPECT_EQ( 2.0, APFloat(APFloat::IEEEdouble(),  "0x1p+1").convertToDouble());
 869   EXPECT_EQ(+2.0, APFloat(APFloat::IEEEdouble(), "+0x1p+1").convertToDouble());
 870   EXPECT_EQ(-2.0, APFloat(APFloat::IEEEdouble(), "-0x1p+1").convertToDouble());
 871
 872   EXPECT_EQ( 0.5, APFloat(APFloat::IEEEdouble(),  "0x1p-1").convertToDouble());
 873   EXPECT_EQ(+0.5, APFloat(APFloat::IEEEdouble(), "+0x1p-1").convertToDouble());
 874   EXPECT_EQ(-0.5, APFloat(APFloat::IEEEdouble(), "-0x1p-1").convertToDouble());
 875
 876
 877   EXPECT_EQ( 3.0, APFloat(APFloat::IEEEdouble(),  "0x1.8p1").convertToDouble());
 878   EXPECT_EQ(+3.0, APFloat(APFloat::IEEEdouble(), "+0x1.8p1").convertToDouble());
 879   EXPECT_EQ(-3.0, APFloat(APFloat::IEEEdouble(), "-0x1.8p1").convertToDouble());
 880
 881   EXPECT_EQ( 3.0, APFloat(APFloat::IEEEdouble(),  "0x1.8p+1").convertToDouble());
 882   EXPECT_EQ(+3.0, APFloat(APFloat::IEEEdouble(), "+0x1.8p+1").convertToDouble());
 883   EXPECT_EQ(-3.0, APFloat(APFloat::IEEEdouble(), "-0x1.8p+1").convertToDouble());
 884
 885   EXPECT_EQ( 0.75, APFloat(APFloat::IEEEdouble(),  "0x1.8p-1").convertToDouble());
 886   EXPECT_EQ(+0.75, APFloat(APFloat::IEEEdouble(), "+0x1.8p-1").convertToDouble());
 887   EXPECT_EQ(-0.75, APFloat(APFloat::IEEEdouble(), "-0x1.8p-1").convertToDouble());
 888
 889
 890   EXPECT_EQ( 8192.0, APFloat(APFloat::IEEEdouble(),  "0x1000.000p1").convertToDouble());
 891   EXPECT_EQ(+8192.0, APFloat(APFloat::IEEEdouble(), "+0x1000.000p1").convertToDouble());
 892   EXPECT_EQ(-8192.0, APFloat(APFloat::IEEEdouble(), "-0x1000.000p1").convertToDouble());
 893
 894   EXPECT_EQ( 8192.0, APFloat(APFloat::IEEEdouble(),  "0x1000.000p+1").convertToDouble());
 895   EXPECT_EQ(+8192.0, APFloat(APFloat::IEEEdouble(), "+0x1000.000p+1").convertToDouble());
 896   EXPECT_EQ(-8192.0, APFloat(APFloat::IEEEdouble(), "-0x1000.000p+1").convertToDouble());
 897
 898   EXPECT_EQ( 2048.0, APFloat(APFloat::IEEEdouble(),  "0x1000.000p-1").convertToDouble());
 899   EXPECT_EQ(+2048.0, APFloat(APFloat::IEEEdouble(), "+0x1000.000p-1").convertToDouble());
 900   EXPECT_EQ(-2048.0, APFloat(APFloat::IEEEdouble(), "-0x1000.000p-1").convertToDouble());
 901
 902
 903   EXPECT_EQ( 8192.0, APFloat(APFloat::IEEEdouble(),  "0x1000p1").convertToDouble());
 904   EXPECT_EQ(+8192.0, APFloat(APFloat::IEEEdouble(), "+0x1000p1").convertToDouble());
 905   EXPECT_EQ(-8192.0, APFloat(APFloat::IEEEdouble(), "-0x1000p1").convertToDouble());
 906
 907   EXPECT_EQ( 8192.0, APFloat(APFloat::IEEEdouble(),  "0x1000p+1").convertToDouble());
 908   EXPECT_EQ(+8192.0, APFloat(APFloat::IEEEdouble(), "+0x1000p+1").convertToDouble());
 909   EXPECT_EQ(-8192.0, APFloat(APFloat::IEEEdouble(), "-0x1000p+1").convertToDouble());
 910
 911   EXPECT_EQ( 2048.0, APFloat(APFloat::IEEEdouble(),  "0x1000p-1").convertToDouble());
 912   EXPECT_EQ(+2048.0, APFloat(APFloat::IEEEdouble(), "+0x1000p-1").convertToDouble());
 913   EXPECT_EQ(-2048.0, APFloat(APFloat::IEEEdouble(), "-0x1000p-1").convertToDouble());
 914
 915
 916   EXPECT_EQ( 16384.0, APFloat(APFloat::IEEEdouble(),  "0x10p10").convertToDouble());
 917   EXPECT_EQ(+16384.0, APFloat(APFloat::IEEEdouble(), "+0x10p10").convertToDouble());
 918   EXPECT_EQ(-16384.0, APFloat(APFloat::IEEEdouble(), "-0x10p10").convertToDouble());
 919
 920   EXPECT_EQ( 16384.0, APFloat(APFloat::IEEEdouble(),  "0x10p+10").convertToDouble());
 921   EXPECT_EQ(+16384.0, APFloat(APFloat::IEEEdouble(), "+0x10p+10").convertToDouble());
 922   EXPECT_EQ(-16384.0, APFloat(APFloat::IEEEdouble(), "-0x10p+10").convertToDouble());
 923
 924   EXPECT_EQ( 0.015625, APFloat(APFloat::IEEEdouble(),  "0x10p-10").convertToDouble());
 925   EXPECT_EQ(+0.015625, APFloat(APFloat::IEEEdouble(), "+0x10p-10").convertToDouble());
 926   EXPECT_EQ(-0.015625, APFloat(APFloat::IEEEdouble(), "-0x10p-10").convertToDouble());
 927
 928   EXPECT_EQ(1.0625, APFloat(APFloat::IEEEdouble(), "0x1.1p0").convertToDouble());
 929   EXPECT_EQ(1.0, APFloat(APFloat::IEEEdouble(), "0x1p0").convertToDouble());
 930
 931   EXPECT_EQ(convertToDoubleFromString("0x1p-150"),
 932             convertToDoubleFromString("+0x800000000000000001.p-221"));
 933   EXPECT_EQ(2251799813685248.5,
 934             convertToDoubleFromString("0x80000000000004000000.010p-28"));
 935 }
 936
 937 TEST(APFloatTest, toString) {
 938   ASSERT_EQ("10", convertToString(10.0, 6, 3));
 939   ASSERT_EQ("1.0E+1", convertToString(10.0, 6, 0));
 940   ASSERT_EQ("10100", convertToString(1.01E+4, 5, 2));
 941   ASSERT_EQ("1.01E+4", convertToString(1.01E+4, 4, 2));
 942   ASSERT_EQ("1.01E+4", convertToString(1.01E+4, 5, 1));
 943   ASSERT_EQ("0.0101", convertToString(1.01E-2, 5, 2));
 944   ASSERT_EQ("0.0101", convertToString(1.01E-2, 4, 2));
 945   ASSERT_EQ("1.01E-2", convertToString(1.01E-2, 5, 1));
 946   ASSERT_EQ("0.78539816339744828", convertToString(0.78539816339744830961, 0, 3));
 947   ASSERT_EQ("4.9406564584124654E-324", convertToString(4.9406564584124654e-324, 0, 3));
 948   ASSERT_EQ("873.18340000000001", convertToString(873.1834, 0, 1));
 949   ASSERT_EQ("8.7318340000000001E+2", convertToString(873.1834, 0, 0));
 950   ASSERT_EQ("1.7976931348623157E+308", convertToString(1.7976931348623157E+308, 0, 0));
 951 }
 952
 953 TEST(APFloatTest, toInteger) {
 954   bool isExact = false;
 955   APSInt result(5, /*isUnsigned=*/true);
 956
 957   EXPECT_EQ(APFloat::opOK,
 958             APFloat(APFloat::IEEEdouble(), "10")
 959             .convertToInteger(result, APFloat::rmTowardZero, &isExact));
 960   EXPECT_TRUE(isExact);
 961   EXPECT_EQ(APSInt(APInt(5, 10), true), result);
 962
 963   EXPECT_EQ(APFloat::opInvalidOp,
 964             APFloat(APFloat::IEEEdouble(), "-10")
 965             .convertToInteger(result, APFloat::rmTowardZero, &isExact));
 966   EXPECT_FALSE(isExact);
 967   EXPECT_EQ(APSInt::getMinValue(5, true), result);
 968
 969   EXPECT_EQ(APFloat::opInvalidOp,
 970             APFloat(APFloat::IEEEdouble(), "32")
 971             .convertToInteger(result, APFloat::rmTowardZero, &isExact));
 972   EXPECT_FALSE(isExact);
 973   EXPECT_EQ(APSInt::getMaxValue(5, true), result);
 974
 975   EXPECT_EQ(APFloat::opInexact,
 976             APFloat(APFloat::IEEEdouble(), "7.9")
 977             .convertToInteger(result, APFloat::rmTowardZero, &isExact));
 978   EXPECT_FALSE(isExact);
 979   EXPECT_EQ(APSInt(APInt(5, 7), true), result);
 980
 981   result.setIsUnsigned(false);
 982   EXPECT_EQ(APFloat::opOK,
 983             APFloat(APFloat::IEEEdouble(), "-10")
 984             .convertToInteger(result, APFloat::rmTowardZero, &isExact));
 985   EXPECT_TRUE(isExact);
 986   EXPECT_EQ(APSInt(APInt(5, -10, true), false), result);
 987
 988   EXPECT_EQ(APFloat::opInvalidOp,
 989             APFloat(APFloat::IEEEdouble(), "-17")
 990             .convertToInteger(result, APFloat::rmTowardZero, &isExact));
 991   EXPECT_FALSE(isExact);
 992   EXPECT_EQ(APSInt::getMinValue(5, false), result);
 993
 994   EXPECT_EQ(APFloat::opInvalidOp,
 995             APFloat(APFloat::IEEEdouble(), "16")
 996             .convertToInteger(result, APFloat::rmTowardZero, &isExact));
 997   EXPECT_FALSE(isExact);
 998   EXPECT_EQ(APSInt::getMaxValue(5, false), result);
 999 }
1000
1001 static APInt nanbits(const fltSemantics &Sem,
1002                      bool SNaN, bool Negative, uint64_t fill) {
1003   APInt apfill(64, fill);
1004   if (SNaN)
1005     return APFloat::getSNaN(Sem, Negative, &apfill).bitcastToAPInt();
1006   else
1007     return APFloat::getQNaN(Sem, Negative, &apfill).bitcastToAPInt();
1008 }
1009
1010 TEST(APFloatTest, makeNaN) {
1011   ASSERT_EQ(0x7fc00000, nanbits(APFloat::IEEEsingle(), false, false, 0));
1012   ASSERT_EQ(0xffc00000, nanbits(APFloat::IEEEsingle(), false, true, 0));
1013   ASSERT_EQ(0x7fc0ae72, nanbits(APFloat::IEEEsingle(), false, false, 0xae72));
1014   ASSERT_EQ(0x7fffae72, nanbits(APFloat::IEEEsingle(), false, false, 0xffffae72));
1015   ASSERT_EQ(0x7fa00000, nanbits(APFloat::IEEEsingle(), true, false, 0));
1016   ASSERT_EQ(0xffa00000, nanbits(APFloat::IEEEsingle(), true, true, 0));
1017   ASSERT_EQ(0x7f80ae72, nanbits(APFloat::IEEEsingle(), true, false, 0xae72));
1018   ASSERT_EQ(0x7fbfae72, nanbits(APFloat::IEEEsingle(), true, false, 0xffffae72));
1019
1020   ASSERT_EQ(0x7ff8000000000000ULL, nanbits(APFloat::IEEEdouble(), false, false, 0));
1021   ASSERT_EQ(0xfff8000000000000ULL, nanbits(APFloat::IEEEdouble(), false, true, 0));
1022   ASSERT_EQ(0x7ff800000000ae72ULL, nanbits(APFloat::IEEEdouble(), false, false, 0xae72));
1023   ASSERT_EQ(0x7fffffffffffae72ULL, nanbits(APFloat::IEEEdouble(), false, false, 0xffffffffffffae72ULL));
1024   ASSERT_EQ(0x7ff4000000000000ULL, nanbits(APFloat::IEEEdouble(), true, false, 0));
1025   ASSERT_EQ(0xfff4000000000000ULL, nanbits(APFloat::IEEEdouble(), true, true, 0));
1026   ASSERT_EQ(0x7ff000000000ae72ULL, nanbits(APFloat::IEEEdouble(), true, false, 0xae72));
1027   ASSERT_EQ(0x7ff7ffffffffae72ULL, nanbits(APFloat::IEEEdouble(), true, false, 0xffffffffffffae72ULL));
1028 }
1029
1030 #ifdef GTEST_HAS_DEATH_TEST
1031 #ifndef NDEBUG
1032 TEST(APFloatTest, SemanticsDeath) {
1033   EXPECT_DEATH(APFloat(APFloat::IEEEsingle(), 0.0f).convertToDouble(), "Float semantics are not IEEEdouble");
1034   EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), 0.0 ).convertToFloat(),  "Float semantics are not IEEEsingle");
1035 }
1036
1037 TEST(APFloatTest, StringDecimalDeath) {
1038   EXPECT_DEATH(APFloat(APFloat::IEEEdouble(),  ""), "Invalid string length");
1039   EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "+"), "String has no digits");
1040   EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "-"), "String has no digits");
1041
1042   EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), StringRef("\0", 1)), "Invalid character in significand");
1043   EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), StringRef("1\0", 2)), "Invalid character in significand");
1044   EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), StringRef("1\02", 3)), "Invalid character in significand");
1045   EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), StringRef("1\02e1", 5)), "Invalid character in significand");
1046   EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), StringRef("1e\0", 3)), "Invalid character in exponent");
1047   EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), StringRef("1e1\0", 4)), "Invalid character in exponent");
1048   EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), StringRef("1e1\02", 5)), "Invalid character in exponent");
1049
1050   EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "1.0f"), "Invalid character in significand");
1051
1052   EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), ".."), "String contains multiple dots");
1053   EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "..0"), "String contains multiple dots");
1054   EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "1.0.0"), "String contains multiple dots");
1055 }
1056
1057 TEST(APFloatTest, StringDecimalSignificandDeath) {
1058   EXPECT_DEATH(APFloat(APFloat::IEEEdouble(),  "."), "Significand has no digits");
1059   EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "+."), "Significand has no digits");
1060   EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "-."), "Significand has no digits");
1061
1062
1063   EXPECT_DEATH(APFloat(APFloat::IEEEdouble(),  "e"), "Significand has no digits");
1064   EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "+e"), "Significand has no digits");
1065   EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "-e"), "Significand has no digits");
1066
1067   EXPECT_DEATH(APFloat(APFloat::IEEEdouble(),  "e1"), "Significand has no digits");
1068   EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "+e1"), "Significand has no digits");
1069   EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "-e1"), "Significand has no digits");
1070
1071   EXPECT_DEATH(APFloat(APFloat::IEEEdouble(),  ".e1"), "Significand has no digits");
1072   EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "+.e1"), "Significand has no digits");
1073   EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "-.e1"), "Significand has no digits");
1074
1075
1076   EXPECT_DEATH(APFloat(APFloat::IEEEdouble(),  ".e"), "Significand has no digits");
1077   EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "+.e"), "Significand has no digits");
1078   EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "-.e"), "Significand has no digits");
1079 }
1080
1081 TEST(APFloatTest, StringDecimalExponentDeath) {
1082   EXPECT_DEATH(APFloat(APFloat::IEEEdouble(),   "1e"), "Exponent has no digits");
1083   EXPECT_DEATH(APFloat(APFloat::IEEEdouble(),  "+1e"), "Exponent has no digits");
1084   EXPECT_DEATH(APFloat(APFloat::IEEEdouble(),  "-1e"), "Exponent has no digits");
1085
1086   EXPECT_DEATH(APFloat(APFloat::IEEEdouble(),   "1.e"), "Exponent has no digits");
1087   EXPECT_DEATH(APFloat(APFloat::IEEEdouble(),  "+1.e"), "Exponent has no digits");
1088   EXPECT_DEATH(APFloat(APFloat::IEEEdouble(),  "-1.e"), "Exponent has no digits");
1089
1090   EXPECT_DEATH(APFloat(APFloat::IEEEdouble(),   ".1e"), "Exponent has no digits");
1091   EXPECT_DEATH(APFloat(APFloat::IEEEdouble(),  "+.1e"), "Exponent has no digits");
1092   EXPECT_DEATH(APFloat(APFloat::IEEEdouble(),  "-.1e"), "Exponent has no digits");
1093
1094   EXPECT_DEATH(APFloat(APFloat::IEEEdouble(),   "1.1e"), "Exponent has no digits");
1095   EXPECT_DEATH(APFloat(APFloat::IEEEdouble(),  "+1.1e"), "Exponent has no digits");
1096   EXPECT_DEATH(APFloat(APFloat::IEEEdouble(),  "-1.1e"), "Exponent has no digits");
1097
1098
1099   EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "1e+"), "Exponent has no digits");
1100   EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "1e-"), "Exponent has no digits");
1101
1102   EXPECT_DEATH(APFloat(APFloat::IEEEdouble(),  ".1e"), "Exponent has no digits");
1103   EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), ".1e+"), "Exponent has no digits");
1104   EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), ".1e-"), "Exponent has no digits");
1105
1106   EXPECT_DEATH(APFloat(APFloat::IEEEdouble(),  "1.0e"), "Exponent has no digits");
1107   EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "1.0e+"), "Exponent has no digits");
1108   EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "1.0e-"), "Exponent has no digits");
1109 }
1110
1111 TEST(APFloatTest, StringHexadecimalDeath) {
1112   EXPECT_DEATH(APFloat(APFloat::IEEEdouble(),  "0x"), "Invalid string");
1113   EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "+0x"), "Invalid string");
1114   EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "-0x"), "Invalid string");
1115
1116   EXPECT_DEATH(APFloat(APFloat::IEEEdouble(),  "0x0"), "Hex strings require an exponent");
1117   EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "+0x0"), "Hex strings require an exponent");
1118   EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "-0x0"), "Hex strings require an exponent");
1119
1120   EXPECT_DEATH(APFloat(APFloat::IEEEdouble(),  "0x0."), "Hex strings require an exponent");
1121   EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "+0x0."), "Hex strings require an exponent");
1122   EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "-0x0."), "Hex strings require an exponent");
1123
1124   EXPECT_DEATH(APFloat(APFloat::IEEEdouble(),  "0x.0"), "Hex strings require an exponent");
1125   EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "+0x.0"), "Hex strings require an exponent");
1126   EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "-0x.0"), "Hex strings require an exponent");
1127
1128   EXPECT_DEATH(APFloat(APFloat::IEEEdouble(),  "0x0.0"), "Hex strings require an exponent");
1129   EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "+0x0.0"), "Hex strings require an exponent");
1130   EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "-0x0.0"), "Hex strings require an exponent");
1131
1132   EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), StringRef("0x\0", 3)), "Invalid character in significand");
1133   EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), StringRef("0x1\0", 4)), "Invalid character in significand");
1134   EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), StringRef("0x1\02", 5)), "Invalid character in significand");
1135   EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), StringRef("0x1\02p1", 7)), "Invalid character in significand");
1136   EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), StringRef("0x1p\0", 5)), "Invalid character in exponent");
1137   EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), StringRef("0x1p1\0", 6)), "Invalid character in exponent");
1138   EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), StringRef("0x1p1\02", 7)), "Invalid character in exponent");
1139
1140   EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "0x1p0f"), "Invalid character in exponent");
1141
1142   EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "0x..p1"), "String contains multiple dots");
1143   EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "0x..0p1"), "String contains multiple dots");
1144   EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "0x1.0.0p1"), "String contains multiple dots");
1145 }
1146
1147 TEST(APFloatTest, StringHexadecimalSignificandDeath) {
1148   EXPECT_DEATH(APFloat(APFloat::IEEEdouble(),  "0x."), "Significand has no digits");
1149   EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "+0x."), "Significand has no digits");
1150   EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "-0x."), "Significand has no digits");
1151
1152   EXPECT_DEATH(APFloat(APFloat::IEEEdouble(),  "0xp"), "Significand has no digits");
1153   EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "+0xp"), "Significand has no digits");
1154   EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "-0xp"), "Significand has no digits");
1155
1156   EXPECT_DEATH(APFloat(APFloat::IEEEdouble(),  "0xp+"), "Significand has no digits");
1157   EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "+0xp+"), "Significand has no digits");
1158   EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "-0xp+"), "Significand has no digits");
1159
1160   EXPECT_DEATH(APFloat(APFloat::IEEEdouble(),  "0xp-"), "Significand has no digits");
1161   EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "+0xp-"), "Significand has no digits");
1162   EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "-0xp-"), "Significand has no digits");
1163
1164
1165   EXPECT_DEATH(APFloat(APFloat::IEEEdouble(),  "0x.p"), "Significand has no digits");
1166   EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "+0x.p"), "Significand has no digits");
1167   EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "-0x.p"), "Significand has no digits");
1168
1169   EXPECT_DEATH(APFloat(APFloat::IEEEdouble(),  "0x.p+"), "Significand has no digits");
1170   EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "+0x.p+"), "Significand has no digits");
1171   EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "-0x.p+"), "Significand has no digits");
1172
1173   EXPECT_DEATH(APFloat(APFloat::IEEEdouble(),  "0x.p-"), "Significand has no digits");
1174   EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "+0x.p-"), "Significand has no digits");
1175   EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "-0x.p-"), "Significand has no digits");
1176 }
1177
1178 TEST(APFloatTest, StringHexadecimalExponentDeath) {
1179   EXPECT_DEATH(APFloat(APFloat::IEEEdouble(),  "0x1p"), "Exponent has no digits");
1180   EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "+0x1p"), "Exponent has no digits");
1181   EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "-0x1p"), "Exponent has no digits");
1182
1183   EXPECT_DEATH(APFloat(APFloat::IEEEdouble(),  "0x1p+"), "Exponent has no digits");
1184   EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "+0x1p+"), "Exponent has no digits");
1185   EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "-0x1p+"), "Exponent has no digits");
1186
1187   EXPECT_DEATH(APFloat(APFloat::IEEEdouble(),  "0x1p-"), "Exponent has no digits");
1188   EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "+0x1p-"), "Exponent has no digits");
1189   EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "-0x1p-"), "Exponent has no digits");
1190
1191
1192   EXPECT_DEATH(APFloat(APFloat::IEEEdouble(),  "0x1.p"), "Exponent has no digits");
1193   EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "+0x1.p"), "Exponent has no digits");
1194   EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "-0x1.p"), "Exponent has no digits");
1195
1196   EXPECT_DEATH(APFloat(APFloat::IEEEdouble(),  "0x1.p+"), "Exponent has no digits");
1197   EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "+0x1.p+"), "Exponent has no digits");
1198   EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "-0x1.p+"), "Exponent has no digits");
1199
1200   EXPECT_DEATH(APFloat(APFloat::IEEEdouble(),  "0x1.p-"), "Exponent has no digits");
1201   EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "+0x1.p-"), "Exponent has no digits");
1202   EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "-0x1.p-"), "Exponent has no digits");
1203
1204
1205   EXPECT_DEATH(APFloat(APFloat::IEEEdouble(),  "0x.1p"), "Exponent has no digits");
1206   EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "+0x.1p"), "Exponent has no digits");
1207   EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "-0x.1p"), "Exponent has no digits");
1208
1209   EXPECT_DEATH(APFloat(APFloat::IEEEdouble(),  "0x.1p+"), "Exponent has no digits");
1210   EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "+0x.1p+"), "Exponent has no digits");
1211   EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "-0x.1p+"), "Exponent has no digits");
1212
1213   EXPECT_DEATH(APFloat(APFloat::IEEEdouble(),  "0x.1p-"), "Exponent has no digits");
1214   EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "+0x.1p-"), "Exponent has no digits");
1215   EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "-0x.1p-"), "Exponent has no digits");
1216
1217
1218   EXPECT_DEATH(APFloat(APFloat::IEEEdouble(),  "0x1.1p"), "Exponent has no digits");
1219   EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "+0x1.1p"), "Exponent has no digits");
1220   EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "-0x1.1p"), "Exponent has no digits");
1221
1222   EXPECT_DEATH(APFloat(APFloat::IEEEdouble(),  "0x1.1p+"), "Exponent has no digits");
1223   EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "+0x1.1p+"), "Exponent has no digits");
1224   EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "-0x1.1p+"), "Exponent has no digits");
1225
1226   EXPECT_DEATH(APFloat(APFloat::IEEEdouble(),  "0x1.1p-"), "Exponent has no digits");
1227   EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "+0x1.1p-"), "Exponent has no digits");
1228   EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "-0x1.1p-"), "Exponent has no digits");
1229 }
1230 #endif
1231 #endif
1232
1233 TEST(APFloatTest, exactInverse) {
1234   APFloat inv(0.0f);
1235
1236   // Trivial operation.
1237   EXPECT_TRUE(APFloat(2.0).getExactInverse(&inv));
1238   EXPECT_TRUE(inv.bitwiseIsEqual(APFloat(0.5)));
1239   EXPECT_TRUE(APFloat(2.0f).getExactInverse(&inv));
1240   EXPECT_TRUE(inv.bitwiseIsEqual(APFloat(0.5f)));
1241   EXPECT_TRUE(APFloat(APFloat::IEEEquad(), "2.0").getExactInverse(&inv));
1242   EXPECT_TRUE(inv.bitwiseIsEqual(APFloat(APFloat::IEEEquad(), "0.5")));
1243   EXPECT_TRUE(APFloat(APFloat::PPCDoubleDouble(), "2.0").getExactInverse(&inv));
1244   EXPECT_TRUE(inv.bitwiseIsEqual(APFloat(APFloat::PPCDoubleDouble(), "0.5")));
1245   EXPECT_TRUE(APFloat(APFloat::x87DoubleExtended(), "2.0").getExactInverse(&inv));
1246   EXPECT_TRUE(inv.bitwiseIsEqual(APFloat(APFloat::x87DoubleExtended(), "0.5")));
1247
1248   // FLT_MIN
1249   EXPECT_TRUE(APFloat(1.17549435e-38f).getExactInverse(&inv));
1250   EXPECT_TRUE(inv.bitwiseIsEqual(APFloat(8.5070592e+37f)));
1251
1252   // Large float, inverse is a denormal.
1253   EXPECT_FALSE(APFloat(1.7014118e38f).getExactInverse(nullptr));
1254   // Zero
1255   EXPECT_FALSE(APFloat(0.0).getExactInverse(nullptr));
1256   // Denormalized float
1257   EXPECT_FALSE(APFloat(1.40129846e-45f).getExactInverse(nullptr));
1258 }
1259
1260 TEST(APFloatTest, roundToIntegral) {
1261   APFloat T(-0.5), S(3.14), R(APFloat::getLargest(APFloat::IEEEdouble())), P(0.0);
1262
1263   P = T;
1264   P.roundToIntegral(APFloat::rmTowardZero);
1265   EXPECT_EQ(-0.0, P.convertToDouble());
1266   P = T;
1267   P.roundToIntegral(APFloat::rmTowardNegative);
1268   EXPECT_EQ(-1.0, P.convertToDouble());
1269   P = T;
1270   P.roundToIntegral(APFloat::rmTowardPositive);
1271   EXPECT_EQ(-0.0, P.convertToDouble());
1272   P = T;
1273   P.roundToIntegral(APFloat::rmNearestTiesToEven);
1274   EXPECT_EQ(-0.0, P.convertToDouble());
1275
1276   P = S;
1277   P.roundToIntegral(APFloat::rmTowardZero);
1278   EXPECT_EQ(3.0, P.convertToDouble());
1279   P = S;
1280   P.roundToIntegral(APFloat::rmTowardNegative);
1281   EXPECT_EQ(3.0, P.convertToDouble());
1282   P = S;
1283   P.roundToIntegral(APFloat::rmTowardPositive);
1284   EXPECT_EQ(4.0, P.convertToDouble());
1285   P = S;
1286   P.roundToIntegral(APFloat::rmNearestTiesToEven);
1287   EXPECT_EQ(3.0, P.convertToDouble());
1288
1289   P = R;
1290   P.roundToIntegral(APFloat::rmTowardZero);
1291   EXPECT_EQ(R.convertToDouble(), P.convertToDouble());
1292   P = R;
1293   P.roundToIntegral(APFloat::rmTowardNegative);
1294   EXPECT_EQ(R.convertToDouble(), P.convertToDouble());
1295   P = R;
1296   P.roundToIntegral(APFloat::rmTowardPositive);
1297   EXPECT_EQ(R.convertToDouble(), P.convertToDouble());
1298   P = R;
1299   P.roundToIntegral(APFloat::rmNearestTiesToEven);
1300   EXPECT_EQ(R.convertToDouble(), P.convertToDouble());
1301
1302   P = APFloat::getZero(APFloat::IEEEdouble());
1303   P.roundToIntegral(APFloat::rmTowardZero);
1304   EXPECT_EQ(0.0, P.convertToDouble());
1305   P = APFloat::getZero(APFloat::IEEEdouble(), true);
1306   P.roundToIntegral(APFloat::rmTowardZero);
1307   EXPECT_EQ(-0.0, P.convertToDouble());
1308   P = APFloat::getNaN(APFloat::IEEEdouble());
1309   P.roundToIntegral(APFloat::rmTowardZero);
1310   EXPECT_TRUE(std::isnan(P.convertToDouble()));
1311   P = APFloat::getInf(APFloat::IEEEdouble());
1312   P.roundToIntegral(APFloat::rmTowardZero);
1313   EXPECT_TRUE(std::isinf(P.convertToDouble()) && P.convertToDouble() > 0.0);
1314   P = APFloat::getInf(APFloat::IEEEdouble(), true);
1315   P.roundToIntegral(APFloat::rmTowardZero);
1316   EXPECT_TRUE(std::isinf(P.convertToDouble()) && P.convertToDouble() < 0.0);
1317 }
1318
1319 TEST(APFloatTest, isInteger) {
1320   APFloat T(-0.0);
1321   EXPECT_TRUE(T.isInteger());
1322   T = APFloat(3.14159);
1323   EXPECT_FALSE(T.isInteger());
1324   T = APFloat::getNaN(APFloat::IEEEdouble());
1325   EXPECT_FALSE(T.isInteger());
1326   T = APFloat::getInf(APFloat::IEEEdouble());
1327   EXPECT_FALSE(T.isInteger());
1328   T = APFloat::getInf(APFloat::IEEEdouble(), true);
1329   EXPECT_FALSE(T.isInteger());
1330   T = APFloat::getLargest(APFloat::IEEEdouble());
1331   EXPECT_TRUE(T.isInteger());
1332 }
1333
1334 TEST(APFloatTest, getLargest) {
1335   EXPECT_EQ(3.402823466e+38f, APFloat::getLargest(APFloat::IEEEsingle()).convertToFloat());
1336   EXPECT_EQ(1.7976931348623158e+308, APFloat::getLargest(APFloat::IEEEdouble()).convertToDouble());
1337 }
1338
1339 TEST(APFloatTest, getSmallest) {
1340   APFloat test = APFloat::getSmallest(APFloat::IEEEsingle(), false);
1341   APFloat expected = APFloat(APFloat::IEEEsingle(), "0x0.000002p-126");
1342   EXPECT_FALSE(test.isNegative());
1343   EXPECT_TRUE(test.isFiniteNonZero());
1344   EXPECT_TRUE(test.isDenormal());
1345   EXPECT_TRUE(test.bitwiseIsEqual(expected));
1346
1347   test = APFloat::getSmallest(APFloat::IEEEsingle(), true);
1348   expected = APFloat(APFloat::IEEEsingle(), "-0x0.000002p-126");
1349   EXPECT_TRUE(test.isNegative());
1350   EXPECT_TRUE(test.isFiniteNonZero());
1351   EXPECT_TRUE(test.isDenormal());
1352   EXPECT_TRUE(test.bitwiseIsEqual(expected));
1353
1354   test = APFloat::getSmallest(APFloat::IEEEquad(), false);
1355   expected = APFloat(APFloat::IEEEquad(), "0x0.0000000000000000000000000001p-16382");
1356   EXPECT_FALSE(test.isNegative());
1357   EXPECT_TRUE(test.isFiniteNonZero());
1358   EXPECT_TRUE(test.isDenormal());
1359   EXPECT_TRUE(test.bitwiseIsEqual(expected));
1360
1361   test = APFloat::getSmallest(APFloat::IEEEquad(), true);
1362   expected = APFloat(APFloat::IEEEquad(), "-0x0.0000000000000000000000000001p-16382");
1363   EXPECT_TRUE(test.isNegative());
1364   EXPECT_TRUE(test.isFiniteNonZero());
1365   EXPECT_TRUE(test.isDenormal());
1366   EXPECT_TRUE(test.bitwiseIsEqual(expected));
1367 }
1368
1369 TEST(APFloatTest, getSmallestNormalized) {
1370   APFloat test = APFloat::getSmallestNormalized(APFloat::IEEEsingle(), false);
1371   APFloat expected = APFloat(APFloat::IEEEsingle(), "0x1p-126");
1372   EXPECT_FALSE(test.isNegative());
1373   EXPECT_TRUE(test.isFiniteNonZero());
1374   EXPECT_FALSE(test.isDenormal());
1375   EXPECT_TRUE(test.bitwiseIsEqual(expected));
1376
1377   test = APFloat::getSmallestNormalized(APFloat::IEEEsingle(), true);
1378   expected = APFloat(APFloat::IEEEsingle(), "-0x1p-126");
1379   EXPECT_TRUE(test.isNegative());
1380   EXPECT_TRUE(test.isFiniteNonZero());
1381   EXPECT_FALSE(test.isDenormal());
1382   EXPECT_TRUE(test.bitwiseIsEqual(expected));
1383
1384   test = APFloat::getSmallestNormalized(APFloat::IEEEquad(), false);
1385   expected = APFloat(APFloat::IEEEquad(), "0x1p-16382");
1386   EXPECT_FALSE(test.isNegative());
1387   EXPECT_TRUE(test.isFiniteNonZero());
1388   EXPECT_FALSE(test.isDenormal());
1389   EXPECT_TRUE(test.bitwiseIsEqual(expected));
1390
1391   test = APFloat::getSmallestNormalized(APFloat::IEEEquad(), true);
1392   expected = APFloat(APFloat::IEEEquad(), "-0x1p-16382");
1393   EXPECT_TRUE(test.isNegative());
1394   EXPECT_TRUE(test.isFiniteNonZero());
1395   EXPECT_FALSE(test.isDenormal());
1396   EXPECT_TRUE(test.bitwiseIsEqual(expected));
1397 }
1398
1399 TEST(APFloatTest, getZero) {
1400   struct {
1401     const fltSemantics *semantics;
1402     const bool sign;
1403     const unsigned long long bitPattern[2];
1404     const unsigned bitPatternLength;
1405   } const GetZeroTest[] = {
1406     { &APFloat::IEEEhalf(), false, {0, 0}, 1},
1407     { &APFloat::IEEEhalf(), true, {0x8000ULL, 0}, 1},
1408     { &APFloat::IEEEsingle(), false, {0, 0}, 1},
1409     { &APFloat::IEEEsingle(), true, {0x80000000ULL, 0}, 1},
1410     { &APFloat::IEEEdouble(), false, {0, 0}, 1},
1411     { &APFloat::IEEEdouble(), true, {0x8000000000000000ULL, 0}, 1},
1412     { &APFloat::IEEEquad(), false, {0, 0}, 2},
1413     { &APFloat::IEEEquad(), true, {0, 0x8000000000000000ULL}, 2},
1414     { &APFloat::PPCDoubleDouble(), false, {0, 0}, 2},
1415     { &APFloat::PPCDoubleDouble(), true, {0x8000000000000000ULL, 0}, 2},
1416     { &APFloat::x87DoubleExtended(), false, {0, 0}, 2},
1417     { &APFloat::x87DoubleExtended(), true, {0, 0x8000ULL}, 2},
1418   };
1419   const unsigned NumGetZeroTests = 12;
1420   for (unsigned i = 0; i < NumGetZeroTests; ++i) {
1421     APFloat test = APFloat::getZero(*GetZeroTest[i].semantics,
1422                                     GetZeroTest[i].sign);
1423     const char *pattern = GetZeroTest[i].sign? "-0x0p+0" : "0x0p+0";
1424     APFloat expected = APFloat(*GetZeroTest[i].semantics,
1425                                pattern);
1426     EXPECT_TRUE(test.isZero());
1427     EXPECT_TRUE(GetZeroTest[i].sign? test.isNegative() : !test.isNegative());
1428     EXPECT_TRUE(test.bitwiseIsEqual(expected));
1429     for (unsigned j = 0, je = GetZeroTest[i].bitPatternLength; j < je; ++j) {
1430       EXPECT_EQ(GetZeroTest[i].bitPattern[j],
1431                 test.bitcastToAPInt().getRawData()[j]);
1432     }
1433   }
1434 }
1435
1436 TEST(APFloatTest, copySign) {
1437   EXPECT_TRUE(APFloat(-42.0).bitwiseIsEqual(
1438       APFloat::copySign(APFloat(42.0), APFloat(-1.0))));
1439   EXPECT_TRUE(APFloat(42.0).bitwiseIsEqual(
1440       APFloat::copySign(APFloat(-42.0), APFloat(1.0))));
1441   EXPECT_TRUE(APFloat(-42.0).bitwiseIsEqual(
1442       APFloat::copySign(APFloat(-42.0), APFloat(-1.0))));
1443   EXPECT_TRUE(APFloat(42.0).bitwiseIsEqual(
1444       APFloat::copySign(APFloat(42.0), APFloat(1.0))));
1445 }
1446
1447 TEST(APFloatTest, convert) {
1448   bool losesInfo;
1449   APFloat test(APFloat::IEEEdouble(), "1.0");
1450   test.convert(APFloat::IEEEsingle(), APFloat::rmNearestTiesToEven, &losesInfo);
1451   EXPECT_EQ(1.0f, test.convertToFloat());
1452   EXPECT_FALSE(losesInfo);
1453
1454   test = APFloat(APFloat::x87DoubleExtended(), "0x1p-53");
1455   test.add(APFloat(APFloat::x87DoubleExtended(), "1.0"), APFloat::rmNearestTiesToEven);
1456   test.convert(APFloat::IEEEdouble(), APFloat::rmNearestTiesToEven, &losesInfo);
1457   EXPECT_EQ(1.0, test.convertToDouble());
1458   EXPECT_TRUE(losesInfo);
1459
1460   test = APFloat(APFloat::IEEEquad(), "0x1p-53");
1461   test.add(APFloat(APFloat::IEEEquad(), "1.0"), APFloat::rmNearestTiesToEven);
1462   test.convert(APFloat::IEEEdouble(), APFloat::rmNearestTiesToEven, &losesInfo);
1463   EXPECT_EQ(1.0, test.convertToDouble());
1464   EXPECT_TRUE(losesInfo);
1465
1466   test = APFloat(APFloat::x87DoubleExtended(), "0xf.fffffffp+28");
1467   test.convert(APFloat::IEEEdouble(), APFloat::rmNearestTiesToEven, &losesInfo);
1468   EXPECT_EQ(4294967295.0, test.convertToDouble());
1469   EXPECT_FALSE(losesInfo);
1470
1471   test = APFloat::getSNaN(APFloat::IEEEsingle());
1472   APFloat X87SNaN = APFloat::getSNaN(APFloat::x87DoubleExtended());
1473   test.convert(APFloat::x87DoubleExtended(), APFloat::rmNearestTiesToEven,
1474                &losesInfo);
1475   EXPECT_TRUE(test.bitwiseIsEqual(X87SNaN));
1476   EXPECT_FALSE(losesInfo);
1477
1478   test = APFloat::getQNaN(APFloat::IEEEsingle());
1479   APFloat X87QNaN = APFloat::getQNaN(APFloat::x87DoubleExtended());
1480   test.convert(APFloat::x87DoubleExtended(), APFloat::rmNearestTiesToEven,
1481                &losesInfo);
1482   EXPECT_TRUE(test.bitwiseIsEqual(X87QNaN));
1483   EXPECT_FALSE(losesInfo);
1484
1485   test = APFloat::getSNaN(APFloat::x87DoubleExtended());
1486   test.convert(APFloat::x87DoubleExtended(), APFloat::rmNearestTiesToEven,
1487                &losesInfo);
1488   EXPECT_TRUE(test.bitwiseIsEqual(X87SNaN));
1489   EXPECT_FALSE(losesInfo);
1490
1491   test = APFloat::getQNaN(APFloat::x87DoubleExtended());
1492   test.convert(APFloat::x87DoubleExtended(), APFloat::rmNearestTiesToEven,
1493                &losesInfo);
1494   EXPECT_TRUE(test.bitwiseIsEqual(X87QNaN));
1495   EXPECT_FALSE(losesInfo);
1496 }
1497
1498 TEST(APFloatTest, PPCDoubleDouble) {
1499   APFloat test(APFloat::PPCDoubleDouble(), "1.0");
1500   EXPECT_EQ(0x3ff0000000000000ull, test.bitcastToAPInt().getRawData()[0]);
1501   EXPECT_EQ(0x0000000000000000ull, test.bitcastToAPInt().getRawData()[1]);
1502
1503   // LDBL_MAX
1504   test = APFloat(APFloat::PPCDoubleDouble(), "1.79769313486231580793728971405301e+308");
1505   EXPECT_EQ(0x7fefffffffffffffull, test.bitcastToAPInt().getRawData()[0]);
1506   EXPECT_EQ(0x7c8ffffffffffffeull, test.bitcastToAPInt().getRawData()[1]);
1507
1508   // LDBL_MIN
1509   test = APFloat(APFloat::PPCDoubleDouble(), "2.00416836000897277799610805135016e-292");
1510   EXPECT_EQ(0x0360000000000000ull, test.bitcastToAPInt().getRawData()[0]);
1511   EXPECT_EQ(0x0000000000000000ull, test.bitcastToAPInt().getRawData()[1]);
1512
1513   // PR30869
1514   {
1515     auto Result = APFloat(APFloat::PPCDoubleDouble(), "1.0") +
1516                   APFloat(APFloat::PPCDoubleDouble(), "1.0");
1517     EXPECT_EQ(&APFloat::PPCDoubleDouble(), &Result.getSemantics());
1518
1519     Result = APFloat(APFloat::PPCDoubleDouble(), "1.0") -
1520              APFloat(APFloat::PPCDoubleDouble(), "1.0");
1521     EXPECT_EQ(&APFloat::PPCDoubleDouble(), &Result.getSemantics());
1522
1523     Result = APFloat(APFloat::PPCDoubleDouble(), "1.0") *
1524              APFloat(APFloat::PPCDoubleDouble(), "1.0");
1525     EXPECT_EQ(&APFloat::PPCDoubleDouble(), &Result.getSemantics());
1526
1527     Result = APFloat(APFloat::PPCDoubleDouble(), "1.0") /
1528              APFloat(APFloat::PPCDoubleDouble(), "1.0");
1529     EXPECT_EQ(&APFloat::PPCDoubleDouble(), &Result.getSemantics());
1530
1531     int Exp;
1532     Result = frexp(APFloat(APFloat::PPCDoubleDouble(), "1.0"), Exp,
1533                    APFloat::rmNearestTiesToEven);
1534     EXPECT_EQ(&APFloat::PPCDoubleDouble(), &Result.getSemantics());
1535
1536     Result = scalbn(APFloat(APFloat::PPCDoubleDouble(), "1.0"), 1,
1537                     APFloat::rmNearestTiesToEven);
1538     EXPECT_EQ(&APFloat::PPCDoubleDouble(), &Result.getSemantics());
1539   }
1540 }
1541
1542 TEST(APFloatTest, isNegative) {
1543   APFloat t(APFloat::IEEEsingle(), "0x1p+0");
1544   EXPECT_FALSE(t.isNegative());
1545   t = APFloat(APFloat::IEEEsingle(), "-0x1p+0");
1546   EXPECT_TRUE(t.isNegative());
1547
1548   EXPECT_FALSE(APFloat::getInf(APFloat::IEEEsingle(), false).isNegative());
1549   EXPECT_TRUE(APFloat::getInf(APFloat::IEEEsingle(), true).isNegative());
1550
1551   EXPECT_FALSE(APFloat::getZero(APFloat::IEEEsingle(), false).isNegative());
1552   EXPECT_TRUE(APFloat::getZero(APFloat::IEEEsingle(), true).isNegative());
1553
1554   EXPECT_FALSE(APFloat::getNaN(APFloat::IEEEsingle(), false).isNegative());
1555   EXPECT_TRUE(APFloat::getNaN(APFloat::IEEEsingle(), true).isNegative());
1556
1557   EXPECT_FALSE(APFloat::getSNaN(APFloat::IEEEsingle(), false).isNegative());
1558   EXPECT_TRUE(APFloat::getSNaN(APFloat::IEEEsingle(), true).isNegative());
1559 }
1560
1561 TEST(APFloatTest, isNormal) {
1562   APFloat t(APFloat::IEEEsingle(), "0x1p+0");
1563   EXPECT_TRUE(t.isNormal());
1564
1565   EXPECT_FALSE(APFloat::getInf(APFloat::IEEEsingle(), false).isNormal());
1566   EXPECT_FALSE(APFloat::getZero(APFloat::IEEEsingle(), false).isNormal());
1567   EXPECT_FALSE(APFloat::getNaN(APFloat::IEEEsingle(), false).isNormal());
1568   EXPECT_FALSE(APFloat::getSNaN(APFloat::IEEEsingle(), false).isNormal());
1569   EXPECT_FALSE(APFloat(APFloat::IEEEsingle(), "0x1p-149").isNormal());
1570 }
1571
1572 TEST(APFloatTest, isFinite) {
1573   APFloat t(APFloat::IEEEsingle(), "0x1p+0");
1574   EXPECT_TRUE(t.isFinite());
1575   EXPECT_FALSE(APFloat::getInf(APFloat::IEEEsingle(), false).isFinite());
1576   EXPECT_TRUE(APFloat::getZero(APFloat::IEEEsingle(), false).isFinite());
1577   EXPECT_FALSE(APFloat::getNaN(APFloat::IEEEsingle(), false).isFinite());
1578   EXPECT_FALSE(APFloat::getSNaN(APFloat::IEEEsingle(), false).isFinite());
1579   EXPECT_TRUE(APFloat(APFloat::IEEEsingle(), "0x1p-149").isFinite());
1580 }
1581
1582 TEST(APFloatTest, isInfinity) {
1583   APFloat t(APFloat::IEEEsingle(), "0x1p+0");
1584   EXPECT_FALSE(t.isInfinity());
1585   EXPECT_TRUE(APFloat::getInf(APFloat::IEEEsingle(), false).isInfinity());
1586   EXPECT_FALSE(APFloat::getZero(APFloat::IEEEsingle(), false).isInfinity());
1587   EXPECT_FALSE(APFloat::getNaN(APFloat::IEEEsingle(), false).isInfinity());
1588   EXPECT_FALSE(APFloat::getSNaN(APFloat::IEEEsingle(), false).isInfinity());
1589   EXPECT_FALSE(APFloat(APFloat::IEEEsingle(), "0x1p-149").isInfinity());
1590 }
1591
1592 TEST(APFloatTest, isNaN) {
1593   APFloat t(APFloat::IEEEsingle(), "0x1p+0");
1594   EXPECT_FALSE(t.isNaN());
1595   EXPECT_FALSE(APFloat::getInf(APFloat::IEEEsingle(), false).isNaN());
1596   EXPECT_FALSE(APFloat::getZero(APFloat::IEEEsingle(), false).isNaN());
1597   EXPECT_TRUE(APFloat::getNaN(APFloat::IEEEsingle(), false).isNaN());
1598   EXPECT_TRUE(APFloat::getSNaN(APFloat::IEEEsingle(), false).isNaN());
1599   EXPECT_FALSE(APFloat(APFloat::IEEEsingle(), "0x1p-149").isNaN());
1600 }
1601
1602 TEST(APFloatTest, isFiniteNonZero) {
1603   // Test positive/negative normal value.
1604   EXPECT_TRUE(APFloat(APFloat::IEEEsingle(), "0x1p+0").isFiniteNonZero());
1605   EXPECT_TRUE(APFloat(APFloat::IEEEsingle(), "-0x1p+0").isFiniteNonZero());
1606
1607   // Test positive/negative denormal value.
1608   EXPECT_TRUE(APFloat(APFloat::IEEEsingle(), "0x1p-149").isFiniteNonZero());
1609   EXPECT_TRUE(APFloat(APFloat::IEEEsingle(), "-0x1p-149").isFiniteNonZero());
1610
1611   // Test +/- Infinity.
1612   EXPECT_FALSE(APFloat::getInf(APFloat::IEEEsingle(), false).isFiniteNonZero());
1613   EXPECT_FALSE(APFloat::getInf(APFloat::IEEEsingle(), true).isFiniteNonZero());
1614
1615   // Test +/- Zero.
1616   EXPECT_FALSE(APFloat::getZero(APFloat::IEEEsingle(), false).isFiniteNonZero());
1617   EXPECT_FALSE(APFloat::getZero(APFloat::IEEEsingle(), true).isFiniteNonZero());
1618
1619   // Test +/- qNaN. +/- dont mean anything with qNaN but paranoia can't hurt in
1620   // this instance.
1621   EXPECT_FALSE(APFloat::getNaN(APFloat::IEEEsingle(), false).isFiniteNonZero());
1622   EXPECT_FALSE(APFloat::getNaN(APFloat::IEEEsingle(), true).isFiniteNonZero());
1623
1624   // Test +/- sNaN. +/- dont mean anything with sNaN but paranoia can't hurt in
1625   // this instance.
1626   EXPECT_FALSE(APFloat::getSNaN(APFloat::IEEEsingle(), false).isFiniteNonZero());
1627   EXPECT_FALSE(APFloat::getSNaN(APFloat::IEEEsingle(), true).isFiniteNonZero());
1628 }
1629
1630 TEST(APFloatTest, add) {
1631   // Test Special Cases against each other and normal values.
1632
1633   // TODOS/NOTES:
1634   // 1. Since we perform only default exception handling all operations with
1635   // signaling NaNs should have a result that is a quiet NaN. Currently they
1636   // return sNaN.
1637
1638   APFloat PInf = APFloat::getInf(APFloat::IEEEsingle(), false);
1639   APFloat MInf = APFloat::getInf(APFloat::IEEEsingle(), true);
1640   APFloat PZero = APFloat::getZero(APFloat::IEEEsingle(), false);
1641   APFloat MZero = APFloat::getZero(APFloat::IEEEsingle(), true);
1642   APFloat QNaN = APFloat::getNaN(APFloat::IEEEsingle(), false);
1643   APFloat SNaN = APFloat::getSNaN(APFloat::IEEEsingle(), false);
1644   APFloat PNormalValue = APFloat(APFloat::IEEEsingle(), "0x1p+0");
1645   APFloat MNormalValue = APFloat(APFloat::IEEEsingle(), "-0x1p+0");
1646   APFloat PLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), false);
1647   APFloat MLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), true);
1648   APFloat PSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), false);
1649   APFloat MSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), true);
1650   APFloat PSmallestNormalized =
1651     APFloat::getSmallestNormalized(APFloat::IEEEsingle(), false);
1652   APFloat MSmallestNormalized =
1653     APFloat::getSmallestNormalized(APFloat::IEEEsingle(), true);
1654
1655   const int OverflowStatus = APFloat::opOverflow | APFloat::opInexact;
1656
1657   const unsigned NumTests = 169;
1658   struct {
1659     APFloat x;
1660     APFloat y;
1661     const char *result;
1662     int status;
1663     int category;
1664   } SpecialCaseTests[NumTests] = {
1665     { PInf, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
1666     { PInf, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1667     { PInf, PZero, "inf", APFloat::opOK, APFloat::fcInfinity },
1668     { PInf, MZero, "inf", APFloat::opOK, APFloat::fcInfinity },
1669     { PInf, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
1670 #if 0
1671     // See Note 1.
1672     { PInf, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1673 #endif
1674     { PInf, PNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity },
1675     { PInf, MNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity },
1676     { PInf, PLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
1677     { PInf, MLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
1678     { PInf, PSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
1679     { PInf, MSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
1680     { PInf, PSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity },
1681     { PInf, MSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity },
1682     { MInf, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1683     { MInf, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
1684     { MInf, PZero, "-inf", APFloat::opOK, APFloat::fcInfinity },
1685     { MInf, MZero, "-inf", APFloat::opOK, APFloat::fcInfinity },
1686     { MInf, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
1687 #if 0
1688     // See Note 1.
1689     { MInf, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1690 #endif
1691     { MInf, PNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
1692     { MInf, MNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
1693     { MInf, PLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
1694     { MInf, MLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
1695     { MInf, PSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
1696     { MInf, MSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
1697     { MInf, PSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity },
1698     { MInf, MSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity },
1699     { PZero, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
1700     { PZero, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
1701     { PZero, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
1702     { PZero, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
1703     { PZero, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
1704 #if 0
1705     // See Note 1.
1706     { PZero, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1707 #endif
1708     { PZero, PNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
1709     { PZero, MNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
1710     { PZero, PLargestValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
1711     { PZero, MLargestValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
1712     { PZero, PSmallestValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
1713     { PZero, MSmallestValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
1714     { PZero, PSmallestNormalized, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
1715     { PZero, MSmallestNormalized, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
1716     { MZero, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
1717     { MZero, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
1718     { MZero, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
1719     { MZero, MZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
1720     { MZero, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
1721 #if 0
1722     // See Note 1.
1723     { MZero, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1724 #endif
1725     { MZero, PNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
1726     { MZero, MNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
1727     { MZero, PLargestValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
1728     { MZero, MLargestValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
1729     { MZero, PSmallestValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
1730     { MZero, MSmallestValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
1731     { MZero, PSmallestNormalized, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
1732     { MZero, MSmallestNormalized, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
1733     { QNaN, PInf, "nan", APFloat::opOK, APFloat::fcNaN },
1734     { QNaN, MInf, "nan", APFloat::opOK, APFloat::fcNaN },
1735     { QNaN, PZero, "nan", APFloat::opOK, APFloat::fcNaN },
1736     { QNaN, MZero, "nan", APFloat::opOK, APFloat::fcNaN },
1737     { QNaN, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
1738 #if 0
1739     // See Note 1.
1740     { QNaN, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1741 #endif
1742     { QNaN, PNormalValue, "nan", APFloat::opOK, APFloat::fcNaN },
1743     { QNaN, MNormalValue, "nan", APFloat::opOK, APFloat::fcNaN },
1744     { QNaN, PLargestValue, "nan", APFloat::opOK, APFloat::fcNaN },
1745     { QNaN, MLargestValue, "nan", APFloat::opOK, APFloat::fcNaN },
1746     { QNaN, PSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN },
1747     { QNaN, MSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN },
1748     { QNaN, PSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN },
1749     { QNaN, MSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN },
1750 #if 0
1751     // See Note 1.
1752     { SNaN, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1753     { SNaN, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1754     { SNaN, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1755     { SNaN, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1756     { SNaN, QNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1757     { SNaN, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1758     { SNaN, PNormalValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1759     { SNaN, MNormalValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1760     { SNaN, PLargestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1761     { SNaN, MLargestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1762     { SNaN, PSmallestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1763     { SNaN, MSmallestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1764     { SNaN, PSmallestNormalized, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1765     { SNaN, MSmallestNormalized, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1766 #endif
1767     { PNormalValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
1768     { PNormalValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
1769     { PNormalValue, PZero, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
1770     { PNormalValue, MZero, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
1771     { PNormalValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
1772 #if 0
1773     // See Note 1.
1774     { PNormalValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1775 #endif
1776     { PNormalValue, PNormalValue, "0x1p+1", APFloat::opOK, APFloat::fcNormal },
1777     { PNormalValue, MNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
1778     { PNormalValue, PLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1779     { PNormalValue, MLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1780     { PNormalValue, PSmallestValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1781     { PNormalValue, MSmallestValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1782     { PNormalValue, PSmallestNormalized, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1783     { PNormalValue, MSmallestNormalized, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1784     { MNormalValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
1785     { MNormalValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
1786     { MNormalValue, PZero, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
1787     { MNormalValue, MZero, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
1788     { MNormalValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
1789 #if 0
1790     // See Note 1.
1791     { MNormalValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1792 #endif
1793     { MNormalValue, PNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
1794     { MNormalValue, MNormalValue, "-0x1p+1", APFloat::opOK, APFloat::fcNormal },
1795     { MNormalValue, PLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1796     { MNormalValue, MLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1797     { MNormalValue, PSmallestValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1798     { MNormalValue, MSmallestValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1799     { MNormalValue, PSmallestNormalized, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1800     { MNormalValue, MSmallestNormalized, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1801     { PLargestValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
1802     { PLargestValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
1803     { PLargestValue, PZero, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
1804     { PLargestValue, MZero, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
1805     { PLargestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
1806 #if 0
1807     // See Note 1.
1808     { PLargestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1809 #endif
1810     { PLargestValue, PNormalValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1811     { PLargestValue, MNormalValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1812     { PLargestValue, PLargestValue, "inf", OverflowStatus, APFloat::fcInfinity },
1813     { PLargestValue, MLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
1814     { PLargestValue, PSmallestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1815     { PLargestValue, MSmallestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1816     { PLargestValue, PSmallestNormalized, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1817     { PLargestValue, MSmallestNormalized, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1818     { MLargestValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
1819     { MLargestValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
1820     { MLargestValue, PZero, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
1821     { MLargestValue, MZero, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
1822     { MLargestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
1823 #if 0
1824     // See Note 1.
1825     { MLargestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1826 #endif
1827     { MLargestValue, PNormalValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1828     { MLargestValue, MNormalValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1829     { MLargestValue, PLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
1830     { MLargestValue, MLargestValue, "-inf", OverflowStatus, APFloat::fcInfinity },
1831     { MLargestValue, PSmallestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1832     { MLargestValue, MSmallestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1833     { MLargestValue, PSmallestNormalized, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1834     { MLargestValue, MSmallestNormalized, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1835     { PSmallestValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
1836     { PSmallestValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
1837     { PSmallestValue, PZero, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
1838     { PSmallestValue, MZero, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
1839     { PSmallestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
1840 #if 0
1841     // See Note 1.
1842     { PSmallestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1843 #endif
1844     { PSmallestValue, PNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1845     { PSmallestValue, MNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1846     { PSmallestValue, PLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1847     { PSmallestValue, MLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1848     { PSmallestValue, PSmallestValue, "0x1p-148", APFloat::opOK, APFloat::fcNormal },
1849     { PSmallestValue, MSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
1850     { PSmallestValue, PSmallestNormalized, "0x1.000002p-126", APFloat::opOK, APFloat::fcNormal },
1851     { PSmallestValue, MSmallestNormalized, "-0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal },
1852     { MSmallestValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
1853     { MSmallestValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
1854     { MSmallestValue, PZero, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
1855     { MSmallestValue, MZero, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
1856     { MSmallestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
1857 #if 0
1858     // See Note 1.
1859     { MSmallestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1860 #endif
1861     { MSmallestValue, PNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1862     { MSmallestValue, MNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1863     { MSmallestValue, PLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1864     { MSmallestValue, MLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1865     { MSmallestValue, PSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
1866     { MSmallestValue, MSmallestValue, "-0x1p-148", APFloat::opOK, APFloat::fcNormal },
1867     { MSmallestValue, PSmallestNormalized, "0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal },
1868     { MSmallestValue, MSmallestNormalized, "-0x1.000002p-126", APFloat::opOK, APFloat::fcNormal },
1869     { PSmallestNormalized, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
1870     { PSmallestNormalized, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
1871     { PSmallestNormalized, PZero, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
1872     { PSmallestNormalized, MZero, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
1873     { PSmallestNormalized, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
1874 #if 0
1875 // See Note 1.
1876     { PSmallestNormalized, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1877 #endif
1878     { PSmallestNormalized, PNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1879     { PSmallestNormalized, MNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1880     { PSmallestNormalized, PLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1881     { PSmallestNormalized, MLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1882     { PSmallestNormalized, PSmallestValue, "0x1.000002p-126", APFloat::opOK, APFloat::fcNormal },
1883     { PSmallestNormalized, MSmallestValue, "0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal },
1884     { PSmallestNormalized, PSmallestNormalized, "0x1p-125", APFloat::opOK, APFloat::fcNormal },
1885     { PSmallestNormalized, MSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero },
1886     { MSmallestNormalized, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
1887     { MSmallestNormalized, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
1888     { MSmallestNormalized, PZero, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
1889     { MSmallestNormalized, MZero, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
1890     { MSmallestNormalized, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
1891 #if 0
1892     // See Note 1.
1893     { MSmallestNormalized, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1894 #endif
1895     { MSmallestNormalized, PNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1896     { MSmallestNormalized, MNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1897     { MSmallestNormalized, PLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1898     { MSmallestNormalized, MLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1899     { MSmallestNormalized, PSmallestValue, "-0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal },
1900     { MSmallestNormalized, MSmallestValue, "-0x1.000002p-126", APFloat::opOK, APFloat::fcNormal },
1901     { MSmallestNormalized, PSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero },
1902     { MSmallestNormalized, MSmallestNormalized, "-0x1p-125", APFloat::opOK, APFloat::fcNormal }
1903   };
1904
1905   for (size_t i = 0; i < NumTests; ++i) {
1906     APFloat x(SpecialCaseTests[i].x);
1907     APFloat y(SpecialCaseTests[i].y);
1908     APFloat::opStatus status = x.add(y, APFloat::rmNearestTiesToEven);
1909
1910     APFloat result(APFloat::IEEEsingle(), SpecialCaseTests[i].result);
1911
1912     EXPECT_TRUE(result.bitwiseIsEqual(x));
1913     EXPECT_TRUE((int)status == SpecialCaseTests[i].status);
1914     EXPECT_TRUE((int)x.getCategory() == SpecialCaseTests[i].category);
1915   }
1916 }
1917
1918 TEST(APFloatTest, subtract) {
1919   // Test Special Cases against each other and normal values.
1920
1921   // TODOS/NOTES:
1922   // 1. Since we perform only default exception handling all operations with
1923   // signaling NaNs should have a result that is a quiet NaN. Currently they
1924   // return sNaN.
1925
1926   APFloat PInf = APFloat::getInf(APFloat::IEEEsingle(), false);
1927   APFloat MInf = APFloat::getInf(APFloat::IEEEsingle(), true);
1928   APFloat PZero = APFloat::getZero(APFloat::IEEEsingle(), false);
1929   APFloat MZero = APFloat::getZero(APFloat::IEEEsingle(), true);
1930   APFloat QNaN = APFloat::getNaN(APFloat::IEEEsingle(), false);
1931   APFloat SNaN = APFloat::getSNaN(APFloat::IEEEsingle(), false);
1932   APFloat PNormalValue = APFloat(APFloat::IEEEsingle(), "0x1p+0");
1933   APFloat MNormalValue = APFloat(APFloat::IEEEsingle(), "-0x1p+0");
1934   APFloat PLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), false);
1935   APFloat MLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), true);
1936   APFloat PSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), false);
1937   APFloat MSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), true);
1938   APFloat PSmallestNormalized =
1939     APFloat::getSmallestNormalized(APFloat::IEEEsingle(), false);
1940   APFloat MSmallestNormalized =
1941     APFloat::getSmallestNormalized(APFloat::IEEEsingle(), true);
1942
1943   const int OverflowStatus = APFloat::opOverflow | APFloat::opInexact;
1944
1945   const unsigned NumTests = 169;
1946   struct {
1947     APFloat x;
1948     APFloat y;
1949     const char *result;
1950     int status;
1951     int category;
1952   } SpecialCaseTests[NumTests] = {
1953     { PInf, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1954     { PInf, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
1955     { PInf, PZero, "inf", APFloat::opOK, APFloat::fcInfinity },
1956     { PInf, MZero, "inf", APFloat::opOK, APFloat::fcInfinity },
1957     { PInf, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
1958 #if 0
1959 // See Note 1.
1960     { PInf, SNaN, "-nan", APFloat::opInvalidOp, APFloat::fcNaN },
1961 #endif
1962     { PInf, PNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity },
1963     { PInf, MNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity },
1964     { PInf, PLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
1965     { PInf, MLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
1966     { PInf, PSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
1967     { PInf, MSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
1968     { PInf, PSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity },
1969     { PInf, MSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity },
1970     { MInf, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
1971     { MInf, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1972     { MInf, PZero, "-inf", APFloat::opOK, APFloat::fcInfinity },
1973     { MInf, MZero, "-inf", APFloat::opOK, APFloat::fcInfinity },
1974     { MInf, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
1975 #if 0
1976 // See Note 1.
1977     { MInf, SNaN, "-nan", APFloat::opInvalidOp, APFloat::fcNaN },
1978 #endif
1979     { MInf, PNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
1980     { MInf, MNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
1981     { MInf, PLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
1982     { MInf, MLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
1983     { MInf, PSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
1984     { MInf, MSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
1985     { MInf, PSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity },
1986     { MInf, MSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity },
1987     { PZero, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
1988     { PZero, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
1989     { PZero, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
1990     { PZero, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
1991     { PZero, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
1992 #if 0
1993 // See Note 1.
1994     { PZero, SNaN, "-nan", APFloat::opInvalidOp, APFloat::fcNaN },
1995 #endif
1996     { PZero, PNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
1997     { PZero, MNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
1998     { PZero, PLargestValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
1999     { PZero, MLargestValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2000     { PZero, PSmallestValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
2001     { PZero, MSmallestValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
2002     { PZero, PSmallestNormalized, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
2003     { PZero, MSmallestNormalized, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
2004     { MZero, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2005     { MZero, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2006     { MZero, PZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2007     { MZero, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2008     { MZero, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
2009 #if 0
2010 // See Note 1.
2011     { MZero, SNaN, "-nan", APFloat::opInvalidOp, APFloat::fcNaN },
2012 #endif
2013     { MZero, PNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2014     { MZero, MNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2015     { MZero, PLargestValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2016     { MZero, MLargestValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2017     { MZero, PSmallestValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
2018     { MZero, MSmallestValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
2019     { MZero, PSmallestNormalized, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
2020     { MZero, MSmallestNormalized, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
2021     { QNaN, PInf, "nan", APFloat::opOK, APFloat::fcNaN },
2022     { QNaN, MInf, "nan", APFloat::opOK, APFloat::fcNaN },
2023     { QNaN, PZero, "nan", APFloat::opOK, APFloat::fcNaN },
2024     { QNaN, MZero, "nan", APFloat::opOK, APFloat::fcNaN },
2025     { QNaN, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2026 #if 0
2027 // See Note 1.
2028     { QNaN, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2029 #endif
2030     { QNaN, PNormalValue, "nan", APFloat::opOK, APFloat::fcNaN },
2031     { QNaN, MNormalValue, "nan", APFloat::opOK, APFloat::fcNaN },
2032     { QNaN, PLargestValue, "nan", APFloat::opOK, APFloat::fcNaN },
2033     { QNaN, MLargestValue, "nan", APFloat::opOK, APFloat::fcNaN },
2034     { QNaN, PSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN },
2035     { QNaN, MSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN },
2036     { QNaN, PSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN },
2037     { QNaN, MSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN },
2038 #if 0
2039 // See Note 1.
2040     { SNaN, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2041     { SNaN, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2042     { SNaN, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2043     { SNaN, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2044     { SNaN, QNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2045     { SNaN, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2046     { SNaN, PNormalValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2047     { SNaN, MNormalValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2048     { SNaN, PLargestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2049     { SNaN, MLargestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2050     { SNaN, PSmallestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2051     { SNaN, MSmallestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2052     { SNaN, PSmallestNormalized, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2053     { SNaN, MSmallestNormalized, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2054 #endif
2055     { PNormalValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2056     { PNormalValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2057     { PNormalValue, PZero, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2058     { PNormalValue, MZero, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2059     { PNormalValue, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
2060 #if 0
2061 // See Note 1.
2062     { PNormalValue, SNaN, "-nan", APFloat::opInvalidOp, APFloat::fcNaN },
2063 #endif
2064     { PNormalValue, PNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2065     { PNormalValue, MNormalValue, "0x1p+1", APFloat::opOK, APFloat::fcNormal },
2066     { PNormalValue, PLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2067     { PNormalValue, MLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2068     { PNormalValue, PSmallestValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2069     { PNormalValue, MSmallestValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2070     { PNormalValue, PSmallestNormalized, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2071     { PNormalValue, MSmallestNormalized, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2072     { MNormalValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2073     { MNormalValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2074     { MNormalValue, PZero, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2075     { MNormalValue, MZero, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2076     { MNormalValue, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
2077 #if 0
2078 // See Note 1.
2079     { MNormalValue, SNaN, "-nan", APFloat::opInvalidOp, APFloat::fcNaN },
2080 #endif
2081     { MNormalValue, PNormalValue, "-0x1p+1", APFloat::opOK, APFloat::fcNormal },
2082     { MNormalValue, MNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2083     { MNormalValue, PLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2084     { MNormalValue, MLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2085     { MNormalValue, PSmallestValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2086     { MNormalValue, MSmallestValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2087     { MNormalValue, PSmallestNormalized, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2088     { MNormalValue, MSmallestNormalized, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2089     { PLargestValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2090     { PLargestValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2091     { PLargestValue, PZero, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2092     { PLargestValue, MZero, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2093     { PLargestValue, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
2094 #if 0
2095 // See Note 1.
2096     { PLargestValue, SNaN, "-nan", APFloat::opInvalidOp, APFloat::fcNaN },
2097 #endif
2098     { PLargestValue, PNormalValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2099     { PLargestValue, MNormalValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2100     { PLargestValue, PLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2101     { PLargestValue, MLargestValue, "inf", OverflowStatus, APFloat::fcInfinity },
2102     { PLargestValue, PSmallestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2103     { PLargestValue, MSmallestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2104     { PLargestValue, PSmallestNormalized, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2105     { PLargestValue, MSmallestNormalized, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2106     { MLargestValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2107     { MLargestValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2108     { MLargestValue, PZero, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2109     { MLargestValue, MZero, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2110     { MLargestValue, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
2111 #if 0
2112 // See Note 1.
2113     { MLargestValue, SNaN, "-nan", APFloat::opInvalidOp, APFloat::fcNaN },
2114 #endif
2115     { MLargestValue, PNormalValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2116     { MLargestValue, MNormalValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2117     { MLargestValue, PLargestValue, "-inf", OverflowStatus, APFloat::fcInfinity },
2118     { MLargestValue, MLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2119     { MLargestValue, PSmallestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2120     { MLargestValue, MSmallestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2121     { MLargestValue, PSmallestNormalized, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2122     { MLargestValue, MSmallestNormalized, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2123     { PSmallestValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2124     { PSmallestValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2125     { PSmallestValue, PZero, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
2126     { PSmallestValue, MZero, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
2127     { PSmallestValue, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
2128 #if 0
2129 // See Note 1.
2130     { PSmallestValue, SNaN, "-nan", APFloat::opInvalidOp, APFloat::fcNaN },
2131 #endif
2132     { PSmallestValue, PNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2133     { PSmallestValue, MNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2134     { PSmallestValue, PLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2135     { PSmallestValue, MLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2136     { PSmallestValue, PSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2137     { PSmallestValue, MSmallestValue, "0x1p-148", APFloat::opOK, APFloat::fcNormal },
2138     { PSmallestValue, PSmallestNormalized, "-0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal },
2139     { PSmallestValue, MSmallestNormalized, "0x1.000002p-126", APFloat::opOK, APFloat::fcNormal },
2140     { MSmallestValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2141     { MSmallestValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2142     { MSmallestValue, PZero, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
2143     { MSmallestValue, MZero, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
2144     { MSmallestValue, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
2145 #if 0
2146 // See Note 1.
2147     { MSmallestValue, SNaN, "-nan", APFloat::opInvalidOp, APFloat::fcNaN },
2148 #endif
2149     { MSmallestValue, PNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2150     { MSmallestValue, MNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2151     { MSmallestValue, PLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2152     { MSmallestValue, MLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2153     { MSmallestValue, PSmallestValue, "-0x1p-148", APFloat::opOK, APFloat::fcNormal },
2154     { MSmallestValue, MSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2155     { MSmallestValue, PSmallestNormalized, "-0x1.000002p-126", APFloat::opOK, APFloat::fcNormal },
2156     { MSmallestValue, MSmallestNormalized, "0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal },
2157     { PSmallestNormalized, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2158     { PSmallestNormalized, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2159     { PSmallestNormalized, PZero, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
2160     { PSmallestNormalized, MZero, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
2161     { PSmallestNormalized, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
2162 #if 0
2163 // See Note 1.
2164     { PSmallestNormalized, SNaN, "-nan", APFloat::opInvalidOp, APFloat::fcNaN },
2165 #endif
2166     { PSmallestNormalized, PNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2167     { PSmallestNormalized, MNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2168     { PSmallestNormalized, PLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2169     { PSmallestNormalized, MLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2170     { PSmallestNormalized, PSmallestValue, "0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal },
2171     { PSmallestNormalized, MSmallestValue, "0x1.000002p-126", APFloat::opOK, APFloat::fcNormal },
2172     { PSmallestNormalized, PSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2173     { PSmallestNormalized, MSmallestNormalized, "0x1p-125", APFloat::opOK, APFloat::fcNormal },
2174     { MSmallestNormalized, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2175     { MSmallestNormalized, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2176     { MSmallestNormalized, PZero, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
2177     { MSmallestNormalized, MZero, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
2178     { MSmallestNormalized, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
2179 #if 0
2180 // See Note 1.
2181     { MSmallestNormalized, SNaN, "-nan", APFloat::opInvalidOp, APFloat::fcNaN },
2182 #endif
2183     { MSmallestNormalized, PNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2184     { MSmallestNormalized, MNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2185     { MSmallestNormalized, PLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2186     { MSmallestNormalized, MLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2187     { MSmallestNormalized, PSmallestValue, "-0x1.000002p-126", APFloat::opOK, APFloat::fcNormal },
2188     { MSmallestNormalized, MSmallestValue, "-0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal },
2189     { MSmallestNormalized, PSmallestNormalized, "-0x1p-125", APFloat::opOK, APFloat::fcNormal },
2190     { MSmallestNormalized, MSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero }
2191   };
2192
2193   for (size_t i = 0; i < NumTests; ++i) {
2194     APFloat x(SpecialCaseTests[i].x);
2195     APFloat y(SpecialCaseTests[i].y);
2196     APFloat::opStatus status = x.subtract(y, APFloat::rmNearestTiesToEven);
2197
2198     APFloat result(APFloat::IEEEsingle(), SpecialCaseTests[i].result);
2199
2200     EXPECT_TRUE(result.bitwiseIsEqual(x));
2201     EXPECT_TRUE((int)status == SpecialCaseTests[i].status);
2202     EXPECT_TRUE((int)x.getCategory() == SpecialCaseTests[i].category);
2203   }
2204 }
2205
2206 TEST(APFloatTest, multiply) {
2207   // Test Special Cases against each other and normal values.
2208
2209   // TODOS/NOTES:
2210   // 1. Since we perform only default exception handling all operations with
2211   // signaling NaNs should have a result that is a quiet NaN. Currently they
2212   // return sNaN.
2213
2214   APFloat PInf = APFloat::getInf(APFloat::IEEEsingle(), false);
2215   APFloat MInf = APFloat::getInf(APFloat::IEEEsingle(), true);
2216   APFloat PZero = APFloat::getZero(APFloat::IEEEsingle(), false);
2217   APFloat MZero = APFloat::getZero(APFloat::IEEEsingle(), true);
2218   APFloat QNaN = APFloat::getNaN(APFloat::IEEEsingle(), false);
2219   APFloat SNaN = APFloat::getSNaN(APFloat::IEEEsingle(), false);
2220   APFloat PNormalValue = APFloat(APFloat::IEEEsingle(), "0x1p+0");
2221   APFloat MNormalValue = APFloat(APFloat::IEEEsingle(), "-0x1p+0");
2222   APFloat PLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), false);
2223   APFloat MLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), true);
2224   APFloat PSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), false);
2225   APFloat MSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), true);
2226   APFloat PSmallestNormalized =
2227     APFloat::getSmallestNormalized(APFloat::IEEEsingle(), false);
2228   APFloat MSmallestNormalized =
2229     APFloat::getSmallestNormalized(APFloat::IEEEsingle(), true);
2230
2231   const int OverflowStatus = APFloat::opOverflow | APFloat::opInexact;
2232   const int UnderflowStatus = APFloat::opUnderflow | APFloat::opInexact;
2233
2234   const unsigned NumTests = 169;
2235   struct {
2236     APFloat x;
2237     APFloat y;
2238     const char *result;
2239     int status;
2240     int category;
2241   } SpecialCaseTests[NumTests] = {
2242     { PInf, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2243     { PInf, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2244     { PInf, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2245     { PInf, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2246     { PInf, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2247 #if 0
2248 // See Note 1.
2249     { PInf, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2250 #endif
2251     { PInf, PNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2252     { PInf, MNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2253     { PInf, PLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2254     { PInf, MLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2255     { PInf, PSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2256     { PInf, MSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2257     { PInf, PSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity },
2258     { PInf, MSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity },
2259     { MInf, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2260     { MInf, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2261     { MInf, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2262     { MInf, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2263     { MInf, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2264 #if 0
2265 // See Note 1.
2266     { MInf, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2267 #endif
2268     { MInf, PNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2269     { MInf, MNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2270     { MInf, PLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2271     { MInf, MLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2272     { MInf, PSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2273     { MInf, MSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2274     { MInf, PSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity },
2275     { MInf, MSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity },
2276     { PZero, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2277     { PZero, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2278     { PZero, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2279     { PZero, MZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2280     { PZero, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2281 #if 0
2282 // See Note 1.
2283     { PZero, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2284 #endif
2285     { PZero, PNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2286     { PZero, MNormalValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2287     { PZero, PLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2288     { PZero, MLargestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2289     { PZero, PSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2290     { PZero, MSmallestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2291     { PZero, PSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2292     { PZero, MSmallestNormalized, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2293     { MZero, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2294     { MZero, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2295     { MZero, PZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2296     { MZero, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2297     { MZero, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2298 #if 0
2299 // See Note 1.
2300     { MZero, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2301 #endif
2302     { MZero, PNormalValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2303     { MZero, MNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2304     { MZero, PLargestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2305     { MZero, MLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2306     { MZero, PSmallestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2307     { MZero, MSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2308     { MZero, PSmallestNormalized, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2309     { MZero, MSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2310     { QNaN, PInf, "nan", APFloat::opOK, APFloat::fcNaN },
2311     { QNaN, MInf, "nan", APFloat::opOK, APFloat::fcNaN },
2312     { QNaN, PZero, "nan", APFloat::opOK, APFloat::fcNaN },
2313     { QNaN, MZero, "nan", APFloat::opOK, APFloat::fcNaN },
2314     { QNaN, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2315 #if 0
2316 // See Note 1.
2317     { QNaN, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2318 #endif
2319     { QNaN, PNormalValue, "nan", APFloat::opOK, APFloat::fcNaN },
2320     { QNaN, MNormalValue, "nan", APFloat::opOK, APFloat::fcNaN },
2321     { QNaN, PLargestValue, "nan", APFloat::opOK, APFloat::fcNaN },
2322     { QNaN, MLargestValue, "nan", APFloat::opOK, APFloat::fcNaN },
2323     { QNaN, PSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN },
2324     { QNaN, MSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN },
2325     { QNaN, PSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN },
2326     { QNaN, MSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN },
2327 #if 0
2328 // See Note 1.
2329     { SNaN, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2330     { SNaN, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2331     { SNaN, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2332     { SNaN, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2333     { SNaN, QNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2334     { SNaN, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2335     { SNaN, PNormalValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2336     { SNaN, MNormalValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2337     { SNaN, PLargestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2338     { SNaN, MLargestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2339     { SNaN, PSmallestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2340     { SNaN, MSmallestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2341     { SNaN, PSmallestNormalized, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2342     { SNaN, MSmallestNormalized, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2343 #endif
2344     { PNormalValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2345     { PNormalValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2346     { PNormalValue, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2347     { PNormalValue, MZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2348     { PNormalValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2349 #if 0
2350 // See Note 1.
2351     { PNormalValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2352 #endif
2353     { PNormalValue, PNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2354     { PNormalValue, MNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2355     { PNormalValue, PLargestValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2356     { PNormalValue, MLargestValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2357     { PNormalValue, PSmallestValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
2358     { PNormalValue, MSmallestValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
2359     { PNormalValue, PSmallestNormalized, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
2360     { PNormalValue, MSmallestNormalized, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
2361     { MNormalValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2362     { MNormalValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2363     { MNormalValue, PZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2364     { MNormalValue, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2365     { MNormalValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2366 #if 0
2367 // See Note 1.
2368     { MNormalValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2369 #endif
2370     { MNormalValue, PNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2371     { MNormalValue, MNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2372     { MNormalValue, PLargestValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2373     { MNormalValue, MLargestValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2374     { MNormalValue, PSmallestValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
2375     { MNormalValue, MSmallestValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
2376     { MNormalValue, PSmallestNormalized, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
2377     { MNormalValue, MSmallestNormalized, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
2378     { PLargestValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2379     { PLargestValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2380     { PLargestValue, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2381     { PLargestValue, MZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2382     { PLargestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2383 #if 0
2384 // See Note 1.
2385     { PLargestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2386 #endif
2387     { PLargestValue, PNormalValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2388     { PLargestValue, MNormalValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2389     { PLargestValue, PLargestValue, "inf", OverflowStatus, APFloat::fcInfinity },
2390     { PLargestValue, MLargestValue, "-inf", OverflowStatus, APFloat::fcInfinity },
2391     { PLargestValue, PSmallestValue, "0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal },
2392     { PLargestValue, MSmallestValue, "-0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal },
2393     { PLargestValue, PSmallestNormalized, "0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal },
2394     { PLargestValue, MSmallestNormalized, "-0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal },
2395     { MLargestValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2396     { MLargestValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2397     { MLargestValue, PZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2398     { MLargestValue, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2399     { MLargestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2400 #if 0
2401 // See Note 1.
2402     { MLargestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2403 #endif
2404     { MLargestValue, PNormalValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2405     { MLargestValue, MNormalValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2406     { MLargestValue, PLargestValue, "-inf", OverflowStatus, APFloat::fcInfinity },
2407     { MLargestValue, MLargestValue, "inf", OverflowStatus, APFloat::fcInfinity },
2408     { MLargestValue, PSmallestValue, "-0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal },
2409     { MLargestValue, MSmallestValue, "0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal },
2410     { MLargestValue, PSmallestNormalized, "-0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal },
2411     { MLargestValue, MSmallestNormalized, "0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal },
2412     { PSmallestValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2413     { PSmallestValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2414     { PSmallestValue, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2415     { PSmallestValue, MZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2416     { PSmallestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2417 #if 0
2418 // See Note 1.
2419     { PSmallestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2420 #endif
2421     { PSmallestValue, PNormalValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
2422     { PSmallestValue, MNormalValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
2423     { PSmallestValue, PLargestValue, "0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal },
2424     { PSmallestValue, MLargestValue, "-0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal },
2425     { PSmallestValue, PSmallestValue, "0x0p+0", UnderflowStatus, APFloat::fcZero },
2426     { PSmallestValue, MSmallestValue, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
2427     { PSmallestValue, PSmallestNormalized, "0x0p+0", UnderflowStatus, APFloat::fcZero },
2428     { PSmallestValue, MSmallestNormalized, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
2429     { MSmallestValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2430     { MSmallestValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2431     { MSmallestValue, PZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2432     { MSmallestValue, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2433     { MSmallestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2434 #if 0
2435 // See Note 1.
2436     { MSmallestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2437 #endif
2438     { MSmallestValue, PNormalValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
2439     { MSmallestValue, MNormalValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
2440     { MSmallestValue, PLargestValue, "-0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal },
2441     { MSmallestValue, MLargestValue, "0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal },
2442     { MSmallestValue, PSmallestValue, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
2443     { MSmallestValue, MSmallestValue, "0x0p+0", UnderflowStatus, APFloat::fcZero },
2444     { MSmallestValue, PSmallestNormalized, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
2445     { MSmallestValue, MSmallestNormalized, "0x0p+0", UnderflowStatus, APFloat::fcZero },
2446     { PSmallestNormalized, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2447     { PSmallestNormalized, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2448     { PSmallestNormalized, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2449     { PSmallestNormalized, MZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2450     { PSmallestNormalized, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2451 #if 0
2452 // See Note 1.
2453     { PSmallestNormalized, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2454 #endif
2455     { PSmallestNormalized, PNormalValue, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
2456     { PSmallestNormalized, MNormalValue, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
2457     { PSmallestNormalized, PLargestValue, "0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal },
2458     { PSmallestNormalized, MLargestValue, "-0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal },
2459     { PSmallestNormalized, PSmallestValue, "0x0p+0", UnderflowStatus, APFloat::fcZero },
2460     { PSmallestNormalized, MSmallestValue, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
2461     { PSmallestNormalized, PSmallestNormalized, "0x0p+0", UnderflowStatus, APFloat::fcZero },
2462     { PSmallestNormalized, MSmallestNormalized, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
2463     { MSmallestNormalized, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2464     { MSmallestNormalized, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2465     { MSmallestNormalized, PZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2466     { MSmallestNormalized, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2467     { MSmallestNormalized, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2468 #if 0
2469 // See Note 1.
2470     { MSmallestNormalized, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2471 #endif
2472     { MSmallestNormalized, PNormalValue, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
2473     { MSmallestNormalized, MNormalValue, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
2474     { MSmallestNormalized, PLargestValue, "-0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal },
2475     { MSmallestNormalized, MLargestValue, "0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal },
2476     { MSmallestNormalized, PSmallestValue, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
2477     { MSmallestNormalized, MSmallestValue, "0x0p+0", UnderflowStatus, APFloat::fcZero },
2478     { MSmallestNormalized, PSmallestNormalized, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
2479     { MSmallestNormalized, MSmallestNormalized, "0x0p+0", UnderflowStatus, APFloat::fcZero }
2480   };
2481
2482   for (size_t i = 0; i < NumTests; ++i) {
2483     APFloat x(SpecialCaseTests[i].x);
2484     APFloat y(SpecialCaseTests[i].y);
2485     APFloat::opStatus status = x.multiply(y, APFloat::rmNearestTiesToEven);
2486
2487     APFloat result(APFloat::IEEEsingle(), SpecialCaseTests[i].result);
2488
2489     EXPECT_TRUE(result.bitwiseIsEqual(x));
2490     EXPECT_TRUE((int)status == SpecialCaseTests[i].status);
2491     EXPECT_TRUE((int)x.getCategory() == SpecialCaseTests[i].category);
2492   }
2493 }
2494
2495 TEST(APFloatTest, divide) {
2496   // Test Special Cases against each other and normal values.
2497
2498   // TODOS/NOTES:
2499   // 1. Since we perform only default exception handling all operations with
2500   // signaling NaNs should have a result that is a quiet NaN. Currently they
2501   // return sNaN.
2502
2503   APFloat PInf = APFloat::getInf(APFloat::IEEEsingle(), false);
2504   APFloat MInf = APFloat::getInf(APFloat::IEEEsingle(), true);
2505   APFloat PZero = APFloat::getZero(APFloat::IEEEsingle(), false);
2506   APFloat MZero = APFloat::getZero(APFloat::IEEEsingle(), true);
2507   APFloat QNaN = APFloat::getNaN(APFloat::IEEEsingle(), false);
2508   APFloat SNaN = APFloat::getSNaN(APFloat::IEEEsingle(), false);
2509   APFloat PNormalValue = APFloat(APFloat::IEEEsingle(), "0x1p+0");
2510   APFloat MNormalValue = APFloat(APFloat::IEEEsingle(), "-0x1p+0");
2511   APFloat PLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), false);
2512   APFloat MLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), true);
2513   APFloat PSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), false);
2514   APFloat MSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), true);
2515   APFloat PSmallestNormalized =
2516     APFloat::getSmallestNormalized(APFloat::IEEEsingle(), false);
2517   APFloat MSmallestNormalized =
2518     APFloat::getSmallestNormalized(APFloat::IEEEsingle(), true);
2519
2520   const int OverflowStatus = APFloat::opOverflow | APFloat::opInexact;
2521   const int UnderflowStatus = APFloat::opUnderflow | APFloat::opInexact;
2522
2523   const unsigned NumTests = 169;
2524   struct {
2525     APFloat x;
2526     APFloat y;
2527     const char *result;
2528     int status;
2529     int category;
2530   } SpecialCaseTests[NumTests] = {
2531     { PInf, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2532     { PInf, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2533     { PInf, PZero, "inf", APFloat::opOK, APFloat::fcInfinity },
2534     { PInf, MZero, "-inf", APFloat::opOK, APFloat::fcInfinity },
2535     { PInf, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2536 #if 0
2537 // See Note 1.
2538     { PInf, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2539 #endif
2540     { PInf, PNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2541     { PInf, MNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2542     { PInf, PLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2543     { PInf, MLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2544     { PInf, PSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2545     { PInf, MSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2546     { PInf, PSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity },
2547     { PInf, MSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity },
2548     { MInf, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2549     { MInf, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2550     { MInf, PZero, "-inf", APFloat::opOK, APFloat::fcInfinity },
2551     { MInf, MZero, "inf", APFloat::opOK, APFloat::fcInfinity },
2552     { MInf, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2553 #if 0
2554 // See Note 1.
2555     { MInf, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2556 #endif
2557     { MInf, PNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2558     { MInf, MNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2559     { MInf, PLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2560     { MInf, MLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2561     { MInf, PSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2562     { MInf, MSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2563     { MInf, PSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity },
2564     { MInf, MSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity },
2565     { PZero, PInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2566     { PZero, MInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2567     { PZero, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2568     { PZero, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2569     { PZero, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2570 #if 0
2571 // See Note 1.
2572     { PZero, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2573 #endif
2574     { PZero, PNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2575     { PZero, MNormalValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2576     { PZero, PLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2577     { PZero, MLargestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2578     { PZero, PSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2579     { PZero, MSmallestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2580     { PZero, PSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2581     { PZero, MSmallestNormalized, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2582     { MZero, PInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2583     { MZero, MInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2584     { MZero, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2585     { MZero, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2586     { MZero, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2587 #if 0
2588 // See Note 1.
2589     { MZero, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2590 #endif
2591     { MZero, PNormalValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2592     { MZero, MNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2593     { MZero, PLargestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2594     { MZero, MLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2595     { MZero, PSmallestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2596     { MZero, MSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2597     { MZero, PSmallestNormalized, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2598     { MZero, MSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2599     { QNaN, PInf, "nan", APFloat::opOK, APFloat::fcNaN },
2600     { QNaN, MInf, "nan", APFloat::opOK, APFloat::fcNaN },
2601     { QNaN, PZero, "nan", APFloat::opOK, APFloat::fcNaN },
2602     { QNaN, MZero, "nan", APFloat::opOK, APFloat::fcNaN },
2603     { QNaN, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2604 #if 0
2605 // See Note 1.
2606     { QNaN, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2607 #endif
2608     { QNaN, PNormalValue, "nan", APFloat::opOK, APFloat::fcNaN },
2609     { QNaN, MNormalValue, "nan", APFloat::opOK, APFloat::fcNaN },
2610     { QNaN, PLargestValue, "nan", APFloat::opOK, APFloat::fcNaN },
2611     { QNaN, MLargestValue, "nan", APFloat::opOK, APFloat::fcNaN },
2612     { QNaN, PSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN },
2613     { QNaN, MSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN },
2614     { QNaN, PSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN },
2615     { QNaN, MSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN },
2616 #if 0
2617 // See Note 1.
2618     { SNaN, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2619     { SNaN, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2620     { SNaN, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2621     { SNaN, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2622     { SNaN, QNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2623     { SNaN, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2624     { SNaN, PNormalValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2625     { SNaN, MNormalValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2626     { SNaN, PLargestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2627     { SNaN, MLargestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2628     { SNaN, PSmallestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2629     { SNaN, MSmallestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2630     { SNaN, PSmallestNormalized, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2631     { SNaN, MSmallestNormalized, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2632 #endif
2633     { PNormalValue, PInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2634     { PNormalValue, MInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2635     { PNormalValue, PZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity },
2636     { PNormalValue, MZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity },
2637     { PNormalValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2638 #if 0
2639 // See Note 1.
2640     { PNormalValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2641 #endif
2642     { PNormalValue, PNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2643     { PNormalValue, MNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2644     { PNormalValue, PLargestValue, "0x1p-128", UnderflowStatus, APFloat::fcNormal },
2645     { PNormalValue, MLargestValue, "-0x1p-128", UnderflowStatus, APFloat::fcNormal },
2646     { PNormalValue, PSmallestValue, "inf", OverflowStatus, APFloat::fcInfinity },
2647     { PNormalValue, MSmallestValue, "-inf", OverflowStatus, APFloat::fcInfinity },
2648     { PNormalValue, PSmallestNormalized, "0x1p+126", APFloat::opOK, APFloat::fcNormal },
2649     { PNormalValue, MSmallestNormalized, "-0x1p+126", APFloat::opOK, APFloat::fcNormal },
2650     { MNormalValue, PInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2651     { MNormalValue, MInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2652     { MNormalValue, PZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity },
2653     { MNormalValue, MZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity },
2654     { MNormalValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2655 #if 0
2656 // See Note 1.
2657     { MNormalValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2658 #endif
2659     { MNormalValue, PNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2660     { MNormalValue, MNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2661     { MNormalValue, PLargestValue, "-0x1p-128", UnderflowStatus, APFloat::fcNormal },
2662     { MNormalValue, MLargestValue, "0x1p-128", UnderflowStatus, APFloat::fcNormal },
2663     { MNormalValue, PSmallestValue, "-inf", OverflowStatus, APFloat::fcInfinity },
2664     { MNormalValue, MSmallestValue, "inf", OverflowStatus, APFloat::fcInfinity },
2665     { MNormalValue, PSmallestNormalized, "-0x1p+126", APFloat::opOK, APFloat::fcNormal },
2666     { MNormalValue, MSmallestNormalized, "0x1p+126", APFloat::opOK, APFloat::fcNormal },
2667     { PLargestValue, PInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2668     { PLargestValue, MInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2669     { PLargestValue, PZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity },
2670     { PLargestValue, MZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity },
2671     { PLargestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2672 #if 0
2673 // See Note 1.
2674     { PLargestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2675 #endif
2676     { PLargestValue, PNormalValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2677     { PLargestValue, MNormalValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2678     { PLargestValue, PLargestValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2679     { PLargestValue, MLargestValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2680     { PLargestValue, PSmallestValue, "inf", OverflowStatus, APFloat::fcInfinity },
2681     { PLargestValue, MSmallestValue, "-inf", OverflowStatus, APFloat::fcInfinity },
2682     { PLargestValue, PSmallestNormalized, "inf", OverflowStatus, APFloat::fcInfinity },
2683     { PLargestValue, MSmallestNormalized, "-inf", OverflowStatus, APFloat::fcInfinity },
2684     { MLargestValue, PInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2685     { MLargestValue, MInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2686     { MLargestValue, PZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity },
2687     { MLargestValue, MZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity },
2688     { MLargestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2689 #if 0
2690 // See Note 1.
2691     { MLargestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2692 #endif
2693     { MLargestValue, PNormalValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2694     { MLargestValue, MNormalValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2695     { MLargestValue, PLargestValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2696     { MLargestValue, MLargestValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2697     { MLargestValue, PSmallestValue, "-inf", OverflowStatus, APFloat::fcInfinity },
2698     { MLargestValue, MSmallestValue, "inf", OverflowStatus, APFloat::fcInfinity },
2699     { MLargestValue, PSmallestNormalized, "-inf", OverflowStatus, APFloat::fcInfinity },
2700     { MLargestValue, MSmallestNormalized, "inf", OverflowStatus, APFloat::fcInfinity },
2701     { PSmallestValue, PInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2702     { PSmallestValue, MInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2703     { PSmallestValue, PZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity },
2704     { PSmallestValue, MZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity },
2705     { PSmallestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2706 #if 0
2707 // See Note 1.
2708     { PSmallestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2709 #endif
2710     { PSmallestValue, PNormalValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
2711     { PSmallestValue, MNormalValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
2712     { PSmallestValue, PLargestValue, "0x0p+0", UnderflowStatus, APFloat::fcZero },
2713     { PSmallestValue, MLargestValue, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
2714     { PSmallestValue, PSmallestValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2715     { PSmallestValue, MSmallestValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2716     { PSmallestValue, PSmallestNormalized, "0x1p-23", APFloat::opOK, APFloat::fcNormal },
2717     { PSmallestValue, MSmallestNormalized, "-0x1p-23", APFloat::opOK, APFloat::fcNormal },
2718     { MSmallestValue, PInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2719     { MSmallestValue, MInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2720     { MSmallestValue, PZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity },
2721     { MSmallestValue, MZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity },
2722     { MSmallestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2723 #if 0
2724 // See Note 1.
2725     { MSmallestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2726 #endif
2727     { MSmallestValue, PNormalValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
2728     { MSmallestValue, MNormalValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
2729     { MSmallestValue, PLargestValue, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
2730     { MSmallestValue, MLargestValue, "0x0p+0", UnderflowStatus, APFloat::fcZero },
2731     { MSmallestValue, PSmallestValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2732     { MSmallestValue, MSmallestValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2733     { MSmallestValue, PSmallestNormalized, "-0x1p-23", APFloat::opOK, APFloat::fcNormal },
2734     { MSmallestValue, MSmallestNormalized, "0x1p-23", APFloat::opOK, APFloat::fcNormal },
2735     { PSmallestNormalized, PInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2736     { PSmallestNormalized, MInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2737     { PSmallestNormalized, PZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity },
2738     { PSmallestNormalized, MZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity },
2739     { PSmallestNormalized, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2740 #if 0
2741 // See Note 1.
2742     { PSmallestNormalized, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2743 #endif
2744     { PSmallestNormalized, PNormalValue, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
2745     { PSmallestNormalized, MNormalValue, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
2746     { PSmallestNormalized, PLargestValue, "0x0p+0", UnderflowStatus, APFloat::fcZero },
2747     { PSmallestNormalized, MLargestValue, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
2748     { PSmallestNormalized, PSmallestValue, "0x1p+23", APFloat::opOK, APFloat::fcNormal },
2749     { PSmallestNormalized, MSmallestValue, "-0x1p+23", APFloat::opOK, APFloat::fcNormal },
2750     { PSmallestNormalized, PSmallestNormalized, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2751     { PSmallestNormalized, MSmallestNormalized, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2752     { MSmallestNormalized, PInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2753     { MSmallestNormalized, MInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2754     { MSmallestNormalized, PZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity },
2755     { MSmallestNormalized, MZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity },
2756     { MSmallestNormalized, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2757 #if 0
2758 // See Note 1.
2759     { MSmallestNormalized, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2760 #endif
2761     { MSmallestNormalized, PNormalValue, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
2762     { MSmallestNormalized, MNormalValue, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
2763     { MSmallestNormalized, PLargestValue, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
2764     { MSmallestNormalized, MLargestValue, "0x0p+0", UnderflowStatus, APFloat::fcZero },
2765     { MSmallestNormalized, PSmallestValue, "-0x1p+23", APFloat::opOK, APFloat::fcNormal },
2766     { MSmallestNormalized, MSmallestValue, "0x1p+23", APFloat::opOK, APFloat::fcNormal },
2767     { MSmallestNormalized, PSmallestNormalized, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2768     { MSmallestNormalized, MSmallestNormalized, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2769   };
2770
2771   for (size_t i = 0; i < NumTests; ++i) {
2772     APFloat x(SpecialCaseTests[i].x);
2773     APFloat y(SpecialCaseTests[i].y);
2774     APFloat::opStatus status = x.divide(y, APFloat::rmNearestTiesToEven);
2775
2776     APFloat result(APFloat::IEEEsingle(), SpecialCaseTests[i].result);
2777
2778     EXPECT_TRUE(result.bitwiseIsEqual(x));
2779     EXPECT_TRUE((int)status == SpecialCaseTests[i].status);
2780     EXPECT_TRUE((int)x.getCategory() == SpecialCaseTests[i].category);
2781   }
2782 }
2783
2784 TEST(APFloatTest, operatorOverloads) {
2785   // This is mostly testing that these operator overloads compile.
2786   APFloat One = APFloat(APFloat::IEEEsingle(), "0x1p+0");
2787   APFloat Two = APFloat(APFloat::IEEEsingle(), "0x2p+0");
2788   EXPECT_TRUE(Two.bitwiseIsEqual(One + One));
2789   EXPECT_TRUE(One.bitwiseIsEqual(Two - One));
2790   EXPECT_TRUE(Two.bitwiseIsEqual(One * Two));
2791   EXPECT_TRUE(One.bitwiseIsEqual(Two / Two));
2792 }
2793
2794 TEST(APFloatTest, abs) {
2795   APFloat PInf = APFloat::getInf(APFloat::IEEEsingle(), false);
2796   APFloat MInf = APFloat::getInf(APFloat::IEEEsingle(), true);
2797   APFloat PZero = APFloat::getZero(APFloat::IEEEsingle(), false);
2798   APFloat MZero = APFloat::getZero(APFloat::IEEEsingle(), true);
2799   APFloat PQNaN = APFloat::getNaN(APFloat::IEEEsingle(), false);
2800   APFloat MQNaN = APFloat::getNaN(APFloat::IEEEsingle(), true);
2801   APFloat PSNaN = APFloat::getSNaN(APFloat::IEEEsingle(), false);
2802   APFloat MSNaN = APFloat::getSNaN(APFloat::IEEEsingle(), true);
2803   APFloat PNormalValue = APFloat(APFloat::IEEEsingle(), "0x1p+0");
2804   APFloat MNormalValue = APFloat(APFloat::IEEEsingle(), "-0x1p+0");
2805   APFloat PLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), false);
2806   APFloat MLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), true);
2807   APFloat PSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), false);
2808   APFloat MSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), true);
2809   APFloat PSmallestNormalized =
2810     APFloat::getSmallestNormalized(APFloat::IEEEsingle(), false);
2811   APFloat MSmallestNormalized =
2812     APFloat::getSmallestNormalized(APFloat::IEEEsingle(), true);
2813
2814   EXPECT_TRUE(PInf.bitwiseIsEqual(abs(PInf)));
2815   EXPECT_TRUE(PInf.bitwiseIsEqual(abs(MInf)));
2816   EXPECT_TRUE(PZero.bitwiseIsEqual(abs(PZero)));
2817   EXPECT_TRUE(PZero.bitwiseIsEqual(abs(MZero)));
2818   EXPECT_TRUE(PQNaN.bitwiseIsEqual(abs(PQNaN)));
2819   EXPECT_TRUE(PQNaN.bitwiseIsEqual(abs(MQNaN)));
2820   EXPECT_TRUE(PSNaN.bitwiseIsEqual(abs(PSNaN)));
2821   EXPECT_TRUE(PSNaN.bitwiseIsEqual(abs(MSNaN)));
2822   EXPECT_TRUE(PNormalValue.bitwiseIsEqual(abs(PNormalValue)));
2823   EXPECT_TRUE(PNormalValue.bitwiseIsEqual(abs(MNormalValue)));
2824   EXPECT_TRUE(PLargestValue.bitwiseIsEqual(abs(PLargestValue)));
2825   EXPECT_TRUE(PLargestValue.bitwiseIsEqual(abs(MLargestValue)));
2826   EXPECT_TRUE(PSmallestValue.bitwiseIsEqual(abs(PSmallestValue)));
2827   EXPECT_TRUE(PSmallestValue.bitwiseIsEqual(abs(MSmallestValue)));
2828   EXPECT_TRUE(PSmallestNormalized.bitwiseIsEqual(abs(PSmallestNormalized)));
2829   EXPECT_TRUE(PSmallestNormalized.bitwiseIsEqual(abs(MSmallestNormalized)));
2830 }
2831
2832 TEST(APFloatTest, ilogb) {
2833   EXPECT_EQ(-1074, ilogb(APFloat::getSmallest(APFloat::IEEEdouble(), false)));
2834   EXPECT_EQ(-1074, ilogb(APFloat::getSmallest(APFloat::IEEEdouble(), true)));
2835   EXPECT_EQ(-1023, ilogb(APFloat(APFloat::IEEEdouble(), "0x1.ffffffffffffep-1024")));
2836   EXPECT_EQ(-1023, ilogb(APFloat(APFloat::IEEEdouble(), "0x1.ffffffffffffep-1023")));
2837   EXPECT_EQ(-1023, ilogb(APFloat(APFloat::IEEEdouble(), "-0x1.ffffffffffffep-1023")));
2838   EXPECT_EQ(-51, ilogb(APFloat(APFloat::IEEEdouble(), "0x1p-51")));
2839   EXPECT_EQ(-1023, ilogb(APFloat(APFloat::IEEEdouble(), "0x1.c60f120d9f87cp-1023")));
2840   EXPECT_EQ(-2, ilogb(APFloat(APFloat::IEEEdouble(), "0x0.ffffp-1")));
2841   EXPECT_EQ(-1023, ilogb(APFloat(APFloat::IEEEdouble(), "0x1.fffep-1023")));
2842   EXPECT_EQ(1023, ilogb(APFloat::getLargest(APFloat::IEEEdouble(), false)));
2843   EXPECT_EQ(1023, ilogb(APFloat::getLargest(APFloat::IEEEdouble(), true)));
2844
2845
2846   EXPECT_EQ(0, ilogb(APFloat(APFloat::IEEEsingle(), "0x1p+0")));
2847   EXPECT_EQ(0, ilogb(APFloat(APFloat::IEEEsingle(), "-0x1p+0")));
2848   EXPECT_EQ(42, ilogb(APFloat(APFloat::IEEEsingle(), "0x1p+42")));
2849   EXPECT_EQ(-42, ilogb(APFloat(APFloat::IEEEsingle(), "0x1p-42")));
2850
2851   EXPECT_EQ(APFloat::IEK_Inf,
2852             ilogb(APFloat::getInf(APFloat::IEEEsingle(), false)));
2853   EXPECT_EQ(APFloat::IEK_Inf,
2854             ilogb(APFloat::getInf(APFloat::IEEEsingle(), true)));
2855   EXPECT_EQ(APFloat::IEK_Zero,
2856             ilogb(APFloat::getZero(APFloat::IEEEsingle(), false)));
2857   EXPECT_EQ(APFloat::IEK_Zero,
2858             ilogb(APFloat::getZero(APFloat::IEEEsingle(), true)));
2859   EXPECT_EQ(APFloat::IEK_NaN,
2860             ilogb(APFloat::getNaN(APFloat::IEEEsingle(), false)));
2861   EXPECT_EQ(APFloat::IEK_NaN,
2862             ilogb(APFloat::getSNaN(APFloat::IEEEsingle(), false)));
2863
2864   EXPECT_EQ(127, ilogb(APFloat::getLargest(APFloat::IEEEsingle(), false)));
2865   EXPECT_EQ(127, ilogb(APFloat::getLargest(APFloat::IEEEsingle(), true)));
2866
2867   EXPECT_EQ(-149, ilogb(APFloat::getSmallest(APFloat::IEEEsingle(), false)));
2868   EXPECT_EQ(-149, ilogb(APFloat::getSmallest(APFloat::IEEEsingle(), true)));
2869   EXPECT_EQ(-126,
2870             ilogb(APFloat::getSmallestNormalized(APFloat::IEEEsingle(), false)));
2871   EXPECT_EQ(-126,
2872             ilogb(APFloat::getSmallestNormalized(APFloat::IEEEsingle(), true)));
2873 }
2874
2875 TEST(APFloatTest, scalbn) {
2876
2877   const APFloat::roundingMode RM = APFloat::rmNearestTiesToEven;
2878   EXPECT_TRUE(
2879       APFloat(APFloat::IEEEsingle(), "0x1p+0")
2880       .bitwiseIsEqual(scalbn(APFloat(APFloat::IEEEsingle(), "0x1p+0"), 0, RM)));
2881   EXPECT_TRUE(
2882       APFloat(APFloat::IEEEsingle(), "0x1p+42")
2883       .bitwiseIsEqual(scalbn(APFloat(APFloat::IEEEsingle(), "0x1p+0"), 42, RM)));
2884   EXPECT_TRUE(
2885       APFloat(APFloat::IEEEsingle(), "0x1p-42")
2886       .bitwiseIsEqual(scalbn(APFloat(APFloat::IEEEsingle(), "0x1p+0"), -42, RM)));
2887
2888   APFloat PInf = APFloat::getInf(APFloat::IEEEsingle(), false);
2889   APFloat MInf = APFloat::getInf(APFloat::IEEEsingle(), true);
2890   APFloat PZero = APFloat::getZero(APFloat::IEEEsingle(), false);
2891   APFloat MZero = APFloat::getZero(APFloat::IEEEsingle(), true);
2892   APFloat QPNaN = APFloat::getNaN(APFloat::IEEEsingle(), false);
2893   APFloat QMNaN = APFloat::getNaN(APFloat::IEEEsingle(), true);
2894   APFloat SNaN = APFloat::getSNaN(APFloat::IEEEsingle(), false);
2895
2896   EXPECT_TRUE(PInf.bitwiseIsEqual(scalbn(PInf, 0, RM)));
2897   EXPECT_TRUE(MInf.bitwiseIsEqual(scalbn(MInf, 0, RM)));
2898   EXPECT_TRUE(PZero.bitwiseIsEqual(scalbn(PZero, 0, RM)));
2899   EXPECT_TRUE(MZero.bitwiseIsEqual(scalbn(MZero, 0, RM)));
2900   EXPECT_TRUE(QPNaN.bitwiseIsEqual(scalbn(QPNaN, 0, RM)));
2901   EXPECT_TRUE(QMNaN.bitwiseIsEqual(scalbn(QMNaN, 0, RM)));
2902   EXPECT_FALSE(scalbn(SNaN, 0, RM).isSignaling());
2903
2904   APFloat ScalbnSNaN = scalbn(SNaN, 1, RM);
2905   EXPECT_TRUE(ScalbnSNaN.isNaN() && !ScalbnSNaN.isSignaling());
2906
2907   // Make sure highest bit of payload is preserved.
2908   const APInt Payload(64, (UINT64_C(1) << 50) |
2909                       (UINT64_C(1) << 49) |
2910                       (UINT64_C(1234) << 32) |
2911                       1);
2912
2913   APFloat SNaNWithPayload = APFloat::getSNaN(APFloat::IEEEdouble(), false,
2914                                              &Payload);
2915   APFloat QuietPayload = scalbn(SNaNWithPayload, 1, RM);
2916   EXPECT_TRUE(QuietPayload.isNaN() && !QuietPayload.isSignaling());
2917   EXPECT_EQ(Payload, QuietPayload.bitcastToAPInt().getLoBits(51));
2918
2919   EXPECT_TRUE(PInf.bitwiseIsEqual(
2920                 scalbn(APFloat(APFloat::IEEEsingle(), "0x1p+0"), 128, RM)));
2921   EXPECT_TRUE(MInf.bitwiseIsEqual(
2922                 scalbn(APFloat(APFloat::IEEEsingle(), "-0x1p+0"), 128, RM)));
2923   EXPECT_TRUE(PInf.bitwiseIsEqual(
2924                 scalbn(APFloat(APFloat::IEEEsingle(), "0x1p+127"), 1, RM)));
2925   EXPECT_TRUE(PZero.bitwiseIsEqual(
2926                 scalbn(APFloat(APFloat::IEEEsingle(), "0x1p-127"), -127, RM)));
2927   EXPECT_TRUE(MZero.bitwiseIsEqual(
2928                 scalbn(APFloat(APFloat::IEEEsingle(), "-0x1p-127"), -127, RM)));
2929   EXPECT_TRUE(APFloat(APFloat::IEEEsingle(), "-0x1p-149").bitwiseIsEqual(
2930                 scalbn(APFloat(APFloat::IEEEsingle(), "-0x1p-127"), -22, RM)));
2931   EXPECT_TRUE(PZero.bitwiseIsEqual(
2932                 scalbn(APFloat(APFloat::IEEEsingle(), "0x1p-126"), -24, RM)));
2933
2934
2935   APFloat SmallestF64 = APFloat::getSmallest(APFloat::IEEEdouble(), false);
2936   APFloat NegSmallestF64 = APFloat::getSmallest(APFloat::IEEEdouble(), true);
2937
2938   APFloat LargestF64 = APFloat::getLargest(APFloat::IEEEdouble(), false);
2939   APFloat NegLargestF64 = APFloat::getLargest(APFloat::IEEEdouble(), true);
2940
2941   APFloat SmallestNormalizedF64
2942     = APFloat::getSmallestNormalized(APFloat::IEEEdouble(), false);
2943   APFloat NegSmallestNormalizedF64
2944     = APFloat::getSmallestNormalized(APFloat::IEEEdouble(), true);
2945
2946   APFloat LargestDenormalF64(APFloat::IEEEdouble(), "0x1.ffffffffffffep-1023");
2947   APFloat NegLargestDenormalF64(APFloat::IEEEdouble(), "-0x1.ffffffffffffep-1023");
2948
2949
2950   EXPECT_TRUE(SmallestF64.bitwiseIsEqual(
2951                 scalbn(APFloat(APFloat::IEEEdouble(), "0x1p-1074"), 0, RM)));
2952   EXPECT_TRUE(NegSmallestF64.bitwiseIsEqual(
2953                 scalbn(APFloat(APFloat::IEEEdouble(), "-0x1p-1074"), 0, RM)));
2954
2955   EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1p+1023")
2956               .bitwiseIsEqual(scalbn(SmallestF64, 2097, RM)));
2957
2958   EXPECT_TRUE(scalbn(SmallestF64, -2097, RM).isPosZero());
2959   EXPECT_TRUE(scalbn(SmallestF64, -2098, RM).isPosZero());
2960   EXPECT_TRUE(scalbn(SmallestF64, -2099, RM).isPosZero());
2961   EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1p+1022")
2962               .bitwiseIsEqual(scalbn(SmallestF64, 2096, RM)));
2963   EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1p+1023")
2964               .bitwiseIsEqual(scalbn(SmallestF64, 2097, RM)));
2965   EXPECT_TRUE(scalbn(SmallestF64, 2098, RM).isInfinity());
2966   EXPECT_TRUE(scalbn(SmallestF64, 2099, RM).isInfinity());
2967
2968   // Test for integer overflows when adding to exponent.
2969   EXPECT_TRUE(scalbn(SmallestF64, -INT_MAX, RM).isPosZero());
2970   EXPECT_TRUE(scalbn(LargestF64, INT_MAX, RM).isInfinity());
2971
2972   EXPECT_TRUE(LargestDenormalF64
2973               .bitwiseIsEqual(scalbn(LargestDenormalF64, 0, RM)));
2974   EXPECT_TRUE(NegLargestDenormalF64
2975               .bitwiseIsEqual(scalbn(NegLargestDenormalF64, 0, RM)));
2976
2977   EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.ffffffffffffep-1022")
2978               .bitwiseIsEqual(scalbn(LargestDenormalF64, 1, RM)));
2979   EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "-0x1.ffffffffffffep-1021")
2980               .bitwiseIsEqual(scalbn(NegLargestDenormalF64, 2, RM)));
2981
2982   EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.ffffffffffffep+1")
2983               .bitwiseIsEqual(scalbn(LargestDenormalF64, 1024, RM)));
2984   EXPECT_TRUE(scalbn(LargestDenormalF64, -1023, RM).isPosZero());
2985   EXPECT_TRUE(scalbn(LargestDenormalF64, -1024, RM).isPosZero());
2986   EXPECT_TRUE(scalbn(LargestDenormalF64, -2048, RM).isPosZero());
2987   EXPECT_TRUE(scalbn(LargestDenormalF64, 2047, RM).isInfinity());
2988   EXPECT_TRUE(scalbn(LargestDenormalF64, 2098, RM).isInfinity());
2989   EXPECT_TRUE(scalbn(LargestDenormalF64, 2099, RM).isInfinity());
2990
2991   EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.ffffffffffffep-2")
2992               .bitwiseIsEqual(scalbn(LargestDenormalF64, 1021, RM)));
2993   EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.ffffffffffffep-1")
2994               .bitwiseIsEqual(scalbn(LargestDenormalF64, 1022, RM)));
2995   EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.ffffffffffffep+0")
2996               .bitwiseIsEqual(scalbn(LargestDenormalF64, 1023, RM)));
2997   EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.ffffffffffffep+1023")
2998               .bitwiseIsEqual(scalbn(LargestDenormalF64, 2046, RM)));
2999   EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1p+974")
3000               .bitwiseIsEqual(scalbn(SmallestF64, 2048, RM)));
3001
3002   APFloat RandomDenormalF64(APFloat::IEEEdouble(), "0x1.c60f120d9f87cp+51");
3003   EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.c60f120d9f87cp-972")
3004               .bitwiseIsEqual(scalbn(RandomDenormalF64, -1023, RM)));
3005   EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.c60f120d9f87cp-1")
3006               .bitwiseIsEqual(scalbn(RandomDenormalF64, -52, RM)));
3007   EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.c60f120d9f87cp-2")
3008               .bitwiseIsEqual(scalbn(RandomDenormalF64, -53, RM)));
3009   EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.c60f120d9f87cp+0")
3010               .bitwiseIsEqual(scalbn(RandomDenormalF64, -51, RM)));
3011
3012   EXPECT_TRUE(scalbn(RandomDenormalF64, -2097, RM).isPosZero());
3013   EXPECT_TRUE(scalbn(RandomDenormalF64, -2090, RM).isPosZero());
3014
3015
3016   EXPECT_TRUE(
3017     APFloat(APFloat::IEEEdouble(), "-0x1p-1073")
3018     .bitwiseIsEqual(scalbn(NegLargestF64, -2097, RM)));
3019
3020   EXPECT_TRUE(
3021     APFloat(APFloat::IEEEdouble(), "-0x1p-1024")
3022     .bitwiseIsEqual(scalbn(NegLargestF64, -2048, RM)));
3023
3024   EXPECT_TRUE(
3025     APFloat(APFloat::IEEEdouble(), "0x1p-1073")
3026     .bitwiseIsEqual(scalbn(LargestF64, -2097, RM)));
3027
3028   EXPECT_TRUE(
3029     APFloat(APFloat::IEEEdouble(), "0x1p-1074")
3030     .bitwiseIsEqual(scalbn(LargestF64, -2098, RM)));
3031   EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "-0x1p-1074")
3032               .bitwiseIsEqual(scalbn(NegLargestF64, -2098, RM)));
3033   EXPECT_TRUE(scalbn(NegLargestF64, -2099, RM).isNegZero());
3034   EXPECT_TRUE(scalbn(LargestF64, 1, RM).isInfinity());
3035
3036
3037   EXPECT_TRUE(
3038     APFloat(APFloat::IEEEdouble(), "0x1p+0")
3039     .bitwiseIsEqual(scalbn(APFloat(APFloat::IEEEdouble(), "0x1p+52"), -52, RM)));
3040
3041   EXPECT_TRUE(
3042     APFloat(APFloat::IEEEdouble(), "0x1p-103")
3043     .bitwiseIsEqual(scalbn(APFloat(APFloat::IEEEdouble(), "0x1p-51"), -52, RM)));
3044 }
3045
3046 TEST(APFloatTest, frexp) {
3047   const APFloat::roundingMode RM = APFloat::rmNearestTiesToEven;
3048
3049   APFloat PZero = APFloat::getZero(APFloat::IEEEdouble(), false);
3050   APFloat MZero = APFloat::getZero(APFloat::IEEEdouble(), true);
3051   APFloat One(1.0);
3052   APFloat MOne(-1.0);
3053   APFloat Two(2.0);
3054   APFloat MTwo(-2.0);
3055
3056   APFloat LargestDenormal(APFloat::IEEEdouble(), "0x1.ffffffffffffep-1023");
3057   APFloat NegLargestDenormal(APFloat::IEEEdouble(), "-0x1.ffffffffffffep-1023");
3058
3059   APFloat Smallest = APFloat::getSmallest(APFloat::IEEEdouble(), false);
3060   APFloat NegSmallest = APFloat::getSmallest(APFloat::IEEEdouble(), true);
3061
3062   APFloat Largest = APFloat::getLargest(APFloat::IEEEdouble(), false);
3063   APFloat NegLargest = APFloat::getLargest(APFloat::IEEEdouble(), true);
3064
3065   APFloat PInf = APFloat::getInf(APFloat::IEEEdouble(), false);
3066   APFloat MInf = APFloat::getInf(APFloat::IEEEdouble(), true);
3067
3068   APFloat QPNaN = APFloat::getNaN(APFloat::IEEEdouble(), false);
3069   APFloat QMNaN = APFloat::getNaN(APFloat::IEEEdouble(), true);
3070   APFloat SNaN = APFloat::getSNaN(APFloat::IEEEdouble(), false);
3071
3072   // Make sure highest bit of payload is preserved.
3073   const APInt Payload(64, (UINT64_C(1) << 50) |
3074                       (UINT64_C(1) << 49) |
3075                       (UINT64_C(1234) << 32) |
3076                       1);
3077
3078   APFloat SNaNWithPayload = APFloat::getSNaN(APFloat::IEEEdouble(), false,
3079                                              &Payload);
3080
3081   APFloat SmallestNormalized
3082     = APFloat::getSmallestNormalized(APFloat::IEEEdouble(), false);
3083   APFloat NegSmallestNormalized
3084     = APFloat::getSmallestNormalized(APFloat::IEEEdouble(), true);
3085
3086   int Exp;
3087   APFloat Frac(APFloat::IEEEdouble());
3088
3089
3090   Frac = frexp(PZero, Exp, RM);
3091   EXPECT_EQ(0, Exp);
3092   EXPECT_TRUE(Frac.isPosZero());
3093
3094   Frac = frexp(MZero, Exp, RM);
3095   EXPECT_EQ(0, Exp);
3096   EXPECT_TRUE(Frac.isNegZero());
3097
3098
3099   Frac = frexp(One, Exp, RM);
3100   EXPECT_EQ(1, Exp);
3101   EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1p-1").bitwiseIsEqual(Frac));
3102
3103   Frac = frexp(MOne, Exp, RM);
3104   EXPECT_EQ(1, Exp);
3105   EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "-0x1p-1").bitwiseIsEqual(Frac));
3106
3107   Frac = frexp(LargestDenormal, Exp, RM);
3108   EXPECT_EQ(-1022, Exp);
3109   EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.ffffffffffffep-1").bitwiseIsEqual(Frac));
3110
3111   Frac = frexp(NegLargestDenormal, Exp, RM);
3112   EXPECT_EQ(-1022, Exp);
3113   EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "-0x1.ffffffffffffep-1").bitwiseIsEqual(Frac));
3114
3115
3116   Frac = frexp(Smallest, Exp, RM);
3117   EXPECT_EQ(-1073, Exp);
3118   EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1p-1").bitwiseIsEqual(Frac));
3119
3120   Frac = frexp(NegSmallest, Exp, RM);
3121   EXPECT_EQ(-1073, Exp);
3122   EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "-0x1p-1").bitwiseIsEqual(Frac));
3123
3124
3125   Frac = frexp(Largest, Exp, RM);
3126   EXPECT_EQ(1024, Exp);
3127   EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.fffffffffffffp-1").bitwiseIsEqual(Frac));
3128
3129   Frac = frexp(NegLargest, Exp, RM);
3130   EXPECT_EQ(1024, Exp);
3131   EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "-0x1.fffffffffffffp-1").bitwiseIsEqual(Frac));
3132
3133
3134   Frac = frexp(PInf, Exp, RM);
3135   EXPECT_EQ(INT_MAX, Exp);
3136   EXPECT_TRUE(Frac.isInfinity() && !Frac.isNegative());
3137
3138   Frac = frexp(MInf, Exp, RM);
3139   EXPECT_EQ(INT_MAX, Exp);
3140   EXPECT_TRUE(Frac.isInfinity() && Frac.isNegative());
3141
3142   Frac = frexp(QPNaN, Exp, RM);
3143   EXPECT_EQ(INT_MIN, Exp);
3144   EXPECT_TRUE(Frac.isNaN());
3145
3146   Frac = frexp(QMNaN, Exp, RM);
3147   EXPECT_EQ(INT_MIN, Exp);
3148   EXPECT_TRUE(Frac.isNaN());
3149
3150   Frac = frexp(SNaN, Exp, RM);
3151   EXPECT_EQ(INT_MIN, Exp);
3152   EXPECT_TRUE(Frac.isNaN() && !Frac.isSignaling());
3153
3154   Frac = frexp(SNaNWithPayload, Exp, RM);
3155   EXPECT_EQ(INT_MIN, Exp);
3156   EXPECT_TRUE(Frac.isNaN() && !Frac.isSignaling());
3157   EXPECT_EQ(Payload, Frac.bitcastToAPInt().getLoBits(51));
3158
3159   Frac = frexp(APFloat(APFloat::IEEEdouble(), "0x0.ffffp-1"), Exp, RM);
3160   EXPECT_EQ(-1, Exp);
3161   EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.fffep-1").bitwiseIsEqual(Frac));
3162
3163   Frac = frexp(APFloat(APFloat::IEEEdouble(), "0x1p-51"), Exp, RM);
3164   EXPECT_EQ(-50, Exp);
3165   EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1p-1").bitwiseIsEqual(Frac));
3166
3167   Frac = frexp(APFloat(APFloat::IEEEdouble(), "0x1.c60f120d9f87cp+51"), Exp, RM);
3168   EXPECT_EQ(52, Exp);
3169   EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.c60f120d9f87cp-1").bitwiseIsEqual(Frac));
3170 }
3171
3172 TEST(APFloatTest, PPCDoubleDoubleAddSpecial) {
3173   using DataType = std::tuple<uint64_t, uint64_t, uint64_t, uint64_t,
3174                               APFloat::fltCategory, APFloat::roundingMode>;
3175   DataType Data[] = {
3176       // (1 + 0) + (-1 + 0) = fcZero
3177       std::make_tuple(0x3ff0000000000000ull, 0, 0xbff0000000000000ull, 0,
3178                       APFloat::fcZero, APFloat::rmNearestTiesToEven),
3179       // LDBL_MAX + (1.1 >> (1023 - 106) + 0)) = fcInfinity
3180       std::make_tuple(0x7fefffffffffffffull, 0x7c8ffffffffffffeull,
3181                       0x7948000000000000ull, 0ull, APFloat::fcInfinity,
3182                       APFloat::rmNearestTiesToEven),
3183       // TODO: change the 4th 0x75effffffffffffe to 0x75efffffffffffff when
3184       // PPCDoubleDoubleImpl is gone.
3185       // LDBL_MAX + (1.011111... >> (1023 - 106) + (1.1111111...0 >> (1023 -
3186       // 160))) = fcNormal
3187       std::make_tuple(0x7fefffffffffffffull, 0x7c8ffffffffffffeull,
3188                       0x7947ffffffffffffull, 0x75effffffffffffeull,
3189                       APFloat::fcNormal, APFloat::rmNearestTiesToEven),
3190       // LDBL_MAX + (1.1 >> (1023 - 106) + 0)) = fcInfinity
3191       std::make_tuple(0x7fefffffffffffffull, 0x7c8ffffffffffffeull,
3192                       0x7fefffffffffffffull, 0x7c8ffffffffffffeull,
3193                       APFloat::fcInfinity, APFloat::rmNearestTiesToEven),
3194       // NaN + (1 + 0) = fcNaN
3195       std::make_tuple(0x7ff8000000000000ull, 0, 0x3ff0000000000000ull, 0,
3196                       APFloat::fcNaN, APFloat::rmNearestTiesToEven),
3197   };
3198
3199   for (auto Tp : Data) {
3200     uint64_t Op1[2], Op2[2];
3201     APFloat::fltCategory Expected;
3202     APFloat::roundingMode RM;
3203     std::tie(Op1[0], Op1[1], Op2[0], Op2[1], Expected, RM) = Tp;
3204
3205     APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1));
3206     APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2));
3207     A1.add(A2, RM);
3208
3209     EXPECT_EQ(Expected, A1.getCategory())
3210         << formatv("({0:x} + {1:x}) + ({2:x} + {3:x})", Op1[0], Op1[1], Op2[0],
3211                    Op2[1])
3212                .str();
3213   }
3214 }
3215
3216 TEST(APFloatTest, PPCDoubleDoubleAdd) {
3217   using DataType = std::tuple<uint64_t, uint64_t, uint64_t, uint64_t, uint64_t,
3218                               uint64_t, APFloat::roundingMode>;
3219   DataType Data[] = {
3220       // (1 + 0) + (1e-105 + 0) = (1 + 1e-105)
3221       std::make_tuple(0x3ff0000000000000ull, 0, 0x3960000000000000ull, 0,
3222                       0x3ff0000000000000ull, 0x3960000000000000ull,
3223                       APFloat::rmNearestTiesToEven),
3224       // (1 + 0) + (1e-106 + 0) = (1 + 1e-106)
3225       std::make_tuple(0x3ff0000000000000ull, 0, 0x3950000000000000ull, 0,
3226                       0x3ff0000000000000ull, 0x3950000000000000ull,
3227                       APFloat::rmNearestTiesToEven),
3228       // (1 + 1e-106) + (1e-106 + 0) = (1 + 1e-105)
3229       std::make_tuple(0x3ff0000000000000ull, 0x3950000000000000ull,
3230                       0x3950000000000000ull, 0, 0x3ff0000000000000ull,
3231                       0x3960000000000000ull, APFloat::rmNearestTiesToEven),
3232       // (1 + 0) + (epsilon + 0) = (1 + epsilon)
3233       std::make_tuple(0x3ff0000000000000ull, 0, 0x0000000000000001ull, 0,
3234                       0x3ff0000000000000ull, 0x0000000000000001ull,
3235                       APFloat::rmNearestTiesToEven),
3236       // TODO: change 0xf950000000000000 to 0xf940000000000000, when
3237       // PPCDoubleDoubleImpl is gone.
3238       // (DBL_MAX - 1 << (1023 - 105)) + (1 << (1023 - 53) + 0) = DBL_MAX +
3239       // 1.11111... << (1023 - 52)
3240       std::make_tuple(0x7fefffffffffffffull, 0xf950000000000000ull,
3241                       0x7c90000000000000ull, 0, 0x7fefffffffffffffull,
3242                       0x7c8ffffffffffffeull, APFloat::rmNearestTiesToEven),
3243       // TODO: change 0xf950000000000000 to 0xf940000000000000, when
3244       // PPCDoubleDoubleImpl is gone.
3245       // (1 << (1023 - 53) + 0) + (DBL_MAX - 1 << (1023 - 105)) = DBL_MAX +
3246       // 1.11111... << (1023 - 52)
3247       std::make_tuple(0x7c90000000000000ull, 0, 0x7fefffffffffffffull,
3248                       0xf950000000000000ull, 0x7fefffffffffffffull,
3249                       0x7c8ffffffffffffeull, APFloat::rmNearestTiesToEven),
3250   };
3251
3252   for (auto Tp : Data) {
3253     uint64_t Op1[2], Op2[2], Expected[2];
3254     APFloat::roundingMode RM;
3255     std::tie(Op1[0], Op1[1], Op2[0], Op2[1], Expected[0], Expected[1], RM) = Tp;
3256
3257     APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1));
3258     APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2));
3259     A1.add(A2, RM);
3260
3261     EXPECT_EQ(Expected[0], A1.bitcastToAPInt().getRawData()[0])
3262         << formatv("({0:x} + {1:x}) + ({2:x} + {3:x})", Op1[0], Op1[1], Op2[0],
3263                    Op2[1])
3264                .str();
3265     EXPECT_EQ(Expected[1], A1.getSecondFloat().bitcastToAPInt().getRawData()[0])
3266         << formatv("({0:x} + {1:x}) + ({2:x} + {3:x})", Op1[0], Op1[1], Op2[0],
3267                    Op2[1])
3268                .str();
3269   }
3270 }
3271
3272 TEST(APFloatTest, PPCDoubleDoubleSubtract) {
3273   using DataType = std::tuple<uint64_t, uint64_t, uint64_t, uint64_t, uint64_t,
3274                               uint64_t, APFloat::roundingMode>;
3275   DataType Data[] = {
3276       // (1 + 0) - (-1e-105 + 0) = (1 + 1e-105)
3277       std::make_tuple(0x3ff0000000000000ull, 0, 0xb960000000000000ull, 0,
3278                       0x3ff0000000000000ull, 0x3960000000000000ull,
3279                       APFloat::rmNearestTiesToEven),
3280       // (1 + 0) - (-1e-106 + 0) = (1 + 1e-106)
3281       std::make_tuple(0x3ff0000000000000ull, 0, 0xb950000000000000ull, 0,
3282                       0x3ff0000000000000ull, 0x3950000000000000ull,
3283                       APFloat::rmNearestTiesToEven),
3284   };
3285
3286   for (auto Tp : Data) {
3287     uint64_t Op1[2], Op2[2], Expected[2];
3288     APFloat::roundingMode RM;
3289     std::tie(Op1[0], Op1[1], Op2[0], Op2[1], Expected[0], Expected[1], RM) = Tp;
3290
3291     APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1));
3292     APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2));
3293     A1.subtract(A2, RM);
3294
3295     EXPECT_EQ(Expected[0], A1.bitcastToAPInt().getRawData()[0])
3296         << formatv("({0:x} + {1:x}) - ({2:x} + {3:x})", Op1[0], Op1[1], Op2[0],
3297                    Op2[1])
3298                .str();
3299     EXPECT_EQ(Expected[1], A1.getSecondFloat().bitcastToAPInt().getRawData()[0])
3300         << formatv("({0:x} + {1:x}) - ({2:x} + {3:x})", Op1[0], Op1[1], Op2[0],
3301                    Op2[1])
3302                .str();
3303   }
3304 }
3305
3306 TEST(APFloatTest, PPCDoubleDoubleMultiply) {
3307   using DataType = std::tuple<uint64_t, uint64_t, uint64_t, uint64_t, uint64_t,
3308                               uint64_t, APFloat::roundingMode>;
3309   // TODO: Only a sanity check for now. Add more edge cases when the
3310   // double-double algorithm is implemented.
3311   DataType Data[] = {
3312       // 1/3 * 3 = 1.0
3313       std::make_tuple(0x3fd5555555555555ull, 0x3c75555555555556ull,
3314                       0x4008000000000000ull, 0, 0x3ff0000000000000ull, 0,
3315                       APFloat::rmNearestTiesToEven),
3316   };
3317
3318   for (auto Tp : Data) {
3319     uint64_t Op1[2], Op2[2], Expected[2];
3320     APFloat::roundingMode RM;
3321     std::tie(Op1[0], Op1[1], Op2[0], Op2[1], Expected[0], Expected[1], RM) = Tp;
3322
3323     APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1));
3324     APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2));
3325     A1.multiply(A2, RM);
3326
3327     EXPECT_EQ(Expected[0], A1.bitcastToAPInt().getRawData()[0])
3328         << formatv("({0:x} + {1:x}) * ({2:x} + {3:x})", Op1[0], Op1[1], Op2[0],
3329                    Op2[1])
3330                .str();
3331     EXPECT_EQ(Expected[1], A1.bitcastToAPInt().getRawData()[1])
3332         << formatv("({0:x} + {1:x}) * ({2:x} + {3:x})", Op1[0], Op1[1], Op2[0],
3333                    Op2[1])
3334                .str();
3335   }
3336 }
3337
3338 TEST(APFloatTest, PPCDoubleDoubleDivide) {
3339   using DataType = std::tuple<uint64_t, uint64_t, uint64_t, uint64_t, uint64_t,
3340                               uint64_t, APFloat::roundingMode>;
3341   // TODO: Only a sanity check for now. Add more edge cases when the
3342   // double-double algorithm is implemented.
3343   DataType Data[] = {
3344       // 1 / 3 = 1/3
3345       std::make_tuple(0x3ff0000000000000ull, 0, 0x4008000000000000ull, 0,
3346                       0x3fd5555555555555ull, 0x3c75555555555556ull,
3347                       APFloat::rmNearestTiesToEven),
3348   };
3349
3350   for (auto Tp : Data) {
3351     uint64_t Op1[2], Op2[2], Expected[2];
3352     APFloat::roundingMode RM;
3353     std::tie(Op1[0], Op1[1], Op2[0], Op2[1], Expected[0], Expected[1], RM) = Tp;
3354
3355     APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1));
3356     APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2));
3357     A1.divide(A2, RM);
3358
3359     EXPECT_EQ(Expected[0], A1.bitcastToAPInt().getRawData()[0])
3360         << formatv("({0:x} + {1:x}) / ({2:x} + {3:x})", Op1[0], Op1[1], Op2[0],
3361                    Op2[1])
3362                .str();
3363     EXPECT_EQ(Expected[1], A1.bitcastToAPInt().getRawData()[1])
3364         << formatv("({0:x} + {1:x}) / ({2:x} + {3:x})", Op1[0], Op1[1], Op2[0],
3365                    Op2[1])
3366                .str();
3367   }
3368 }
3369
3370 TEST(APFloatTest, PPCDoubleDoubleRemainder) {
3371   using DataType =
3372       std::tuple<uint64_t, uint64_t, uint64_t, uint64_t, uint64_t, uint64_t>;
3373   DataType Data[] = {
3374       // remainder(3.0 + 3.0 << 53, 1.25 + 1.25 << 53) = (0.5 + 0.5 << 53)
3375       std::make_tuple(0x4008000000000000ull, 0x3cb8000000000000ull,
3376                       0x3ff4000000000000ull, 0x3ca4000000000000ull,
3377                       0x3fe0000000000000ull, 0x3c90000000000000ull),
3378       // remainder(3.0 + 3.0 << 53, 1.75 + 1.75 << 53) = (-0.5 - 0.5 << 53)
3379       std::make_tuple(0x4008000000000000ull, 0x3cb8000000000000ull,
3380                       0x3ffc000000000000ull, 0x3cac000000000000ull,
3381                       0xbfe0000000000000ull, 0xbc90000000000000ull),
3382   };
3383
3384   for (auto Tp : Data) {
3385     uint64_t Op1[2], Op2[2], Expected[2];
3386     std::tie(Op1[0], Op1[1], Op2[0], Op2[1], Expected[0], Expected[1]) = Tp;
3387
3388     APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1));
3389     APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2));
3390     A1.remainder(A2);
3391
3392     EXPECT_EQ(Expected[0], A1.bitcastToAPInt().getRawData()[0])
3393         << formatv("remainder({0:x} + {1:x}), ({2:x} + {3:x}))", Op1[0], Op1[1],
3394                    Op2[0], Op2[1])
3395                .str();
3396     EXPECT_EQ(Expected[1], A1.bitcastToAPInt().getRawData()[1])
3397         << formatv("remainder(({0:x} + {1:x}), ({2:x} + {3:x}))", Op1[0],
3398                    Op1[1], Op2[0], Op2[1])
3399                .str();
3400   }
3401 }
3402
3403 TEST(APFloatTest, PPCDoubleDoubleMod) {
3404   using DataType =
3405       std::tuple<uint64_t, uint64_t, uint64_t, uint64_t, uint64_t, uint64_t>;
3406   DataType Data[] = {
3407       // mod(3.0 + 3.0 << 53, 1.25 + 1.25 << 53) = (0.5 + 0.5 << 53)
3408       std::make_tuple(0x4008000000000000ull, 0x3cb8000000000000ull,
3409                       0x3ff4000000000000ull, 0x3ca4000000000000ull,
3410                       0x3fe0000000000000ull, 0x3c90000000000000ull),
3411       // mod(3.0 + 3.0 << 53, 1.75 + 1.75 << 53) = (1.25 + 1.25 << 53)
3412       // 0xbc98000000000000 doesn't seem right, but it's what we currently have.
3413       // TODO: investigate
3414       std::make_tuple(0x4008000000000000ull, 0x3cb8000000000000ull,
3415                       0x3ffc000000000000ull, 0x3cac000000000000ull,
3416                       0x3ff4000000000001ull, 0xbc98000000000000ull),
3417   };
3418
3419   for (auto Tp : Data) {
3420     uint64_t Op1[2], Op2[2], Expected[2];
3421     std::tie(Op1[0], Op1[1], Op2[0], Op2[1], Expected[0], Expected[1]) = Tp;
3422
3423     APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1));
3424     APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2));
3425     A1.mod(A2);
3426
3427     EXPECT_EQ(Expected[0], A1.bitcastToAPInt().getRawData()[0])
3428         << formatv("fmod(({0:x} + {1:x}),  ({2:x} + {3:x}))", Op1[0], Op1[1],
3429                    Op2[0], Op2[1])
3430                .str();
3431     EXPECT_EQ(Expected[1], A1.bitcastToAPInt().getRawData()[1])
3432         << formatv("fmod(({0:x} + {1:x}), ({2:x} + {3:x}))", Op1[0], Op1[1],
3433                    Op2[0], Op2[1])
3434                .str();
3435   }
3436 }
3437
3438 TEST(APFloatTest, PPCDoubleDoubleFMA) {
3439   // Sanity check for now.
3440   APFloat A(APFloat::PPCDoubleDouble(), "2");
3441   A.fusedMultiplyAdd(APFloat(APFloat::PPCDoubleDouble(), "3"),
3442                      APFloat(APFloat::PPCDoubleDouble(), "4"),
3443                      APFloat::rmNearestTiesToEven);
3444   EXPECT_EQ(APFloat::cmpEqual,
3445             APFloat(APFloat::PPCDoubleDouble(), "10").compare(A));
3446 }
3447
3448 TEST(APFloatTest, PPCDoubleDoubleRoundToIntegral) {
3449   {
3450     APFloat A(APFloat::PPCDoubleDouble(), "1.5");
3451     A.roundToIntegral(APFloat::rmNearestTiesToEven);
3452     EXPECT_EQ(APFloat::cmpEqual,
3453               APFloat(APFloat::PPCDoubleDouble(), "2").compare(A));
3454   }
3455   {
3456     APFloat A(APFloat::PPCDoubleDouble(), "2.5");
3457     A.roundToIntegral(APFloat::rmNearestTiesToEven);
3458     EXPECT_EQ(APFloat::cmpEqual,
3459               APFloat(APFloat::PPCDoubleDouble(), "2").compare(A));
3460   }
3461 }
3462
3463 TEST(APFloatTest, PPCDoubleDoubleCompare) {
3464   using DataType =
3465       std::tuple<uint64_t, uint64_t, uint64_t, uint64_t, APFloat::cmpResult>;
3466
3467   DataType Data[] = {
3468       // (1 + 0) = (1 + 0)
3469       std::make_tuple(0x3ff0000000000000ull, 0, 0x3ff0000000000000ull, 0,
3470                       APFloat::cmpEqual),
3471       // (1 + 0) < (1.00...1 + 0)
3472       std::make_tuple(0x3ff0000000000000ull, 0, 0x3ff0000000000001ull, 0,
3473                       APFloat::cmpLessThan),
3474       // (1.00...1 + 0) > (1 + 0)
3475       std::make_tuple(0x3ff0000000000001ull, 0, 0x3ff0000000000000ull, 0,
3476                       APFloat::cmpGreaterThan),
3477       // (1 + 0) < (1 + epsilon)
3478       std::make_tuple(0x3ff0000000000000ull, 0, 0x3ff0000000000001ull,
3479                       0x0000000000000001ull, APFloat::cmpLessThan),
3480       // NaN != NaN
3481       std::make_tuple(0x7ff8000000000000ull, 0, 0x7ff8000000000000ull, 0,
3482                       APFloat::cmpUnordered),
3483       // (1 + 0) != NaN
3484       std::make_tuple(0x3ff0000000000000ull, 0, 0x7ff8000000000000ull, 0,
3485                       APFloat::cmpUnordered),
3486       // Inf = Inf
3487       std::make_tuple(0x7ff0000000000000ull, 0, 0x7ff0000000000000ull, 0,
3488                       APFloat::cmpEqual),
3489   };
3490
3491   for (auto Tp : Data) {
3492     uint64_t Op1[2], Op2[2];
3493     APFloat::cmpResult Expected;
3494     std::tie(Op1[0], Op1[1], Op2[0], Op2[1], Expected) = Tp;
3495
3496     APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1));
3497     APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2));
3498     EXPECT_EQ(Expected, A1.compare(A2))
3499         << formatv("({0:x} + {1:x}) - ({2:x} + {3:x})", Op1[0], Op1[1], Op2[0],
3500                    Op2[1])
3501                .str();
3502   }
3503 }
3504
3505 TEST(APFloatTest, PPCDoubleDoubleChangeSign) {
3506   uint64_t Data[] = {
3507       0x400f000000000000ull, 0xbcb0000000000000ull,
3508   };
3509   APFloat Float(APFloat::PPCDoubleDouble(), APInt(128, 2, Data));
3510   {
3511     APFloat Actual =
3512         APFloat::copySign(Float, APFloat(APFloat::IEEEdouble(), "1"));
3513     EXPECT_EQ(0x400f000000000000ull, Actual.bitcastToAPInt().getRawData()[0]);
3514     EXPECT_EQ(0xbcb0000000000000ull, Actual.bitcastToAPInt().getRawData()[1]);
3515   }
3516   {
3517     APFloat Actual =
3518         APFloat::copySign(Float, APFloat(APFloat::IEEEdouble(), "-1"));
3519     EXPECT_EQ(0xc00f000000000000ull, Actual.bitcastToAPInt().getRawData()[0]);
3520     EXPECT_EQ(0x3cb0000000000000ull, Actual.bitcastToAPInt().getRawData()[1]);
3521   }
3522 }
3523
3524 TEST(APFloatTest, PPCDoubleDoubleFactories) {
3525   {
3526     uint64_t Data[] = {
3527         0, 0,
3528     };
3529     EXPECT_EQ(APInt(128, 2, Data),
3530               APFloat::getZero(APFloat::PPCDoubleDouble()).bitcastToAPInt());
3531   }
3532   {
3533     uint64_t Data[] = {
3534         0x0000000000000001ull, 0,
3535     };
3536     EXPECT_EQ(
3537         APInt(128, 2, Data),
3538         APFloat::getSmallest(APFloat::PPCDoubleDouble()).bitcastToAPInt());
3539   }
3540   {
3541     uint64_t Data[] = {0x0360000000000000ull, 0};
3542     EXPECT_EQ(APInt(128, 2, Data),
3543               APFloat::getSmallestNormalized(APFloat::PPCDoubleDouble())
3544                   .bitcastToAPInt());
3545   }
3546   {
3547     uint64_t Data[] = {
3548         0x8000000000000000ull, 0x0000000000000000ull,
3549     };
3550     EXPECT_EQ(
3551         APInt(128, 2, Data),
3552         APFloat::getZero(APFloat::PPCDoubleDouble(), true).bitcastToAPInt());
3553   }
3554   {
3555     uint64_t Data[] = {
3556         0x8000000000000001ull, 0x0000000000000000ull,
3557     };
3558     EXPECT_EQ(APInt(128, 2, Data),
3559               APFloat::getSmallest(APFloat::PPCDoubleDouble(), true)
3560                   .bitcastToAPInt());
3561   }
3562
3563   EXPECT_EQ(0x8360000000000000ull,
3564             APFloat::getSmallestNormalized(APFloat::PPCDoubleDouble(), true)
3565                 .bitcastToAPInt()
3566                 .getRawData()[0]);
3567   EXPECT_EQ(0x0000000000000000ull,
3568             APFloat::getSmallestNormalized(APFloat::PPCDoubleDouble(), true)
3569                 .getSecondFloat()
3570                 .bitcastToAPInt()
3571                 .getRawData()[0]);
3572
3573   EXPECT_TRUE(APFloat::getSmallest(APFloat::PPCDoubleDouble()).isSmallest());
3574   EXPECT_TRUE(APFloat::getLargest(APFloat::PPCDoubleDouble()).isLargest());
3575 }
3576 }