llvm/unittests/ADT/APFixedPointTest.cpp

   1 //===- unittests/ADT/FixedPointTest.cpp -- fixed point number tests -----===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #include "llvm/ADT/APFixedPoint.h"
  10 #include "llvm/ADT/APFloat.h"
  11 #include "llvm/ADT/APSInt.h"
  12 #include "gtest/gtest.h"
  13
  14 using llvm::APFixedPoint;
  15 using llvm::APFloat;
  16 using llvm::APInt;
  17 using llvm::APSInt;
  18 using llvm::FixedPointSemantics;
  19
  20 namespace {
  21
  22 FixedPointSemantics Saturated(FixedPointSemantics Sema) {
  23   Sema.setSaturated(true);
  24   return Sema;
  25 }
  26
  27 FixedPointSemantics getSAccumSema() {
  28   return FixedPointSemantics(/*width=*/16, /*scale=*/7, /*isSigned=*/true,
  29                              /*isSaturated=*/false,
  30                              /*hasUnsignedPadding=*/false);
  31 }
  32
  33 FixedPointSemantics getAccumSema() {
  34   return FixedPointSemantics(/*width=*/32, /*scale=*/15, /*isSigned=*/true,
  35                              /*isSaturated=*/false,
  36                              /*hasUnsignedPadding=*/false);
  37 }
  38
  39 FixedPointSemantics getLAccumSema() {
  40   return FixedPointSemantics(/*width=*/64, /*scale=*/31, /*isSigned=*/true,
  41                              /*isSaturated=*/false,
  42                              /*hasUnsignedPadding=*/false);
  43 }
  44
  45 FixedPointSemantics getSFractSema() {
  46   return FixedPointSemantics(/*width=*/8, /*scale=*/7, /*isSigned=*/true,
  47                              /*isSaturated=*/false,
  48                              /*hasUnsignedPadding=*/false);
  49 }
  50
  51 FixedPointSemantics getFractSema() {
  52   return FixedPointSemantics(/*width=*/16, /*scale=*/15, /*isSigned=*/true,
  53                              /*isSaturated=*/false,
  54                              /*hasUnsignedPadding=*/false);
  55 }
  56
  57 FixedPointSemantics getLFractSema() {
  58   return FixedPointSemantics(/*width=*/32, /*scale=*/31, /*isSigned=*/true,
  59                              /*isSaturated=*/false,
  60                              /*hasUnsignedPadding=*/false);
  61 }
  62
  63 FixedPointSemantics getUSAccumSema() {
  64   return FixedPointSemantics(/*width=*/16, /*scale=*/8, /*isSigned=*/false,
  65                              /*isSaturated=*/false,
  66                              /*hasUnsignedPadding=*/false);
  67 }
  68
  69 FixedPointSemantics getUAccumSema() {
  70   return FixedPointSemantics(/*width=*/32, /*scale=*/16, /*isSigned=*/false,
  71                              /*isSaturated=*/false,
  72                              /*hasUnsignedPadding=*/false);
  73 }
  74
  75 FixedPointSemantics getULAccumSema() {
  76   return FixedPointSemantics(/*width=*/64, /*scale=*/32, /*isSigned=*/false,
  77                              /*isSaturated=*/false,
  78                              /*hasUnsignedPadding=*/false);
  79 }
  80
  81 FixedPointSemantics getUSFractSema() {
  82   return FixedPointSemantics(/*width=*/8, /*scale=*/8, /*isSigned=*/false,
  83                              /*isSaturated=*/false,
  84                              /*hasUnsignedPadding=*/false);
  85 }
  86
  87 FixedPointSemantics getUFractSema() {
  88   return FixedPointSemantics(/*width=*/16, /*scale=*/16, /*isSigned=*/false,
  89                              /*isSaturated=*/false,
  90                              /*hasUnsignedPadding=*/false);
  91 }
  92
  93 FixedPointSemantics getULFractSema() {
  94   return FixedPointSemantics(/*width=*/32, /*scale=*/32, /*isSigned=*/false,
  95                              /*isSaturated=*/false,
  96                              /*hasUnsignedPadding=*/false);
  97 }
  98
  99 FixedPointSemantics getPadUSAccumSema() {
 100   return FixedPointSemantics(/*width=*/16, /*scale=*/7, /*isSigned=*/false,
 101                              /*isSaturated=*/false,
 102                              /*hasUnsignedPadding=*/true);
 103 }
 104
 105 FixedPointSemantics getPadUAccumSema() {
 106   return FixedPointSemantics(/*width=*/32, /*scale=*/15, /*isSigned=*/false,
 107                              /*isSaturated=*/false,
 108                              /*hasUnsignedPadding=*/true);
 109 }
 110
 111 FixedPointSemantics getPadULAccumSema() {
 112   return FixedPointSemantics(/*width=*/64, /*scale=*/31, /*isSigned=*/false,
 113                              /*isSaturated=*/false,
 114                              /*hasUnsignedPadding=*/true);
 115 }
 116
 117 FixedPointSemantics getPadUSFractSema() {
 118   return FixedPointSemantics(/*width=*/8, /*scale=*/7, /*isSigned=*/false,
 119                              /*isSaturated=*/false,
 120                              /*hasUnsignedPadding=*/true);
 121 }
 122
 123 FixedPointSemantics getPadUFractSema() {
 124   return FixedPointSemantics(/*width=*/16, /*scale=*/15, /*isSigned=*/false,
 125                              /*isSaturated=*/false,
 126                              /*hasUnsignedPadding=*/true);
 127 }
 128
 129 FixedPointSemantics getPadULFractSema() {
 130   return FixedPointSemantics(/*width=*/32, /*scale=*/31, /*isSigned=*/false,
 131                              /*isSaturated=*/false,
 132                              /*hasUnsignedPadding=*/true);
 133 }
 134
 135 FixedPointSemantics getU8Neg10() {
 136   return FixedPointSemantics(/*width=*/8, /*lsb=*/FixedPointSemantics::Lsb{-10},
 137                              /*isSigned=*/false,
 138                              /*isSaturated=*/false,
 139                              /*hasUnsignedPadding=*/false);
 140 }
 141
 142 FixedPointSemantics getS16Neg18() {
 143   return FixedPointSemantics(/*width=*/16,
 144                              /*lsb=*/FixedPointSemantics::Lsb{-18},
 145                              /*isSigned=*/true,
 146                              /*isSaturated=*/false,
 147                              /*hasUnsignedPadding=*/false);
 148 }
 149
 150 FixedPointSemantics getU8Pos4() {
 151   return FixedPointSemantics(/*width=*/8, /*lsb=*/FixedPointSemantics::Lsb{4},
 152                              /*isSigned=*/false,
 153                              /*isSaturated=*/false,
 154                              /*hasUnsignedPadding=*/false);
 155 }
 156
 157 FixedPointSemantics getS32Pos2() {
 158   return FixedPointSemantics(/*width=*/32, /*lsb=*/FixedPointSemantics::Lsb{2},
 159                              /*isSigned=*/true,
 160                              /*isSaturated=*/false,
 161                              /*hasUnsignedPadding=*/false);
 162 }
 163
 164 void CheckUnpaddedMax(const FixedPointSemantics &Sema) {
 165   ASSERT_EQ(APFixedPoint::getMax(Sema).getValue(),
 166             APSInt::getMaxValue(Sema.getWidth(), !Sema.isSigned()));
 167 }
 168
 169 void CheckPaddedMax(const FixedPointSemantics &Sema) {
 170   ASSERT_EQ(APFixedPoint::getMax(Sema).getValue(),
 171             APSInt::getMaxValue(Sema.getWidth(), !Sema.isSigned()) >> 1);
 172 }
 173
 174 void CheckMin(const FixedPointSemantics &Sema) {
 175   ASSERT_EQ(APFixedPoint::getMin(Sema).getValue(),
 176             APSInt::getMinValue(Sema.getWidth(), !Sema.isSigned()));
 177 }
 178
 179 TEST(FixedPointTest, getMax) {
 180   CheckUnpaddedMax(getSAccumSema());
 181   CheckUnpaddedMax(getAccumSema());
 182   CheckUnpaddedMax(getLAccumSema());
 183   CheckUnpaddedMax(getUSAccumSema());
 184   CheckUnpaddedMax(getUAccumSema());
 185   CheckUnpaddedMax(getULAccumSema());
 186   CheckUnpaddedMax(getSFractSema());
 187   CheckUnpaddedMax(getFractSema());
 188   CheckUnpaddedMax(getLFractSema());
 189   CheckUnpaddedMax(getUSFractSema());
 190   CheckUnpaddedMax(getUFractSema());
 191   CheckUnpaddedMax(getULFractSema());
 192   CheckUnpaddedMax(getU8Neg10());
 193   CheckUnpaddedMax(getS16Neg18());
 194   CheckUnpaddedMax(getU8Pos4());
 195   CheckUnpaddedMax(getS32Pos2());
 196
 197   CheckPaddedMax(getPadUSAccumSema());
 198   CheckPaddedMax(getPadUAccumSema());
 199   CheckPaddedMax(getPadULAccumSema());
 200   CheckPaddedMax(getPadUSFractSema());
 201   CheckPaddedMax(getPadUFractSema());
 202   CheckPaddedMax(getPadULFractSema());
 203 }
 204
 205 TEST(FixedPointTest, getMin) {
 206   CheckMin(getSAccumSema());
 207   CheckMin(getAccumSema());
 208   CheckMin(getLAccumSema());
 209   CheckMin(getUSAccumSema());
 210   CheckMin(getUAccumSema());
 211   CheckMin(getULAccumSema());
 212   CheckMin(getSFractSema());
 213   CheckMin(getFractSema());
 214   CheckMin(getLFractSema());
 215   CheckMin(getUSFractSema());
 216   CheckMin(getUFractSema());
 217   CheckMin(getULFractSema());
 218   CheckMin(getU8Neg10());
 219   CheckMin(getS16Neg18());
 220   CheckMin(getU8Pos4());
 221   CheckMin(getS32Pos2());
 222
 223   CheckMin(getPadUSAccumSema());
 224   CheckMin(getPadUAccumSema());
 225   CheckMin(getPadULAccumSema());
 226   CheckMin(getPadUSFractSema());
 227   CheckMin(getPadUFractSema());
 228   CheckMin(getPadULFractSema());
 229 }
 230
 231 int64_t relativeShr(int64_t Int, int64_t Shift) {
 232   return (Shift > 0) ? Int >> Shift : Int << -Shift;
 233 }
 234
 235 void CheckIntPart(const FixedPointSemantics &Sema, int64_t IntPart) {
 236   int64_t FullFactPart =
 237       (Sema.getLsbWeight() > 0) ? 0 : (1ULL << (-Sema.getLsbWeight() - 1));
 238
 239   // Value with a fraction
 240   APFixedPoint ValWithFract(
 241       APInt(Sema.getWidth(),
 242             relativeShr(IntPart, Sema.getLsbWeight()) + FullFactPart,
 243             Sema.isSigned()),
 244       Sema);
 245   ASSERT_EQ(ValWithFract.getIntPart(), IntPart);
 246
 247   // Just fraction
 248   APFixedPoint JustFract(APInt(Sema.getWidth(), FullFactPart, Sema.isSigned()),
 249                          Sema);
 250   ASSERT_EQ(JustFract.getIntPart(), 0);
 251
 252   // Whole number
 253   APFixedPoint WholeNum(APInt(Sema.getWidth(),
 254                               relativeShr(IntPart, Sema.getLsbWeight()),
 255                               Sema.isSigned()),
 256                         Sema);
 257   ASSERT_EQ(WholeNum.getIntPart(), IntPart);
 258
 259   // Negative
 260   if (Sema.isSigned()) {
 261     APFixedPoint Negative(APInt(Sema.getWidth(),
 262                                 relativeShr(IntPart, Sema.getLsbWeight()),
 263                                 Sema.isSigned()),
 264                           Sema);
 265     ASSERT_EQ(Negative.getIntPart(), IntPart);
 266   }
 267 }
 268
 269 void CheckIntPartMin(const FixedPointSemantics &Sema, int64_t Expected) {
 270   EXPECT_TRUE(APSInt::compareValues(APFixedPoint::getMin(Sema).getIntPart(),
 271                                     APSInt::get(Expected)) == 0);
 272 }
 273
 274 void CheckIntPartMax(const FixedPointSemantics &Sema, uint64_t Expected) {
 275   EXPECT_TRUE(APSInt::compareValues(APFixedPoint::getMax(Sema).getIntPart(),
 276                                     APSInt::getUnsigned(Expected)) == 0);
 277 }
 278
 279 void CheckIntPartRes(const FixedPointSemantics &Sema, int64_t Representation,
 280                      uint64_t Result) {
 281   APFixedPoint Val(Representation, Sema);
 282   ASSERT_EQ(Val.getIntPart().getZExtValue(), Result) ;
 283 }
 284
 285 TEST(FixedPoint, getIntPart) {
 286   // Normal values
 287   CheckIntPart(getSAccumSema(), 2);
 288   CheckIntPart(getAccumSema(), 2);
 289   CheckIntPart(getLAccumSema(), 2);
 290   CheckIntPart(getUSAccumSema(), 2);
 291   CheckIntPart(getUAccumSema(), 2);
 292   CheckIntPart(getULAccumSema(), 2);
 293   CheckIntPart(getU8Pos4(), 32);
 294   CheckIntPart(getS32Pos2(), 32);
 295
 296   // Zero
 297   CheckIntPart(getSAccumSema(), 0);
 298   CheckIntPart(getAccumSema(), 0);
 299   CheckIntPart(getLAccumSema(), 0);
 300   CheckIntPart(getUSAccumSema(), 0);
 301   CheckIntPart(getUAccumSema(), 0);
 302   CheckIntPart(getULAccumSema(), 0);
 303
 304   CheckIntPart(getSFractSema(), 0);
 305   CheckIntPart(getFractSema(), 0);
 306   CheckIntPart(getLFractSema(), 0);
 307   CheckIntPart(getUSFractSema(), 0);
 308   CheckIntPart(getUFractSema(), 0);
 309   CheckIntPart(getULFractSema(), 0);
 310
 311   CheckIntPart(getS16Neg18(), 0);
 312   CheckIntPart(getU8Neg10(), 0);
 313   CheckIntPart(getU8Pos4(), 0);
 314   CheckIntPart(getS32Pos2(), 0);
 315
 316   // Min
 317   CheckIntPartMin(getSAccumSema(), -256);
 318   CheckIntPartMin(getAccumSema(), -65536);
 319   CheckIntPartMin(getLAccumSema(), -4294967296);
 320
 321   CheckIntPartMin(getSFractSema(), -1);
 322   CheckIntPartMin(getFractSema(), -1);
 323   CheckIntPartMin(getLFractSema(), -1);
 324
 325   CheckIntPartMin(getS32Pos2(), -8589934592);
 326
 327   // Max
 328   CheckIntPartMax(getSAccumSema(), 255);
 329   CheckIntPartMax(getAccumSema(), 65535);
 330   CheckIntPartMax(getLAccumSema(), 4294967295);
 331   CheckIntPartMax(getUSAccumSema(), 255);
 332   CheckIntPartMax(getUAccumSema(), 65535);
 333   CheckIntPartMax(getULAccumSema(), 4294967295);
 334
 335   CheckIntPartMax(getU8Pos4(), 255 << 4);
 336   CheckIntPartMax(getS32Pos2(), 2147483647ull << 2);
 337
 338   CheckIntPartMax(getSFractSema(), 0);
 339   CheckIntPartMax(getFractSema(), 0);
 340   CheckIntPartMax(getLFractSema(), 0);
 341   CheckIntPartMax(getUSFractSema(), 0);
 342   CheckIntPartMax(getUFractSema(), 0);
 343   CheckIntPartMax(getULFractSema(), 0);
 344
 345   // Padded
 346   // Normal Values
 347   CheckIntPart(getPadUSAccumSema(), 2);
 348   CheckIntPart(getPadUAccumSema(), 2);
 349   CheckIntPart(getPadULAccumSema(), 2);
 350
 351   // Zero
 352   CheckIntPart(getPadUSAccumSema(), 0);
 353   CheckIntPart(getPadUAccumSema(), 0);
 354   CheckIntPart(getPadULAccumSema(), 0);
 355
 356   CheckIntPart(getPadUSFractSema(), 0);
 357   CheckIntPart(getPadUFractSema(), 0);
 358   CheckIntPart(getPadULFractSema(), 0);
 359
 360   // Max
 361   CheckIntPartMax(getPadUSAccumSema(), 255);
 362   CheckIntPartMax(getPadUAccumSema(), 65535);
 363   CheckIntPartMax(getPadULAccumSema(), 4294967295);
 364
 365   CheckIntPartMax(getPadUSFractSema(), 0);
 366   CheckIntPartMax(getPadUFractSema(), 0);
 367   CheckIntPartMax(getPadULFractSema(), 0);
 368
 369   // Rounded Towards Zero
 370   CheckIntPartRes(getSFractSema(), -127, 0);
 371   CheckIntPartRes(getFractSema(), -32767, 0);
 372   CheckIntPartRes(getLFractSema(), -2147483647, 0);
 373   CheckIntPartRes(getS16Neg18(), -32768, 0);
 374 }
 375
 376 TEST(FixedPoint, compare) {
 377   // Equality
 378   // With fractional part (2.5)
 379   // Across sizes
 380   ASSERT_EQ(APFixedPoint(320, getSAccumSema()),
 381             APFixedPoint(81920, getAccumSema()));
 382   ASSERT_EQ(APFixedPoint(320, getSAccumSema()),
 383             APFixedPoint(5368709120, getLAccumSema()));
 384   ASSERT_EQ(APFixedPoint(0, getSAccumSema()), APFixedPoint(0, getLAccumSema()));
 385
 386   ASSERT_EQ(APFixedPoint(0, getS16Neg18()), APFixedPoint(0, getU8Neg10()));
 387   ASSERT_EQ(APFixedPoint(256, getS16Neg18()), APFixedPoint(1, getU8Neg10()));
 388   ASSERT_EQ(APFixedPoint(32512, getS16Neg18()),
 389             APFixedPoint(127, getU8Neg10()));
 390   ASSERT_EQ(APFixedPoint(4, getS32Pos2()), APFixedPoint(1, getU8Pos4()));
 391   ASSERT_EQ(APFixedPoint(1020, getS32Pos2()), APFixedPoint(255, getU8Pos4()));
 392
 393   // Across types (0.5)
 394   ASSERT_EQ(APFixedPoint(64, getSAccumSema()),
 395             APFixedPoint(64, getSFractSema()));
 396   ASSERT_EQ(APFixedPoint(16384, getAccumSema()),
 397             APFixedPoint(16384, getFractSema()));
 398   ASSERT_EQ(APFixedPoint(1073741824, getLAccumSema()),
 399             APFixedPoint(1073741824, getLFractSema()));
 400
 401   // Across widths and types (0.5)
 402   ASSERT_EQ(APFixedPoint(64, getSAccumSema()),
 403             APFixedPoint(16384, getFractSema()));
 404   ASSERT_EQ(APFixedPoint(64, getSAccumSema()),
 405             APFixedPoint(1073741824, getLFractSema()));
 406
 407   // Across saturation
 408   ASSERT_EQ(APFixedPoint(320, getSAccumSema()),
 409             APFixedPoint(81920, Saturated(getAccumSema())));
 410
 411   // Across signs
 412   ASSERT_EQ(APFixedPoint(320, getSAccumSema()),
 413             APFixedPoint(640, getUSAccumSema()));
 414   ASSERT_EQ(APFixedPoint(-320, getSAccumSema()),
 415             APFixedPoint(-81920, getAccumSema()));
 416
 417   // Across padding
 418   ASSERT_EQ(APFixedPoint(320, getSAccumSema()),
 419             APFixedPoint(320, getPadUSAccumSema()));
 420   ASSERT_EQ(APFixedPoint(640, getUSAccumSema()),
 421             APFixedPoint(320, getPadUSAccumSema()));
 422
 423   // Less than
 424   ASSERT_LT(APFixedPoint(-1, getSAccumSema()), APFixedPoint(0, getAccumSema()));
 425   ASSERT_LT(APFixedPoint(-1, getSAccumSema()),
 426             APFixedPoint(0, getUAccumSema()));
 427   ASSERT_LT(APFixedPoint(0, getSAccumSema()), APFixedPoint(1, getAccumSema()));
 428   ASSERT_LT(APFixedPoint(0, getSAccumSema()), APFixedPoint(1, getUAccumSema()));
 429   ASSERT_LT(APFixedPoint(0, getUSAccumSema()), APFixedPoint(1, getAccumSema()));
 430   ASSERT_LT(APFixedPoint(0, getUSAccumSema()),
 431             APFixedPoint(1, getUAccumSema()));
 432   ASSERT_LT(APFixedPoint(65280, getS16Neg18()),
 433             APFixedPoint(255, getU8Neg10()));
 434
 435   // Greater than
 436   ASSERT_GT(APFixedPoint(0, getAccumSema()), APFixedPoint(-1, getSAccumSema()));
 437   ASSERT_GT(APFixedPoint(0, getUAccumSema()),
 438             APFixedPoint(-1, getSAccumSema()));
 439   ASSERT_GT(APFixedPoint(1, getAccumSema()), APFixedPoint(0, getSAccumSema()));
 440   ASSERT_GT(APFixedPoint(1, getUAccumSema()), APFixedPoint(0, getSAccumSema()));
 441   ASSERT_GT(APFixedPoint(1, getAccumSema()), APFixedPoint(0, getUSAccumSema()));
 442   ASSERT_GT(APFixedPoint(1, getUAccumSema()),
 443             APFixedPoint(0, getUSAccumSema()));
 444 }
 445
 446 // Check that a fixed point value in one sema is the same in another sema
 447 void CheckUnsaturatedConversion(FixedPointSemantics Src,
 448                                 FixedPointSemantics Dst, int64_t TestVal) {
 449   int64_t ScaledVal = TestVal;
 450   bool IsNegative = ScaledVal < 0;
 451   if (IsNegative)
 452     ScaledVal = -ScaledVal;
 453
 454   if (Dst.getLsbWeight() < Src.getLsbWeight()) {
 455     ScaledVal <<= (Src.getLsbWeight() - Dst.getLsbWeight());
 456   } else {
 457     ScaledVal >>= (Dst.getLsbWeight() - Src.getLsbWeight());
 458   }
 459
 460   if (IsNegative)
 461     ScaledVal = -ScaledVal;
 462
 463   APFixedPoint Fixed(TestVal, Src);
 464   APFixedPoint Expected(ScaledVal, Dst);
 465   ASSERT_EQ(Fixed.convert(Dst), Expected);
 466 }
 467
 468 // Check the value in a given fixed point sema overflows to the saturated min
 469 // for another sema
 470 void CheckSaturatedConversionMin(FixedPointSemantics Src,
 471                                  FixedPointSemantics Dst, int64_t TestVal) {
 472   APFixedPoint Fixed(TestVal, Src);
 473   ASSERT_EQ(Fixed.convert(Dst), APFixedPoint::getMin(Dst));
 474 }
 475
 476 // Check the value in a given fixed point sema overflows to the saturated max
 477 // for another sema
 478 void CheckSaturatedConversionMax(FixedPointSemantics Src,
 479                                  FixedPointSemantics Dst, int64_t TestVal) {
 480   APFixedPoint Fixed(TestVal, Src);
 481   ASSERT_EQ(Fixed.convert(Dst), APFixedPoint::getMax(Dst));
 482 }
 483
 484 // Check one signed _Accum sema converted to other sema for different values.
 485 void CheckSignedAccumConversionsAgainstOthers(FixedPointSemantics Src,
 486                                               int64_t OneVal) {
 487   int64_t NormalVal = (OneVal * 2) + (OneVal / 2); // 2.5
 488   int64_t HalfVal = (OneVal / 2);                  // 0.5
 489
 490   // +Accums to Accums
 491   CheckUnsaturatedConversion(Src, getSAccumSema(), NormalVal);
 492   CheckUnsaturatedConversion(Src, getAccumSema(), NormalVal);
 493   CheckUnsaturatedConversion(Src, getLAccumSema(), NormalVal);
 494   CheckUnsaturatedConversion(Src, getUSAccumSema(), NormalVal);
 495   CheckUnsaturatedConversion(Src, getUAccumSema(), NormalVal);
 496   CheckUnsaturatedConversion(Src, getULAccumSema(), NormalVal);
 497   CheckUnsaturatedConversion(Src, getPadUSAccumSema(), NormalVal);
 498   CheckUnsaturatedConversion(Src, getPadUAccumSema(), NormalVal);
 499   CheckUnsaturatedConversion(Src, getPadULAccumSema(), NormalVal);
 500
 501   // -Accums to Accums
 502   CheckUnsaturatedConversion(Src, getSAccumSema(), -NormalVal);
 503   CheckUnsaturatedConversion(Src, getAccumSema(), -NormalVal);
 504   CheckUnsaturatedConversion(Src, getLAccumSema(), -NormalVal);
 505   CheckSaturatedConversionMin(Src, Saturated(getUSAccumSema()), -NormalVal);
 506   CheckSaturatedConversionMin(Src, Saturated(getUAccumSema()), -NormalVal);
 507   CheckSaturatedConversionMin(Src, Saturated(getULAccumSema()), -NormalVal);
 508   CheckSaturatedConversionMin(Src, Saturated(getPadUSAccumSema()), -NormalVal);
 509   CheckSaturatedConversionMin(Src, Saturated(getPadUAccumSema()), -NormalVal);
 510   CheckSaturatedConversionMin(Src, Saturated(getPadULAccumSema()), -NormalVal);
 511
 512   // +Accums to Fracts
 513   CheckUnsaturatedConversion(Src, getSFractSema(), HalfVal);
 514   CheckUnsaturatedConversion(Src, getFractSema(), HalfVal);
 515   CheckUnsaturatedConversion(Src, getLFractSema(), HalfVal);
 516   CheckUnsaturatedConversion(Src, getUSFractSema(), HalfVal);
 517   CheckUnsaturatedConversion(Src, getUFractSema(), HalfVal);
 518   CheckUnsaturatedConversion(Src, getULFractSema(), HalfVal);
 519   CheckUnsaturatedConversion(Src, getPadUSFractSema(), HalfVal);
 520   CheckUnsaturatedConversion(Src, getPadUFractSema(), HalfVal);
 521   CheckUnsaturatedConversion(Src, getPadULFractSema(), HalfVal);
 522
 523   // -Accums to Fracts
 524   CheckUnsaturatedConversion(Src, getSFractSema(), -HalfVal);
 525   CheckUnsaturatedConversion(Src, getFractSema(), -HalfVal);
 526   CheckUnsaturatedConversion(Src, getLFractSema(), -HalfVal);
 527   CheckSaturatedConversionMin(Src, Saturated(getUSFractSema()), -HalfVal);
 528   CheckSaturatedConversionMin(Src, Saturated(getUFractSema()), -HalfVal);
 529   CheckSaturatedConversionMin(Src, Saturated(getULFractSema()), -HalfVal);
 530   CheckSaturatedConversionMin(Src, Saturated(getPadUSFractSema()), -HalfVal);
 531   CheckSaturatedConversionMin(Src, Saturated(getPadUFractSema()), -HalfVal);
 532   CheckSaturatedConversionMin(Src, Saturated(getPadULFractSema()), -HalfVal);
 533
 534   // 0 to Accums
 535   CheckUnsaturatedConversion(Src, getSAccumSema(), 0);
 536   CheckUnsaturatedConversion(Src, getAccumSema(), 0);
 537   CheckUnsaturatedConversion(Src, getLAccumSema(), 0);
 538   CheckUnsaturatedConversion(Src, getUSAccumSema(), 0);
 539   CheckUnsaturatedConversion(Src, getUAccumSema(), 0);
 540   CheckUnsaturatedConversion(Src, getULAccumSema(), 0);
 541   CheckUnsaturatedConversion(Src, getPadUSAccumSema(), 0);
 542   CheckUnsaturatedConversion(Src, getPadUAccumSema(), 0);
 543   CheckUnsaturatedConversion(Src, getPadULAccumSema(), 0);
 544
 545   // 0 to Fracts
 546   CheckUnsaturatedConversion(Src, getSFractSema(), 0);
 547   CheckUnsaturatedConversion(Src, getFractSema(), 0);
 548   CheckUnsaturatedConversion(Src, getLFractSema(), 0);
 549   CheckUnsaturatedConversion(Src, getUSFractSema(), 0);
 550   CheckUnsaturatedConversion(Src, getUFractSema(), 0);
 551   CheckUnsaturatedConversion(Src, getULFractSema(), 0);
 552   CheckUnsaturatedConversion(Src, getPadUSFractSema(), 0);
 553   CheckUnsaturatedConversion(Src, getPadUFractSema(), 0);
 554   CheckUnsaturatedConversion(Src, getPadULFractSema(), 0);
 555 }
 556
 557 // Check one unsigned _Accum sema converted to other sema for different
 558 // values.
 559 void CheckUnsignedAccumConversionsAgainstOthers(FixedPointSemantics Src,
 560                                                 int64_t OneVal) {
 561   int64_t NormalVal = (OneVal * 2) + (OneVal / 2); // 2.5
 562   int64_t HalfVal = (OneVal / 2);                  // 0.5
 563
 564   // +UAccums to Accums
 565   CheckUnsaturatedConversion(Src, getSAccumSema(), NormalVal);
 566   CheckUnsaturatedConversion(Src, getAccumSema(), NormalVal);
 567   CheckUnsaturatedConversion(Src, getLAccumSema(), NormalVal);
 568   CheckUnsaturatedConversion(Src, getUSAccumSema(), NormalVal);
 569   CheckUnsaturatedConversion(Src, getUAccumSema(), NormalVal);
 570   CheckUnsaturatedConversion(Src, getULAccumSema(), NormalVal);
 571   CheckUnsaturatedConversion(Src, getPadUSAccumSema(), NormalVal);
 572   CheckUnsaturatedConversion(Src, getPadUAccumSema(), NormalVal);
 573   CheckUnsaturatedConversion(Src, getPadULAccumSema(), NormalVal);
 574
 575   // +UAccums to Fracts
 576   CheckUnsaturatedConversion(Src, getSFractSema(), HalfVal);
 577   CheckUnsaturatedConversion(Src, getFractSema(), HalfVal);
 578   CheckUnsaturatedConversion(Src, getLFractSema(), HalfVal);
 579   CheckUnsaturatedConversion(Src, getUSFractSema(), HalfVal);
 580   CheckUnsaturatedConversion(Src, getUFractSema(), HalfVal);
 581   CheckUnsaturatedConversion(Src, getULFractSema(), HalfVal);
 582   CheckUnsaturatedConversion(Src, getPadUSFractSema(), HalfVal);
 583   CheckUnsaturatedConversion(Src, getPadUFractSema(), HalfVal);
 584   CheckUnsaturatedConversion(Src, getPadULFractSema(), HalfVal);
 585 }
 586
 587 TEST(FixedPoint, AccumConversions) {
 588   // Normal conversions
 589   CheckSignedAccumConversionsAgainstOthers(getSAccumSema(), 128);
 590   CheckUnsignedAccumConversionsAgainstOthers(getUSAccumSema(), 256);
 591   CheckSignedAccumConversionsAgainstOthers(getAccumSema(), 32768);
 592   CheckUnsignedAccumConversionsAgainstOthers(getUAccumSema(), 65536);
 593   CheckSignedAccumConversionsAgainstOthers(getLAccumSema(), 2147483648);
 594   CheckUnsignedAccumConversionsAgainstOthers(getULAccumSema(), 4294967296);
 595
 596   CheckUnsignedAccumConversionsAgainstOthers(getPadUSAccumSema(), 128);
 597   CheckUnsignedAccumConversionsAgainstOthers(getPadUAccumSema(), 32768);
 598   CheckUnsignedAccumConversionsAgainstOthers(getPadULAccumSema(), 2147483648);
 599 }
 600
 601 TEST(FixedPoint, AccumConversionOverflow) {
 602   // To SAccum max limit (65536)
 603   CheckSaturatedConversionMax(getLAccumSema(), Saturated(getAccumSema()),
 604                               140737488355328);
 605   CheckSaturatedConversionMax(getLAccumSema(), Saturated(getUAccumSema()),
 606                               140737488355328);
 607   CheckSaturatedConversionMax(getLAccumSema(), Saturated(getPadUAccumSema()),
 608                               140737488355328);
 609   CheckSaturatedConversionMax(getULAccumSema(), Saturated(getAccumSema()),
 610                               281474976710656);
 611   CheckSaturatedConversionMax(getULAccumSema(), Saturated(getUAccumSema()),
 612                               281474976710656);
 613   CheckSaturatedConversionMax(getULAccumSema(), Saturated(getPadUAccumSema()),
 614                               281474976710656);
 615
 616   CheckSaturatedConversionMax(getPadULAccumSema(), Saturated(getAccumSema()),
 617                               140737488355328);
 618   CheckSaturatedConversionMax(getPadULAccumSema(), Saturated(getUAccumSema()),
 619                               140737488355328);
 620   CheckSaturatedConversionMax(getPadULAccumSema(),
 621                               Saturated(getPadUAccumSema()), 140737488355328);
 622
 623   // To SAccum min limit (-65536)
 624   CheckSaturatedConversionMin(getLAccumSema(), Saturated(getAccumSema()),
 625                               -140737488355328);
 626   CheckSaturatedConversionMin(getLAccumSema(), Saturated(getUAccumSema()),
 627                               -140737488355328);
 628   CheckSaturatedConversionMin(getLAccumSema(), Saturated(getPadUAccumSema()),
 629                               -140737488355328);
 630 }
 631
 632 TEST(FixedPoint, SAccumConversionOverflow) {
 633   // To SAccum max limit (256)
 634   CheckSaturatedConversionMax(getAccumSema(), Saturated(getSAccumSema()),
 635                               8388608);
 636   CheckSaturatedConversionMax(getAccumSema(), Saturated(getUSAccumSema()),
 637                               8388608);
 638   CheckSaturatedConversionMax(getAccumSema(), Saturated(getPadUSAccumSema()),
 639                               8388608);
 640   CheckSaturatedConversionMax(getUAccumSema(), Saturated(getSAccumSema()),
 641                               16777216);
 642   CheckSaturatedConversionMax(getUAccumSema(), Saturated(getUSAccumSema()),
 643                               16777216);
 644   CheckSaturatedConversionMax(getUAccumSema(), Saturated(getPadUSAccumSema()),
 645                               16777216);
 646   CheckSaturatedConversionMax(getLAccumSema(), Saturated(getSAccumSema()),
 647                               549755813888);
 648   CheckSaturatedConversionMax(getLAccumSema(), Saturated(getUSAccumSema()),
 649                               549755813888);
 650   CheckSaturatedConversionMax(getLAccumSema(), Saturated(getPadUSAccumSema()),
 651                               549755813888);
 652   CheckSaturatedConversionMax(getULAccumSema(), Saturated(getSAccumSema()),
 653                               1099511627776);
 654   CheckSaturatedConversionMax(getULAccumSema(), Saturated(getUSAccumSema()),
 655                               1099511627776);
 656   CheckSaturatedConversionMax(getULAccumSema(), Saturated(getPadUSAccumSema()),
 657                               1099511627776);
 658
 659   CheckSaturatedConversionMax(getPadUAccumSema(), Saturated(getSAccumSema()),
 660                               8388608);
 661   CheckSaturatedConversionMax(getPadUAccumSema(), Saturated(getUSAccumSema()),
 662                               8388608);
 663   CheckSaturatedConversionMax(getPadUAccumSema(),
 664                               Saturated(getPadUSAccumSema()), 8388608);
 665   CheckSaturatedConversionMax(getPadULAccumSema(), Saturated(getSAccumSema()),
 666                               549755813888);
 667   CheckSaturatedConversionMax(getPadULAccumSema(), Saturated(getUSAccumSema()),
 668                               549755813888);
 669   CheckSaturatedConversionMax(getPadULAccumSema(),
 670                               Saturated(getPadUSAccumSema()), 549755813888);
 671
 672   // To SAccum min limit (-256)
 673   CheckSaturatedConversionMin(getAccumSema(), Saturated(getSAccumSema()),
 674                               -8388608);
 675   CheckSaturatedConversionMin(getAccumSema(), Saturated(getUSAccumSema()),
 676                               -8388608);
 677   CheckSaturatedConversionMin(getAccumSema(), Saturated(getPadUSAccumSema()),
 678                               -8388608);
 679   CheckSaturatedConversionMin(getLAccumSema(), Saturated(getSAccumSema()),
 680                               -549755813888);
 681   CheckSaturatedConversionMin(getLAccumSema(), Saturated(getUSAccumSema()),
 682                               -549755813888);
 683   CheckSaturatedConversionMin(getLAccumSema(), Saturated(getPadUSAccumSema()),
 684                               -549755813888);
 685 }
 686
 687 TEST(FixedPoint, GetValueSignAfterConversion) {
 688   APFixedPoint Fixed(255 << 7, getSAccumSema());
 689   ASSERT_TRUE(Fixed.getValue().isSigned());
 690   APFixedPoint UFixed = Fixed.convert(getUSAccumSema());
 691   ASSERT_TRUE(UFixed.getValue().isUnsigned());
 692   ASSERT_EQ(UFixed.getValue(), APSInt::getUnsigned(255 << 8).extOrTrunc(16));
 693 }
 694
 695 TEST(FixedPoint, ModularWrapAround) {
 696   // Positive to negative
 697   APFixedPoint Val = APFixedPoint(1ULL << 7, getSAccumSema());
 698   ASSERT_EQ(Val.convert(getLFractSema()).getValue(), -(1ULL << 31));
 699
 700   Val = APFixedPoint(1ULL << 23, getAccumSema());
 701   ASSERT_EQ(Val.convert(getSAccumSema()).getValue(), -(1ULL << 15));
 702
 703   Val = APFixedPoint(1ULL << 47, getLAccumSema());
 704   ASSERT_EQ(Val.convert(getAccumSema()).getValue(), -(1ULL << 31));
 705
 706   // Negative to positive
 707   Val = APFixedPoint(/*-1.5*/ -192, getSAccumSema());
 708   ASSERT_EQ(Val.convert(getLFractSema()).getValue(), 1ULL << 30);
 709
 710   Val = APFixedPoint(-(257 << 15), getAccumSema());
 711   ASSERT_EQ(Val.convert(getSAccumSema()).getValue(), 255 << 7);
 712
 713   Val = APFixedPoint(-(65537ULL << 31), getLAccumSema());
 714   ASSERT_EQ(Val.convert(getAccumSema()).getValue(), 65535 << 15);
 715
 716   // Signed to unsigned
 717   Val = APFixedPoint(-(1 << 7), getSAccumSema());
 718   ASSERT_EQ(Val.convert(getUSAccumSema()).getValue(), 255 << 8);
 719
 720   Val = APFixedPoint(-(1 << 15), getAccumSema());
 721   ASSERT_EQ(Val.convert(getUAccumSema()).getValue(), 65535ULL << 16);
 722
 723   Val = APFixedPoint(-(1ULL << 31), getLAccumSema());
 724   ASSERT_EQ(Val.convert(getULAccumSema()).getValue().getZExtValue(),
 725             4294967295ULL << 32);
 726 }
 727
 728 enum OvfKind { MinSat, MaxSat };
 729
 730 void CheckFloatToFixedConversion(APFloat &Val, const FixedPointSemantics &Sema,
 731                                  int64_t ExpectedNonSat) {
 732   bool Ovf;
 733   ASSERT_EQ(APFixedPoint::getFromFloatValue(Val, Sema, &Ovf).getValue(),
 734             ExpectedNonSat);
 735   ASSERT_EQ(Ovf, false);
 736   ASSERT_EQ(
 737       APFixedPoint::getFromFloatValue(Val, Saturated(Sema), &Ovf).getValue(),
 738       ExpectedNonSat);
 739   ASSERT_EQ(Ovf, false);
 740 }
 741
 742 void CheckFloatToFixedConversion(APFloat &Val, const FixedPointSemantics &Sema,
 743                                  OvfKind ExpectedOvf) {
 744   bool Ovf;
 745   (void)APFixedPoint::getFromFloatValue(Val, Sema, &Ovf);
 746   ASSERT_EQ(Ovf, true);
 747   ASSERT_EQ(
 748       APFixedPoint::getFromFloatValue(Val, Saturated(Sema), &Ovf).getValue(),
 749       (ExpectedOvf == MinSat ? APFixedPoint::getMin(Sema)
 750                              : APFixedPoint::getMax(Sema))
 751           .getValue());
 752   ASSERT_EQ(Ovf, false);
 753 }
 754
 755 TEST(FixedPoint, toString) {
 756   ASSERT_EQ(APFixedPoint::getMax(getS16Neg18()).toString(),
 757             "0.124996185302734375");
 758   ASSERT_EQ(APFixedPoint::getMin(getS16Neg18())
 759                 .add(APFixedPoint(1, getS16Neg18()))
 760                 .toString(),
 761             "-0.124996185302734375");
 762   ASSERT_EQ(APFixedPoint::getMin(getS16Neg18()).toString(), "-0.125");
 763   ASSERT_EQ(APFixedPoint::getMax(getU8Neg10()).toString(), "0.2490234375");
 764   ASSERT_EQ(APFixedPoint::getMin(getU8Neg10()).toString(), "0.0");
 765   ASSERT_EQ(APFixedPoint::getMax(getS32Pos2()).toString(), "8589934588.0");
 766   ASSERT_EQ(APFixedPoint::getMin(getS32Pos2())
 767                 .add(APFixedPoint(1, getS32Pos2()))
 768                 .toString(),
 769             "-8589934588.0");
 770   ASSERT_EQ(APFixedPoint::getMin(getS32Pos2()).toString(), "-8589934592.0");
 771   ASSERT_EQ(APFixedPoint::getMax(getU8Pos4()).toString(), "4080.0");
 772   ASSERT_EQ(APFixedPoint::getMin(getU8Pos4()).toString(), "0.0");
 773 }
 774
 775 TEST(FixedPoint, FloatToFixed) {
 776   APFloat Val(0.0f);
 777
 778   // Simple exact fraction
 779   Val = APFloat(0.75f);
 780   CheckFloatToFixedConversion(Val, getSAccumSema(), 3ULL << 5);
 781   CheckFloatToFixedConversion(Val, getAccumSema(),  3ULL << 13);
 782   CheckFloatToFixedConversion(Val, getLAccumSema(), 3ULL << 29);
 783
 784   CheckFloatToFixedConversion(Val, getUSAccumSema(), 3ULL << 6);
 785   CheckFloatToFixedConversion(Val, getUAccumSema(),  3ULL << 14);
 786   CheckFloatToFixedConversion(Val, getULAccumSema(), 3ULL << 30);
 787
 788   CheckFloatToFixedConversion(Val, getSFractSema(), 3ULL << 5);
 789   CheckFloatToFixedConversion(Val, getFractSema(),  3ULL << 13);
 790   CheckFloatToFixedConversion(Val, getLFractSema(), 3ULL << 29);
 791
 792   CheckFloatToFixedConversion(Val, getUSFractSema(), 3ULL << 6);
 793   CheckFloatToFixedConversion(Val, getUFractSema(),  3ULL << 14);
 794   CheckFloatToFixedConversion(Val, getULFractSema(), 3ULL << 30);
 795
 796   CheckFloatToFixedConversion(Val, getU8Neg10(), MaxSat);
 797   CheckFloatToFixedConversion(Val, getU8Pos4(),  0);
 798   CheckFloatToFixedConversion(Val, getS16Neg18(), MaxSat);
 799   CheckFloatToFixedConversion(Val, getS32Pos2(), 0);
 800
 801   // Simple negative exact fraction
 802   Val = APFloat(-0.75f);
 803   CheckFloatToFixedConversion(Val, getSAccumSema(), -3ULL << 5);
 804   CheckFloatToFixedConversion(Val, getAccumSema(),  -3ULL << 13);
 805   CheckFloatToFixedConversion(Val, getLAccumSema(), -3ULL << 29);
 806
 807   CheckFloatToFixedConversion(Val, getUSAccumSema(), MinSat);
 808   CheckFloatToFixedConversion(Val, getUAccumSema(),  MinSat);
 809   CheckFloatToFixedConversion(Val, getULAccumSema(), MinSat);
 810
 811   CheckFloatToFixedConversion(Val, getSFractSema(), -3ULL << 5);
 812   CheckFloatToFixedConversion(Val, getFractSema(),  -3ULL << 13);
 813   CheckFloatToFixedConversion(Val, getLFractSema(), -3ULL << 29);
 814
 815   CheckFloatToFixedConversion(Val, getUSFractSema(), MinSat);
 816   CheckFloatToFixedConversion(Val, getUFractSema(),  MinSat);
 817   CheckFloatToFixedConversion(Val, getULFractSema(), MinSat);
 818
 819   CheckFloatToFixedConversion(Val, getU8Neg10(), MinSat);
 820   CheckFloatToFixedConversion(Val, getU8Pos4(),  0);
 821   CheckFloatToFixedConversion(Val, getS16Neg18(), MinSat);
 822   CheckFloatToFixedConversion(Val, getS32Pos2(), 0);
 823
 824   // Highly precise fraction
 825   Val = APFloat(0.999999940395355224609375f);
 826   CheckFloatToFixedConversion(Val, getSAccumSema(), 0x7FULL);
 827   CheckFloatToFixedConversion(Val, getAccumSema(),  0x7FFFULL);
 828   CheckFloatToFixedConversion(Val, getLAccumSema(), 0xFFFFFFULL << 7);
 829
 830   CheckFloatToFixedConversion(Val, getUSAccumSema(), 0xFFULL);
 831   CheckFloatToFixedConversion(Val, getUAccumSema(),  0xFFFFULL);
 832   CheckFloatToFixedConversion(Val, getULAccumSema(), 0xFFFFFFULL << 8);
 833
 834   CheckFloatToFixedConversion(Val, getSFractSema(), 0x7FULL);
 835   CheckFloatToFixedConversion(Val, getFractSema(),  0x7FFFULL);
 836   CheckFloatToFixedConversion(Val, getLFractSema(), 0xFFFFFFULL << 7);
 837
 838   CheckFloatToFixedConversion(Val, getUSFractSema(), 0xFFULL);
 839   CheckFloatToFixedConversion(Val, getUFractSema(),  0xFFFFULL);
 840   CheckFloatToFixedConversion(Val, getULFractSema(), 0xFFFFFFULL << 8);
 841
 842   CheckFloatToFixedConversion(Val, getU8Neg10(), MaxSat);
 843   CheckFloatToFixedConversion(Val, getU8Pos4(), 0);
 844   CheckFloatToFixedConversion(Val, getS16Neg18(), MaxSat);
 845   CheckFloatToFixedConversion(Val, getS32Pos2(), 0);
 846
 847   // Integral and fraction
 848   Val = APFloat(17.99609375f);
 849   CheckFloatToFixedConversion(Val, getSAccumSema(), 0x11FFULL >> 1);
 850   CheckFloatToFixedConversion(Val, getAccumSema(),  0x11FFULL << 7);
 851   CheckFloatToFixedConversion(Val, getLAccumSema(), 0x11FFULL << 23);
 852
 853   CheckFloatToFixedConversion(Val, getUSAccumSema(), 0x11FFULL);
 854   CheckFloatToFixedConversion(Val, getUAccumSema(),  0x11FFULL << 8);
 855   CheckFloatToFixedConversion(Val, getULAccumSema(), 0x11FFULL << 24);
 856
 857   CheckFloatToFixedConversion(Val, getSFractSema(), MaxSat);
 858   CheckFloatToFixedConversion(Val, getFractSema(),  MaxSat);
 859   CheckFloatToFixedConversion(Val, getLFractSema(), MaxSat);
 860
 861   CheckFloatToFixedConversion(Val, getUSFractSema(), MaxSat);
 862   CheckFloatToFixedConversion(Val, getUFractSema(),  MaxSat);
 863   CheckFloatToFixedConversion(Val, getULFractSema(), MaxSat);
 864
 865   CheckFloatToFixedConversion(Val, getU8Neg10(), MaxSat);
 866   CheckFloatToFixedConversion(Val, getU8Pos4(), 1);
 867   CheckFloatToFixedConversion(Val, getS16Neg18(), MaxSat);
 868   CheckFloatToFixedConversion(Val, getS32Pos2(), 1 << 2);
 869
 870   // Negative integral and fraction
 871   Val = APFloat(-17.99609375f);
 872   CheckFloatToFixedConversion(Val, getSAccumSema(), -0x11FELL >> 1);
 873   CheckFloatToFixedConversion(Val, getAccumSema(),  -0x11FFULL << 7);
 874   CheckFloatToFixedConversion(Val, getLAccumSema(), -0x11FFULL << 23);
 875
 876   CheckFloatToFixedConversion(Val, getUSAccumSema(), MinSat);
 877   CheckFloatToFixedConversion(Val, getUAccumSema(),  MinSat);
 878   CheckFloatToFixedConversion(Val, getULAccumSema(), MinSat);
 879
 880   CheckFloatToFixedConversion(Val, getSFractSema(), MinSat);
 881   CheckFloatToFixedConversion(Val, getFractSema(),  MinSat);
 882   CheckFloatToFixedConversion(Val, getLFractSema(), MinSat);
 883
 884   CheckFloatToFixedConversion(Val, getUSFractSema(), MinSat);
 885   CheckFloatToFixedConversion(Val, getUFractSema(),  MinSat);
 886   CheckFloatToFixedConversion(Val, getULFractSema(), MinSat);
 887
 888   CheckFloatToFixedConversion(Val, getU8Neg10(), MinSat);
 889   CheckFloatToFixedConversion(Val, getU8Pos4(), MinSat);
 890   CheckFloatToFixedConversion(Val, getS16Neg18(), MinSat);
 891   CheckFloatToFixedConversion(Val, getS32Pos2(), -4);
 892
 893   // Very large value
 894   Val = APFloat(1.0e38f);
 895   CheckFloatToFixedConversion(Val, getSAccumSema(), MaxSat);
 896   CheckFloatToFixedConversion(Val, getAccumSema(),  MaxSat);
 897   CheckFloatToFixedConversion(Val, getLAccumSema(), MaxSat);
 898
 899   CheckFloatToFixedConversion(Val, getUSAccumSema(), MaxSat);
 900   CheckFloatToFixedConversion(Val, getUAccumSema(),  MaxSat);
 901   CheckFloatToFixedConversion(Val, getULAccumSema(), MaxSat);
 902
 903   CheckFloatToFixedConversion(Val, getSFractSema(), MaxSat);
 904   CheckFloatToFixedConversion(Val, getFractSema(),  MaxSat);
 905   CheckFloatToFixedConversion(Val, getLFractSema(), MaxSat);
 906
 907   CheckFloatToFixedConversion(Val, getUSFractSema(), MaxSat);
 908   CheckFloatToFixedConversion(Val, getUFractSema(),  MaxSat);
 909   CheckFloatToFixedConversion(Val, getULFractSema(), MaxSat);
 910
 911   CheckFloatToFixedConversion(Val, getU8Neg10(), MaxSat);
 912   CheckFloatToFixedConversion(Val, getU8Pos4(), MaxSat);
 913   CheckFloatToFixedConversion(Val, getS16Neg18(), MaxSat);
 914   CheckFloatToFixedConversion(Val, getS32Pos2(), MaxSat);
 915
 916   // Very small value
 917   Val = APFloat(1.0e-38f);
 918   CheckFloatToFixedConversion(Val, getSAccumSema(), 0);
 919   CheckFloatToFixedConversion(Val, getAccumSema(),  0);
 920   CheckFloatToFixedConversion(Val, getLAccumSema(), 0);
 921
 922   CheckFloatToFixedConversion(Val, getUSAccumSema(), 0);
 923   CheckFloatToFixedConversion(Val, getUAccumSema(),  0);
 924   CheckFloatToFixedConversion(Val, getULAccumSema(), 0);
 925
 926   CheckFloatToFixedConversion(Val, getSFractSema(), 0);
 927   CheckFloatToFixedConversion(Val, getFractSema(),  0);
 928   CheckFloatToFixedConversion(Val, getLFractSema(), 0);
 929
 930   CheckFloatToFixedConversion(Val, getUSFractSema(), 0);
 931   CheckFloatToFixedConversion(Val, getUFractSema(),  0);
 932   CheckFloatToFixedConversion(Val, getULFractSema(), 0);
 933
 934   CheckFloatToFixedConversion(Val, getU8Neg10(), 0);
 935   CheckFloatToFixedConversion(Val, getU8Pos4(), 0);
 936   CheckFloatToFixedConversion(Val, getS16Neg18(), 0);
 937   CheckFloatToFixedConversion(Val, getS32Pos2(), 0);
 938
 939   // Half conversion
 940   Val = APFloat(0.99951171875f);
 941   bool Ignored;
 942   Val.convert(APFloat::IEEEhalf(), APFloat::rmNearestTiesToEven, &Ignored);
 943
 944   CheckFloatToFixedConversion(Val, getSAccumSema(), 0x7FULL);
 945   CheckFloatToFixedConversion(Val, getAccumSema(),  0x7FFULL << 4);
 946   CheckFloatToFixedConversion(Val, getLAccumSema(), 0x7FFULL << 20);
 947
 948   CheckFloatToFixedConversion(Val, getUSAccumSema(), 0xFFULL);
 949   CheckFloatToFixedConversion(Val, getUAccumSema(),  0xFFEULL << 4);
 950   CheckFloatToFixedConversion(Val, getULAccumSema(), 0xFFEULL << 20);
 951
 952   CheckFloatToFixedConversion(Val, getSFractSema(), 0x7FULL);
 953   CheckFloatToFixedConversion(Val, getFractSema(),  0x7FFULL << 4);
 954   CheckFloatToFixedConversion(Val, getLFractSema(), 0x7FFULL << 20);
 955
 956   CheckFloatToFixedConversion(Val, getUSFractSema(), 0xFFULL);
 957   CheckFloatToFixedConversion(Val, getUFractSema(),  0xFFEULL << 4);
 958   CheckFloatToFixedConversion(Val, getULFractSema(), 0xFFEULL << 20);
 959
 960   CheckFloatToFixedConversion(Val, getU8Neg10(), MaxSat);
 961   CheckFloatToFixedConversion(Val, getU8Pos4(), 0);
 962   CheckFloatToFixedConversion(Val, getS16Neg18(), MaxSat);
 963   CheckFloatToFixedConversion(Val, getS32Pos2(), 0);
 964
 965   Val = APFloat(0.124996185302734375);
 966   CheckFloatToFixedConversion(Val, getU8Neg10(), 0x7f);
 967   CheckFloatToFixedConversion(Val, getU8Pos4(), 0);
 968   CheckFloatToFixedConversion(Val, getS16Neg18(), 0x7fff);
 969   CheckFloatToFixedConversion(Val, getS32Pos2(), 0);
 970
 971   Val = APFloat(-0.124996185302734375);
 972   CheckFloatToFixedConversion(Val, getU8Neg10(), MinSat);
 973   CheckFloatToFixedConversion(Val, getU8Pos4(), 0);
 974   CheckFloatToFixedConversion(Val, getS16Neg18(), -0x7fff);
 975   CheckFloatToFixedConversion(Val, getS32Pos2(), 0);
 976 }
 977
 978 void CheckFixedToFloatConversion(int64_t Val, const FixedPointSemantics &Sema,
 979                                  float Result) {
 980   APFixedPoint FXVal(Val, Sema);
 981   APFloat APRes(Result);
 982   ASSERT_EQ(FXVal.convertToFloat(APFloat::IEEEsingle()), APRes);
 983 }
 984
 985 void CheckFixedToHalfConversion(int64_t Val, const FixedPointSemantics &Sema,
 986                                 float Result) {
 987   APFixedPoint FXVal(Val, Sema);
 988   APFloat APRes(Result);
 989   bool Ignored;
 990   APRes.convert(APFloat::IEEEhalf(), APFloat::rmNearestTiesToEven, &Ignored);
 991   ASSERT_EQ(FXVal.convertToFloat(APFloat::IEEEhalf()), APRes);
 992 }
 993
 994 TEST(FixedPoint, FixedToFloat) {
 995   int64_t Val = 0x1ULL;
 996   CheckFixedToFloatConversion(Val, getSAccumSema(), 0.0078125f);
 997   CheckFixedToFloatConversion(Val, getFractSema(),  0.000030517578125f);
 998   CheckFixedToFloatConversion(Val, getAccumSema(),  0.000030517578125f);
 999   CheckFixedToFloatConversion(Val, getLFractSema(),
1000                               0.0000000004656612873077392578125f);
1001
1002   CheckFixedToFloatConversion(Val, getUSAccumSema(), 0.00390625f);
1003   CheckFixedToFloatConversion(Val, getUFractSema(),  0.0000152587890625f);
1004   CheckFixedToFloatConversion(Val, getUAccumSema(),  0.0000152587890625f);
1005   CheckFixedToFloatConversion(Val, getULFractSema(),
1006                               0.00000000023283064365386962890625f);
1007
1008   CheckFixedToFloatConversion(Val, getU8Neg10(), 0.0009765625f);
1009   CheckFixedToFloatConversion(Val, getU8Pos4(), 16.0f);
1010   CheckFixedToFloatConversion(Val, getS16Neg18(), 0.000003814697265625f);
1011   CheckFixedToFloatConversion(Val, getS32Pos2(), 4.0f);
1012
1013   Val = 0x7FULL;
1014   CheckFixedToFloatConversion(Val, getSAccumSema(), 0.9921875f);
1015   CheckFixedToFloatConversion(Val, getFractSema(),  0.003875732421875f);
1016   CheckFixedToFloatConversion(Val, getAccumSema(),  0.003875732421875f);
1017   CheckFixedToFloatConversion(Val, getLFractSema(),
1018                               0.0000000591389834880828857421875f);
1019
1020   CheckFixedToFloatConversion(Val, getUSAccumSema(), 0.49609375f);
1021   CheckFixedToFloatConversion(Val, getUFractSema(),  0.0019378662109375f);
1022   CheckFixedToFloatConversion(Val, getUAccumSema(),  0.0019378662109375f);
1023   CheckFixedToFloatConversion(Val, getULFractSema(),
1024                               0.00000002956949174404144287109375f);
1025
1026   CheckFixedToFloatConversion(Val, getU8Neg10(), 0.1240234375f);
1027   CheckFixedToFloatConversion(Val, getU8Pos4(), 2032.0f);
1028   CheckFixedToFloatConversion(Val, getS16Neg18(), 0.000484466552734375f);
1029   CheckFixedToFloatConversion(Val, getS32Pos2(), 508.0f);
1030
1031   Val = -0x1ULL;
1032   CheckFixedToFloatConversion(Val, getSAccumSema(), -0.0078125f);
1033   CheckFixedToFloatConversion(Val, getFractSema(),  -0.000030517578125f);
1034   CheckFixedToFloatConversion(Val, getAccumSema(),  -0.000030517578125f);
1035   CheckFixedToFloatConversion(Val, getLFractSema(),
1036                               -0.0000000004656612873077392578125f);
1037
1038   CheckFixedToFloatConversion(Val, getU8Neg10(), 0.249023437f);
1039   CheckFixedToFloatConversion(Val, getU8Pos4(), 4080.0f);
1040   CheckFixedToFloatConversion(Val, getS16Neg18(), -0.000003814697265625f);
1041   CheckFixedToFloatConversion(Val, getS32Pos2(), -4.0f);
1042
1043   CheckFixedToFloatConversion(-0x80ULL,       getSAccumSema(), -1.0f);
1044   CheckFixedToFloatConversion(-0x8000ULL,     getFractSema(),  -1.0f);
1045   CheckFixedToFloatConversion(-0x8000ULL,     getAccumSema(),  -1.0f);
1046   CheckFixedToFloatConversion(-0x80000000ULL, getLFractSema(), -1.0f);
1047
1048   Val = 0xAFAULL;
1049   CheckFixedToFloatConversion(Val, getSAccumSema(), 21.953125f);
1050   CheckFixedToFloatConversion(Val, getFractSema(),  0.08575439453125f);
1051   CheckFixedToFloatConversion(Val, getAccumSema(),  0.08575439453125f);
1052   CheckFixedToFloatConversion(Val, getLFractSema(),
1053                               0.000001308508217334747314453125f);
1054
1055   CheckFixedToFloatConversion(Val, getUSAccumSema(), 10.9765625f);
1056   CheckFixedToFloatConversion(Val, getUFractSema(),  0.042877197265625f);
1057   CheckFixedToFloatConversion(Val, getUAccumSema(),  0.042877197265625f);
1058   CheckFixedToFloatConversion(Val, getULFractSema(),
1059                               0.0000006542541086673736572265625f);
1060
1061   CheckFixedToFloatConversion(Val, getS16Neg18(), 0.01071929931640625f);
1062   CheckFixedToFloatConversion(Val, getS32Pos2(), 11240.0f);
1063
1064   Val = -0xAFAULL;
1065   CheckFixedToFloatConversion(Val, getSAccumSema(), -21.953125f);
1066   CheckFixedToFloatConversion(Val, getFractSema(),  -0.08575439453125f);
1067   CheckFixedToFloatConversion(Val, getAccumSema(),  -0.08575439453125f);
1068   CheckFixedToFloatConversion(Val, getLFractSema(),
1069                               -0.000001308508217334747314453125f);
1070
1071   CheckFixedToFloatConversion(Val, getS16Neg18(), -0.01071929931640625f);
1072   CheckFixedToFloatConversion(Val, getS32Pos2(), -11240.0f);
1073
1074   Val = 0x40000080ULL;
1075   CheckFixedToFloatConversion(Val, getAccumSema(),  32768.00390625f);
1076   CheckFixedToFloatConversion(Val, getLFractSema(),
1077                               0.500000059604644775390625f);
1078
1079   CheckFixedToFloatConversion(Val, getUAccumSema(),  16384.001953125f);
1080   CheckFixedToFloatConversion(Val, getULFractSema(),
1081                               0.2500000298023223876953125f);
1082
1083   CheckFixedToFloatConversion(Val, getS32Pos2(), 4294967808.0f);
1084
1085   Val = 0x40000040ULL;
1086   CheckFixedToFloatConversion(Val, getAccumSema(),  32768.0f);
1087   CheckFixedToFloatConversion(Val, getLFractSema(), 0.5f);
1088
1089   CheckFixedToFloatConversion(Val, getUAccumSema(),  16384.0f);
1090   CheckFixedToFloatConversion(Val, getULFractSema(), 0.25f);
1091
1092   CheckFixedToFloatConversion(Val, getS32Pos2(), 4294967552.0f);
1093
1094   Val = 0x7FF0ULL;
1095   CheckFixedToHalfConversion(Val, getAccumSema(), 0.99951171875f);
1096   CheckFixedToHalfConversion(Val, getLFractSema(), 0.000015251338481903076171875f);
1097
1098   CheckFixedToHalfConversion(Val, getUAccumSema(), 0.499755859375f);
1099   CheckFixedToHalfConversion(Val, getULFractSema(), 0.0000076256692409515380859375f);
1100
1101   CheckFixedToFloatConversion(Val, getS32Pos2(), 131008.0f);
1102 }
1103
1104 void CheckAdd(const APFixedPoint &Lhs, const APFixedPoint &Rhs,
1105               const APFixedPoint &Res) {
1106   bool Overflow = false;
1107   APFixedPoint Result = Lhs.add(Rhs, &Overflow);
1108   ASSERT_FALSE(Overflow);
1109   ASSERT_EQ(Result.getSemantics(), Res.getSemantics());
1110   ASSERT_EQ(Result, Res);
1111 }
1112
1113 void CheckAddOverflow(const APFixedPoint &Lhs, const APFixedPoint &Rhs) {
1114   bool Overflow = false;
1115   APFixedPoint Result = Lhs.add(Rhs, &Overflow);
1116   ASSERT_TRUE(Overflow);
1117 }
1118
1119 TEST(FixedPoint, add) {
1120   CheckAdd(APFixedPoint(1, getS32Pos2()), APFixedPoint(1, getS32Pos2()),
1121            APFixedPoint(2, getS32Pos2()));
1122   CheckAdd(APFixedPoint(1, getS16Neg18()), APFixedPoint(1, getS16Neg18()),
1123            APFixedPoint(2, getS16Neg18()));
1124   CheckAdd(APFixedPoint(1, getU8Neg10()), APFixedPoint(1, getU8Neg10()),
1125            APFixedPoint(2, getU8Neg10()));
1126   CheckAdd(APFixedPoint(1, getU8Pos4()), APFixedPoint(1, getU8Pos4()),
1127            APFixedPoint(2, getU8Pos4()));
1128
1129   CheckAdd(APFixedPoint(11, getS32Pos2()), APFixedPoint(1, getS32Pos2()),
1130            APFixedPoint(12, getS32Pos2()));
1131   CheckAdd(APFixedPoint(11, getS16Neg18()), APFixedPoint(1, getS16Neg18()),
1132            APFixedPoint(12, getS16Neg18()));
1133   CheckAdd(APFixedPoint(11, getU8Neg10()), APFixedPoint(1, getU8Neg10()),
1134            APFixedPoint(12, getU8Neg10()));
1135   CheckAdd(APFixedPoint(11, getU8Pos4()), APFixedPoint(1, getU8Pos4()),
1136            APFixedPoint(12, getU8Pos4()));
1137
1138   CheckAdd(APFixedPoint(11, getS32Pos2()), APFixedPoint(1, getS16Neg18()),
1139            APFixedPoint(11534337,
1140                         FixedPointSemantics(52, FixedPointSemantics::Lsb{-18},
1141                                             true, false, false)));
1142   CheckAdd(
1143       APFixedPoint(11, getU8Neg10()), APFixedPoint(-9472, getS16Neg18()),
1144       APFixedPoint(-6656, FixedPointSemantics(17, FixedPointSemantics::Lsb{-18},
1145                                               true, false, false)));
1146   CheckAddOverflow(
1147       APFixedPoint::getMax(getU8Neg10()), APFixedPoint::getMax(getS16Neg18()));
1148   CheckAdd(APFixedPoint::getMin(getU8Neg10()),
1149            APFixedPoint::getMin(getS16Neg18()),
1150            APFixedPoint::getMin(getS16Neg18())
1151                .convert(FixedPointSemantics(17, FixedPointSemantics::Lsb{-18},
1152                                             true, false, false)));
1153   CheckAddOverflow(APFixedPoint::getMin(getS32Pos2()),
1154                    APFixedPoint::getMin(getS16Neg18()));
1155 }
1156
1157 void CheckMul(const APFixedPoint &Lhs, const APFixedPoint &Rhs,
1158               const APFixedPoint &Res) {
1159   bool Overflow = false;
1160   APFixedPoint Result = Lhs.mul(Rhs, &Overflow);
1161   ASSERT_FALSE(Overflow);
1162   ASSERT_EQ(Result.getSemantics(), Res.getSemantics());
1163   ASSERT_EQ(Result, Res);
1164 }
1165
1166 void CheckMulOverflow(const APFixedPoint &Lhs, const APFixedPoint &Rhs) {
1167   bool Overflow = false;
1168   APFixedPoint Result = Lhs.mul(Rhs, &Overflow);
1169   ASSERT_TRUE(Overflow);
1170 }
1171
1172 TEST(FixedPoint, mul) {
1173   CheckMul(APFixedPoint(1, getS32Pos2()), APFixedPoint(1, getS32Pos2()),
1174            APFixedPoint(4, getS32Pos2()));
1175   CheckMul(APFixedPoint(1, getS16Neg18()), APFixedPoint(1, getS16Neg18()),
1176            APFixedPoint(0, getS16Neg18()));
1177   CheckMul(APFixedPoint(1, getU8Neg10()), APFixedPoint(1, getU8Neg10()),
1178            APFixedPoint(0, getU8Neg10()));
1179   CheckMul(APFixedPoint(1, getU8Pos4()), APFixedPoint(1, getU8Pos4()),
1180            APFixedPoint(16, getU8Pos4()));
1181
1182   CheckMul(APFixedPoint(11, getS32Pos2()), APFixedPoint(1, getS32Pos2()),
1183            APFixedPoint(44, getS32Pos2()));
1184   CheckMul(APFixedPoint(11, getS16Neg18()), APFixedPoint(1, getS16Neg18()),
1185            APFixedPoint(0, getS16Neg18()));
1186   CheckMul(APFixedPoint(11, getU8Neg10()), APFixedPoint(1, getU8Neg10()),
1187            APFixedPoint(0, getU8Neg10()));
1188   CheckMul(APFixedPoint(11, getU8Pos4()), APFixedPoint(1, getU8Pos4()),
1189            APFixedPoint(176, getU8Pos4()));
1190
1191   CheckMul(APFixedPoint(512, getS16Neg18()), APFixedPoint(512, getS16Neg18()),
1192            APFixedPoint(1, getS16Neg18()));
1193   CheckMul(APFixedPoint(32, getU8Neg10()), APFixedPoint(32, getU8Neg10()),
1194            APFixedPoint(1, getU8Neg10()));
1195
1196   CheckMul(APFixedPoint(11, getS32Pos2()), APFixedPoint(1, getS16Neg18()),
1197            APFixedPoint(44,
1198                         FixedPointSemantics(52, FixedPointSemantics::Lsb{-18},
1199                                             true, false, false)));
1200   CheckMul(
1201       APFixedPoint(11, getU8Neg10()), APFixedPoint(-9472, getS16Neg18()),
1202       APFixedPoint(-102, FixedPointSemantics(17, FixedPointSemantics::Lsb{-18},
1203                                              true, false, false)));
1204   CheckMul(
1205       APFixedPoint::getMax(getU8Neg10()), APFixedPoint::getMax(getS16Neg18()),
1206       APFixedPoint(8159, FixedPointSemantics(17, FixedPointSemantics::Lsb{-18},
1207                                              true, false, false)));
1208   CheckMul(
1209       APFixedPoint::getMin(getU8Neg10()), APFixedPoint::getMin(getS16Neg18()),
1210       APFixedPoint(0, FixedPointSemantics(17, FixedPointSemantics::Lsb{-18},
1211                                           true, false, false)));
1212   CheckMul(APFixedPoint::getMin(getS32Pos2()),
1213            APFixedPoint::getMin(getS16Neg18()),
1214            APFixedPoint(281474976710656,
1215                         FixedPointSemantics(52, FixedPointSemantics::Lsb{-18},
1216                                             true, false, false)));
1217   CheckMulOverflow(APFixedPoint::getMax(getS32Pos2()), APFixedPoint::getMax(getU8Pos4()));
1218   CheckMulOverflow(APFixedPoint::getMin(getS32Pos2()), APFixedPoint::getMax(getU8Pos4()));
1219 }
1220
1221 void CheckDiv(const APFixedPoint &Lhs, const APFixedPoint &Rhs,
1222               const APFixedPoint &Expected) {
1223   bool Overflow = false;
1224   APFixedPoint Result = Lhs.div(Rhs, &Overflow);
1225   ASSERT_FALSE(Overflow);
1226   ASSERT_EQ(Result.getSemantics(), Expected.getSemantics());
1227   ASSERT_EQ(Result, Expected);
1228 }
1229
1230 void CheckDivOverflow(const APFixedPoint &Lhs, const APFixedPoint &Rhs) {
1231   bool Overflow = false;
1232   APFixedPoint Result = Lhs.div(Rhs, &Overflow);
1233   ASSERT_TRUE(Overflow);
1234 }
1235
1236 TEST(FixedPoint, div) {
1237   CheckDiv(APFixedPoint(1, getS32Pos2()), APFixedPoint(1, getS32Pos2()),
1238            APFixedPoint(0, getS32Pos2()));
1239   CheckDivOverflow(APFixedPoint(1, getS16Neg18()), APFixedPoint(1, getS16Neg18()));
1240   CheckDivOverflow(APFixedPoint(1, getU8Neg10()), APFixedPoint(1, getU8Neg10()));
1241   CheckDiv(APFixedPoint(1, getU8Pos4()), APFixedPoint(1, getU8Pos4()),
1242            APFixedPoint(0, getU8Pos4()));
1243
1244   CheckDiv(APFixedPoint(11, getS32Pos2()), APFixedPoint(1, getS32Pos2()),
1245            APFixedPoint(2, getS32Pos2()));
1246   CheckDiv(APFixedPoint(11, getU8Pos4()), APFixedPoint(1, getU8Pos4()),
1247            APFixedPoint(0, getU8Pos4()));
1248
1249   CheckDiv(APFixedPoint(11, getS32Pos2()), APFixedPoint(1, getS16Neg18()),
1250            APFixedPoint(3023656976384,
1251                         FixedPointSemantics(52, FixedPointSemantics::Lsb{-18},
1252                                             true, false, false)));
1253   CheckDiv(APFixedPoint(11, getU8Neg10()), APFixedPoint(-11264, getS16Neg18()),
1254            APFixedPoint::getMin(FixedPointSemantics(
1255                17, FixedPointSemantics::Lsb{-18}, true, false, false)));
1256   CheckDiv(APFixedPoint(11, getU8Neg10()), APFixedPoint(11265, getS16Neg18()),
1257            APFixedPoint(0xfffa,
1258                         FixedPointSemantics(17, FixedPointSemantics::Lsb{-18},
1259                                             true, false, false)));
1260   CheckDivOverflow(APFixedPoint(11, getU8Neg10()),
1261                    APFixedPoint(11264, getS16Neg18()));
1262
1263   CheckDivOverflow(APFixedPoint(11, getU8Neg10()),
1264                    APFixedPoint(-9472, getS16Neg18()));
1265   CheckDivOverflow(APFixedPoint::getMax(getU8Neg10()),
1266                    APFixedPoint::getMax(getS16Neg18()));
1267   CheckDiv(
1268       APFixedPoint::getMin(getU8Neg10()), APFixedPoint::getMin(getS16Neg18()),
1269       APFixedPoint(0, FixedPointSemantics(17, FixedPointSemantics::Lsb{-18},
1270                                           true, false, false)));
1271   CheckDiv(
1272       APFixedPoint(1, getU8Neg10()), APFixedPoint::getMin(getS16Neg18()),
1273       APFixedPoint(-2048, FixedPointSemantics(17, FixedPointSemantics::Lsb{-18},
1274                                               true, false, false)));
1275 }
1276
1277 } // namespace