llvm/unittests/Support/ScaledNumberTest.cpp

   1 //===- llvm/unittest/Support/ScaledNumberTest.cpp - ScaledPair 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/Support/ScaledNumber.h"
  10 #include "llvm/Support/DataTypes.h"
  11 #include "gtest/gtest.h"
  12
  13 using namespace llvm;
  14 using namespace llvm::ScaledNumbers;
  15
  16 namespace {
  17
  18 template <class UIntT> struct ScaledPair {
  19   UIntT D;
  20   int S;
  21   ScaledPair(const std::pair<UIntT, int16_t> &F) : D(F.first), S(F.second) {}
  22   ScaledPair(UIntT D, int S) : D(D), S(S) {}
  23
  24   bool operator==(const ScaledPair<UIntT> &X) const {
  25     return D == X.D && S == X.S;
  26   }
  27 };
  28 template <class UIntT>
  29 bool operator==(const std::pair<UIntT, int16_t> &L,
  30                 const ScaledPair<UIntT> &R) {
  31   return ScaledPair<UIntT>(L) == R;
  32 }
  33 template <class UIntT>
  34 void PrintTo(const ScaledPair<UIntT> &F, ::std::ostream *os) {
  35   *os << F.D << "*2^" << F.S;
  36 }
  37
  38 typedef ScaledPair<uint32_t> SP32;
  39 typedef ScaledPair<uint64_t> SP64;
  40
  41 TEST(ScaledNumberHelpersTest, getRounded) {
  42   EXPECT_EQ(getRounded32(0, 0, false), SP32(0, 0));
  43   EXPECT_EQ(getRounded32(0, 0, true), SP32(1, 0));
  44   EXPECT_EQ(getRounded32(20, 21, true), SP32(21, 21));
  45   EXPECT_EQ(getRounded32(UINT32_MAX, 0, false), SP32(UINT32_MAX, 0));
  46   EXPECT_EQ(getRounded32(UINT32_MAX, 0, true), SP32(1 << 31, 1));
  47
  48   EXPECT_EQ(getRounded64(0, 0, false), SP64(0, 0));
  49   EXPECT_EQ(getRounded64(0, 0, true), SP64(1, 0));
  50   EXPECT_EQ(getRounded64(20, 21, true), SP64(21, 21));
  51   EXPECT_EQ(getRounded64(UINT32_MAX, 0, false), SP64(UINT32_MAX, 0));
  52   EXPECT_EQ(getRounded64(UINT32_MAX, 0, true), SP64(UINT64_C(1) << 32, 0));
  53   EXPECT_EQ(getRounded64(UINT64_MAX, 0, false), SP64(UINT64_MAX, 0));
  54   EXPECT_EQ(getRounded64(UINT64_MAX, 0, true), SP64(UINT64_C(1) << 63, 1));
  55 }
  56
  57 TEST(ScaledNumberHelpersTest, getAdjusted) {
  58   const uint64_t Max32In64 = UINT32_MAX;
  59   EXPECT_EQ(getAdjusted32(0), SP32(0, 0));
  60   EXPECT_EQ(getAdjusted32(0, 5), SP32(0, 5));
  61   EXPECT_EQ(getAdjusted32(UINT32_MAX), SP32(UINT32_MAX, 0));
  62   EXPECT_EQ(getAdjusted32(Max32In64 << 1), SP32(UINT32_MAX, 1));
  63   EXPECT_EQ(getAdjusted32(Max32In64 << 1, 1), SP32(UINT32_MAX, 2));
  64   EXPECT_EQ(getAdjusted32(Max32In64 << 31), SP32(UINT32_MAX, 31));
  65   EXPECT_EQ(getAdjusted32(Max32In64 << 32), SP32(UINT32_MAX, 32));
  66   EXPECT_EQ(getAdjusted32(Max32In64 + 1), SP32(1u << 31, 1));
  67   EXPECT_EQ(getAdjusted32(UINT64_MAX), SP32(1u << 31, 33));
  68
  69   EXPECT_EQ(getAdjusted64(0), SP64(0, 0));
  70   EXPECT_EQ(getAdjusted64(0, 5), SP64(0, 5));
  71   EXPECT_EQ(getAdjusted64(UINT32_MAX), SP64(UINT32_MAX, 0));
  72   EXPECT_EQ(getAdjusted64(Max32In64 << 1), SP64(Max32In64 << 1, 0));
  73   EXPECT_EQ(getAdjusted64(Max32In64 << 1, 1), SP64(Max32In64 << 1, 1));
  74   EXPECT_EQ(getAdjusted64(Max32In64 << 31), SP64(Max32In64 << 31, 0));
  75   EXPECT_EQ(getAdjusted64(Max32In64 << 32), SP64(Max32In64 << 32, 0));
  76   EXPECT_EQ(getAdjusted64(Max32In64 + 1), SP64(Max32In64 + 1, 0));
  77   EXPECT_EQ(getAdjusted64(UINT64_MAX), SP64(UINT64_MAX, 0));
  78 }
  79
  80 TEST(ScaledNumberHelpersTest, getProduct) {
  81   // Zero.
  82   EXPECT_EQ(SP32(0, 0), getProduct32(0, 0));
  83   EXPECT_EQ(SP32(0, 0), getProduct32(0, 1));
  84   EXPECT_EQ(SP32(0, 0), getProduct32(0, 33));
  85
  86   // Basic.
  87   EXPECT_EQ(SP32(6, 0), getProduct32(2, 3));
  88   EXPECT_EQ(SP32(UINT16_MAX / 3 * UINT16_MAX / 5 * 2, 0),
  89             getProduct32(UINT16_MAX / 3, UINT16_MAX / 5 * 2));
  90
  91   // Overflow, no loss of precision.
  92   // ==> 0xf00010 * 0x1001
  93   // ==> 0xf00f00000 + 0x10010
  94   // ==> 0xf00f10010
  95   // ==> 0xf00f1001 * 2^4
  96   EXPECT_EQ(SP32(0xf00f1001, 4), getProduct32(0xf00010, 0x1001));
  97
  98   // Overflow, loss of precision, rounds down.
  99   // ==> 0xf000070 * 0x1001
 100   // ==> 0xf00f000000 + 0x70070
 101   // ==> 0xf00f070070
 102   // ==> 0xf00f0700 * 2^8
 103   EXPECT_EQ(SP32(0xf00f0700, 8), getProduct32(0xf000070, 0x1001));
 104
 105   // Overflow, loss of precision, rounds up.
 106   // ==> 0xf000080 * 0x1001
 107   // ==> 0xf00f000000 + 0x80080
 108   // ==> 0xf00f080080
 109   // ==> 0xf00f0801 * 2^8
 110   EXPECT_EQ(SP32(0xf00f0801, 8), getProduct32(0xf000080, 0x1001));
 111
 112   // Reverse operand order.
 113   EXPECT_EQ(SP32(0, 0), getProduct32(1, 0));
 114   EXPECT_EQ(SP32(0, 0), getProduct32(33, 0));
 115   EXPECT_EQ(SP32(6, 0), getProduct32(3, 2));
 116   EXPECT_EQ(SP32(UINT16_MAX / 3 * UINT16_MAX / 5 * 2, 0),
 117             getProduct32(UINT16_MAX / 5 * 2, UINT16_MAX / 3));
 118   EXPECT_EQ(SP32(0xf00f1001, 4), getProduct32(0x1001, 0xf00010));
 119   EXPECT_EQ(SP32(0xf00f0700, 8), getProduct32(0x1001, 0xf000070));
 120   EXPECT_EQ(SP32(0xf00f0801, 8), getProduct32(0x1001, 0xf000080));
 121
 122   // Round to overflow.
 123   EXPECT_EQ(SP64(UINT64_C(1) << 63, 64),
 124             getProduct64(UINT64_C(10376293541461622786),
 125                          UINT64_C(16397105843297379211)));
 126
 127   // Big number with rounding.
 128   EXPECT_EQ(SP64(UINT64_C(9223372036854775810), 64),
 129             getProduct64(UINT64_C(18446744073709551556),
 130                          UINT64_C(9223372036854775840)));
 131 }
 132
 133 TEST(ScaledNumberHelpersTest, getQuotient) {
 134   // Zero.
 135   EXPECT_EQ(SP32(0, 0), getQuotient32(0, 0));
 136   EXPECT_EQ(SP32(0, 0), getQuotient32(0, 1));
 137   EXPECT_EQ(SP32(0, 0), getQuotient32(0, 73));
 138   EXPECT_EQ(SP32(UINT32_MAX, MaxScale), getQuotient32(1, 0));
 139   EXPECT_EQ(SP32(UINT32_MAX, MaxScale), getQuotient32(6, 0));
 140
 141   // Powers of two.
 142   EXPECT_EQ(SP32(1u << 31, -31), getQuotient32(1, 1));
 143   EXPECT_EQ(SP32(1u << 31, -30), getQuotient32(2, 1));
 144   EXPECT_EQ(SP32(1u << 31, -33), getQuotient32(4, 16));
 145   EXPECT_EQ(SP32(7u << 29, -29), getQuotient32(7, 1));
 146   EXPECT_EQ(SP32(7u << 29, -30), getQuotient32(7, 2));
 147   EXPECT_EQ(SP32(7u << 29, -33), getQuotient32(7, 16));
 148
 149   // Divide evenly.
 150   EXPECT_EQ(SP32(3u << 30, -30), getQuotient32(9, 3));
 151   EXPECT_EQ(SP32(9u << 28, -28), getQuotient32(63, 7));
 152
 153   // Divide unevenly.
 154   EXPECT_EQ(SP32(0xaaaaaaab, -33), getQuotient32(1, 3));
 155   EXPECT_EQ(SP32(0xd5555555, -31), getQuotient32(5, 3));
 156
 157   // 64-bit division is hard to test, since divide64 doesn't canonicalize its
 158   // output.  However, this is the algorithm the implementation uses:
 159   //
 160   // - Shift divisor right.
 161   // - If we have 1 (power of 2), return early -- not canonicalized.
 162   // - Shift dividend left.
 163   // - 64-bit integer divide.
 164   // - If there's a remainder, continue with long division.
 165   //
 166   // TODO: require less knowledge about the implementation in the test.
 167
 168   // Zero.
 169   EXPECT_EQ(SP64(0, 0), getQuotient64(0, 0));
 170   EXPECT_EQ(SP64(0, 0), getQuotient64(0, 1));
 171   EXPECT_EQ(SP64(0, 0), getQuotient64(0, 73));
 172   EXPECT_EQ(SP64(UINT64_MAX, MaxScale), getQuotient64(1, 0));
 173   EXPECT_EQ(SP64(UINT64_MAX, MaxScale), getQuotient64(6, 0));
 174
 175   // Powers of two.
 176   EXPECT_EQ(SP64(1, 0), getQuotient64(1, 1));
 177   EXPECT_EQ(SP64(2, 0), getQuotient64(2, 1));
 178   EXPECT_EQ(SP64(4, -4), getQuotient64(4, 16));
 179   EXPECT_EQ(SP64(7, 0), getQuotient64(7, 1));
 180   EXPECT_EQ(SP64(7, -1), getQuotient64(7, 2));
 181   EXPECT_EQ(SP64(7, -4), getQuotient64(7, 16));
 182
 183   // Divide evenly.
 184   EXPECT_EQ(SP64(UINT64_C(3) << 60, -60), getQuotient64(9, 3));
 185   EXPECT_EQ(SP64(UINT64_C(9) << 58, -58), getQuotient64(63, 7));
 186
 187   // Divide unevenly.
 188   EXPECT_EQ(SP64(0xaaaaaaaaaaaaaaab, -65), getQuotient64(1, 3));
 189   EXPECT_EQ(SP64(0xd555555555555555, -63), getQuotient64(5, 3));
 190 }
 191
 192 TEST(ScaledNumberHelpersTest, getLg) {
 193   EXPECT_EQ(0, getLg(UINT32_C(1), 0));
 194   EXPECT_EQ(1, getLg(UINT32_C(1), 1));
 195   EXPECT_EQ(1, getLg(UINT32_C(2), 0));
 196   EXPECT_EQ(3, getLg(UINT32_C(1), 3));
 197   EXPECT_EQ(3, getLg(UINT32_C(7), 0));
 198   EXPECT_EQ(3, getLg(UINT32_C(8), 0));
 199   EXPECT_EQ(3, getLg(UINT32_C(9), 0));
 200   EXPECT_EQ(3, getLg(UINT32_C(64), -3));
 201   EXPECT_EQ(31, getLg((UINT32_MAX >> 1) + 2, 0));
 202   EXPECT_EQ(32, getLg(UINT32_MAX, 0));
 203   EXPECT_EQ(-1, getLg(UINT32_C(1), -1));
 204   EXPECT_EQ(-1, getLg(UINT32_C(2), -2));
 205   EXPECT_EQ(INT32_MIN, getLg(UINT32_C(0), -1));
 206   EXPECT_EQ(INT32_MIN, getLg(UINT32_C(0), 0));
 207   EXPECT_EQ(INT32_MIN, getLg(UINT32_C(0), 1));
 208
 209   EXPECT_EQ(0, getLg(UINT64_C(1), 0));
 210   EXPECT_EQ(1, getLg(UINT64_C(1), 1));
 211   EXPECT_EQ(1, getLg(UINT64_C(2), 0));
 212   EXPECT_EQ(3, getLg(UINT64_C(1), 3));
 213   EXPECT_EQ(3, getLg(UINT64_C(7), 0));
 214   EXPECT_EQ(3, getLg(UINT64_C(8), 0));
 215   EXPECT_EQ(3, getLg(UINT64_C(9), 0));
 216   EXPECT_EQ(3, getLg(UINT64_C(64), -3));
 217   EXPECT_EQ(63, getLg((UINT64_MAX >> 1) + 2, 0));
 218   EXPECT_EQ(64, getLg(UINT64_MAX, 0));
 219   EXPECT_EQ(-1, getLg(UINT64_C(1), -1));
 220   EXPECT_EQ(-1, getLg(UINT64_C(2), -2));
 221   EXPECT_EQ(INT32_MIN, getLg(UINT64_C(0), -1));
 222   EXPECT_EQ(INT32_MIN, getLg(UINT64_C(0), 0));
 223   EXPECT_EQ(INT32_MIN, getLg(UINT64_C(0), 1));
 224 }
 225
 226 TEST(ScaledNumberHelpersTest, getLgFloor) {
 227   EXPECT_EQ(0, getLgFloor(UINT32_C(1), 0));
 228   EXPECT_EQ(1, getLgFloor(UINT32_C(1), 1));
 229   EXPECT_EQ(1, getLgFloor(UINT32_C(2), 0));
 230   EXPECT_EQ(2, getLgFloor(UINT32_C(7), 0));
 231   EXPECT_EQ(3, getLgFloor(UINT32_C(1), 3));
 232   EXPECT_EQ(3, getLgFloor(UINT32_C(8), 0));
 233   EXPECT_EQ(3, getLgFloor(UINT32_C(9), 0));
 234   EXPECT_EQ(3, getLgFloor(UINT32_C(64), -3));
 235   EXPECT_EQ(31, getLgFloor((UINT32_MAX >> 1) + 2, 0));
 236   EXPECT_EQ(31, getLgFloor(UINT32_MAX, 0));
 237   EXPECT_EQ(INT32_MIN, getLgFloor(UINT32_C(0), -1));
 238   EXPECT_EQ(INT32_MIN, getLgFloor(UINT32_C(0), 0));
 239   EXPECT_EQ(INT32_MIN, getLgFloor(UINT32_C(0), 1));
 240
 241   EXPECT_EQ(0, getLgFloor(UINT64_C(1), 0));
 242   EXPECT_EQ(1, getLgFloor(UINT64_C(1), 1));
 243   EXPECT_EQ(1, getLgFloor(UINT64_C(2), 0));
 244   EXPECT_EQ(2, getLgFloor(UINT64_C(7), 0));
 245   EXPECT_EQ(3, getLgFloor(UINT64_C(1), 3));
 246   EXPECT_EQ(3, getLgFloor(UINT64_C(8), 0));
 247   EXPECT_EQ(3, getLgFloor(UINT64_C(9), 0));
 248   EXPECT_EQ(3, getLgFloor(UINT64_C(64), -3));
 249   EXPECT_EQ(63, getLgFloor((UINT64_MAX >> 1) + 2, 0));
 250   EXPECT_EQ(63, getLgFloor(UINT64_MAX, 0));
 251   EXPECT_EQ(INT32_MIN, getLgFloor(UINT64_C(0), -1));
 252   EXPECT_EQ(INT32_MIN, getLgFloor(UINT64_C(0), 0));
 253   EXPECT_EQ(INT32_MIN, getLgFloor(UINT64_C(0), 1));
 254 }
 255
 256 TEST(ScaledNumberHelpersTest, getLgCeiling) {
 257   EXPECT_EQ(0, getLgCeiling(UINT32_C(1), 0));
 258   EXPECT_EQ(1, getLgCeiling(UINT32_C(1), 1));
 259   EXPECT_EQ(1, getLgCeiling(UINT32_C(2), 0));
 260   EXPECT_EQ(3, getLgCeiling(UINT32_C(1), 3));
 261   EXPECT_EQ(3, getLgCeiling(UINT32_C(7), 0));
 262   EXPECT_EQ(3, getLgCeiling(UINT32_C(8), 0));
 263   EXPECT_EQ(3, getLgCeiling(UINT32_C(64), -3));
 264   EXPECT_EQ(4, getLgCeiling(UINT32_C(9), 0));
 265   EXPECT_EQ(32, getLgCeiling(UINT32_MAX, 0));
 266   EXPECT_EQ(32, getLgCeiling((UINT32_MAX >> 1) + 2, 0));
 267   EXPECT_EQ(INT32_MIN, getLgCeiling(UINT32_C(0), -1));
 268   EXPECT_EQ(INT32_MIN, getLgCeiling(UINT32_C(0), 0));
 269   EXPECT_EQ(INT32_MIN, getLgCeiling(UINT32_C(0), 1));
 270
 271   EXPECT_EQ(0, getLgCeiling(UINT64_C(1), 0));
 272   EXPECT_EQ(1, getLgCeiling(UINT64_C(1), 1));
 273   EXPECT_EQ(1, getLgCeiling(UINT64_C(2), 0));
 274   EXPECT_EQ(3, getLgCeiling(UINT64_C(1), 3));
 275   EXPECT_EQ(3, getLgCeiling(UINT64_C(7), 0));
 276   EXPECT_EQ(3, getLgCeiling(UINT64_C(8), 0));
 277   EXPECT_EQ(3, getLgCeiling(UINT64_C(64), -3));
 278   EXPECT_EQ(4, getLgCeiling(UINT64_C(9), 0));
 279   EXPECT_EQ(64, getLgCeiling((UINT64_MAX >> 1) + 2, 0));
 280   EXPECT_EQ(64, getLgCeiling(UINT64_MAX, 0));
 281   EXPECT_EQ(INT32_MIN, getLgCeiling(UINT64_C(0), -1));
 282   EXPECT_EQ(INT32_MIN, getLgCeiling(UINT64_C(0), 0));
 283   EXPECT_EQ(INT32_MIN, getLgCeiling(UINT64_C(0), 1));
 284 }
 285
 286 TEST(ScaledNumberHelpersTest, compare) {
 287   EXPECT_EQ(0, compare(UINT32_C(0), 0, UINT32_C(0), 1));
 288   EXPECT_EQ(0, compare(UINT32_C(0), 0, UINT32_C(0), -10));
 289   EXPECT_EQ(0, compare(UINT32_C(0), 0, UINT32_C(0), 20));
 290   EXPECT_EQ(0, compare(UINT32_C(8), 0, UINT32_C(64), -3));
 291   EXPECT_EQ(0, compare(UINT32_C(8), 0, UINT32_C(32), -2));
 292   EXPECT_EQ(0, compare(UINT32_C(8), 0, UINT32_C(16), -1));
 293   EXPECT_EQ(0, compare(UINT32_C(8), 0, UINT32_C(8), 0));
 294   EXPECT_EQ(0, compare(UINT32_C(8), 0, UINT32_C(4), 1));
 295   EXPECT_EQ(0, compare(UINT32_C(8), 0, UINT32_C(2), 2));
 296   EXPECT_EQ(0, compare(UINT32_C(8), 0, UINT32_C(1), 3));
 297   EXPECT_EQ(-1, compare(UINT32_C(0), 0, UINT32_C(1), 3));
 298   EXPECT_EQ(-1, compare(UINT32_C(7), 0, UINT32_C(1), 3));
 299   EXPECT_EQ(-1, compare(UINT32_C(7), 0, UINT32_C(64), -3));
 300   EXPECT_EQ(1, compare(UINT32_C(9), 0, UINT32_C(1), 3));
 301   EXPECT_EQ(1, compare(UINT32_C(9), 0, UINT32_C(64), -3));
 302   EXPECT_EQ(1, compare(UINT32_C(9), 0, UINT32_C(0), 0));
 303
 304   EXPECT_EQ(0, compare(UINT64_C(0), 0, UINT64_C(0), 1));
 305   EXPECT_EQ(0, compare(UINT64_C(0), 0, UINT64_C(0), -10));
 306   EXPECT_EQ(0, compare(UINT64_C(0), 0, UINT64_C(0), 20));
 307   EXPECT_EQ(0, compare(UINT64_C(8), 0, UINT64_C(64), -3));
 308   EXPECT_EQ(0, compare(UINT64_C(8), 0, UINT64_C(32), -2));
 309   EXPECT_EQ(0, compare(UINT64_C(8), 0, UINT64_C(16), -1));
 310   EXPECT_EQ(0, compare(UINT64_C(8), 0, UINT64_C(8), 0));
 311   EXPECT_EQ(0, compare(UINT64_C(8), 0, UINT64_C(4), 1));
 312   EXPECT_EQ(0, compare(UINT64_C(8), 0, UINT64_C(2), 2));
 313   EXPECT_EQ(0, compare(UINT64_C(8), 0, UINT64_C(1), 3));
 314   EXPECT_EQ(-1, compare(UINT64_C(0), 0, UINT64_C(1), 3));
 315   EXPECT_EQ(-1, compare(UINT64_C(7), 0, UINT64_C(1), 3));
 316   EXPECT_EQ(-1, compare(UINT64_C(7), 0, UINT64_C(64), -3));
 317   EXPECT_EQ(1, compare(UINT64_C(9), 0, UINT64_C(1), 3));
 318   EXPECT_EQ(1, compare(UINT64_C(9), 0, UINT64_C(64), -3));
 319   EXPECT_EQ(1, compare(UINT64_C(9), 0, UINT64_C(0), 0));
 320   EXPECT_EQ(-1, compare(UINT64_MAX, 0, UINT64_C(1), 64));
 321 }
 322
 323 TEST(ScaledNumberHelpersTest, matchScales) {
 324 #define MATCH_SCALES(T, LDIn, LSIn, RDIn, RSIn, LDOut, RDOut, SOut)            \
 325   do {                                                                         \
 326     T LDx = LDIn;                                                              \
 327     T RDx = RDIn;                                                              \
 328     T LDy = LDOut;                                                             \
 329     T RDy = RDOut;                                                             \
 330     int16_t LSx = LSIn;                                                        \
 331     int16_t RSx = RSIn;                                                        \
 332     int16_t Sy = SOut;                                                         \
 333                                                                                \
 334     EXPECT_EQ(SOut, matchScales(LDx, LSx, RDx, RSx));                          \
 335     EXPECT_EQ(LDy, LDx);                                                       \
 336     EXPECT_EQ(RDy, RDx);                                                       \
 337     if (LDy) {                                                                 \
 338       EXPECT_EQ(Sy, LSx);                                                      \
 339     }                                                                          \
 340     if (RDy) {                                                                 \
 341       EXPECT_EQ(Sy, RSx);                                                      \
 342     }                                                                          \
 343   } while (false)
 344
 345   MATCH_SCALES(uint32_t, 0, 0, 0, 0, 0, 0, 0);
 346   MATCH_SCALES(uint32_t, 0, 50, 7, 1, 0, 7, 1);
 347   MATCH_SCALES(uint32_t, UINT32_C(1) << 31, 1, 9, 0, UINT32_C(1) << 31, 4, 1);
 348   MATCH_SCALES(uint32_t, UINT32_C(1) << 31, 2, 9, 0, UINT32_C(1) << 31, 2, 2);
 349   MATCH_SCALES(uint32_t, UINT32_C(1) << 31, 3, 9, 0, UINT32_C(1) << 31, 1, 3);
 350   MATCH_SCALES(uint32_t, UINT32_C(1) << 31, 4, 9, 0, UINT32_C(1) << 31, 0, 4);
 351   MATCH_SCALES(uint32_t, UINT32_C(1) << 30, 4, 9, 0, UINT32_C(1) << 31, 1, 3);
 352   MATCH_SCALES(uint32_t, UINT32_C(1) << 29, 4, 9, 0, UINT32_C(1) << 31, 2, 2);
 353   MATCH_SCALES(uint32_t, UINT32_C(1) << 28, 4, 9, 0, UINT32_C(1) << 31, 4, 1);
 354   MATCH_SCALES(uint32_t, UINT32_C(1) << 27, 4, 9, 0, UINT32_C(1) << 31, 9, 0);
 355   MATCH_SCALES(uint32_t, 7, 1, 0, 50, 7, 0, 1);
 356   MATCH_SCALES(uint32_t, 9, 0, UINT32_C(1) << 31, 1, 4, UINT32_C(1) << 31, 1);
 357   MATCH_SCALES(uint32_t, 9, 0, UINT32_C(1) << 31, 2, 2, UINT32_C(1) << 31, 2);
 358   MATCH_SCALES(uint32_t, 9, 0, UINT32_C(1) << 31, 3, 1, UINT32_C(1) << 31, 3);
 359   MATCH_SCALES(uint32_t, 9, 0, UINT32_C(1) << 31, 4, 0, UINT32_C(1) << 31, 4);
 360   MATCH_SCALES(uint32_t, 9, 0, UINT32_C(1) << 30, 4, 1, UINT32_C(1) << 31, 3);
 361   MATCH_SCALES(uint32_t, 9, 0, UINT32_C(1) << 29, 4, 2, UINT32_C(1) << 31, 2);
 362   MATCH_SCALES(uint32_t, 9, 0, UINT32_C(1) << 28, 4, 4, UINT32_C(1) << 31, 1);
 363   MATCH_SCALES(uint32_t, 9, 0, UINT32_C(1) << 27, 4, 9, UINT32_C(1) << 31, 0);
 364
 365   MATCH_SCALES(uint64_t, 0, 0, 0, 0, 0, 0, 0);
 366   MATCH_SCALES(uint64_t, 0, 100, 7, 1, 0, 7, 1);
 367   MATCH_SCALES(uint64_t, UINT64_C(1) << 63, 1, 9, 0, UINT64_C(1) << 63, 4, 1);
 368   MATCH_SCALES(uint64_t, UINT64_C(1) << 63, 2, 9, 0, UINT64_C(1) << 63, 2, 2);
 369   MATCH_SCALES(uint64_t, UINT64_C(1) << 63, 3, 9, 0, UINT64_C(1) << 63, 1, 3);
 370   MATCH_SCALES(uint64_t, UINT64_C(1) << 63, 4, 9, 0, UINT64_C(1) << 63, 0, 4);
 371   MATCH_SCALES(uint64_t, UINT64_C(1) << 62, 4, 9, 0, UINT64_C(1) << 63, 1, 3);
 372   MATCH_SCALES(uint64_t, UINT64_C(1) << 61, 4, 9, 0, UINT64_C(1) << 63, 2, 2);
 373   MATCH_SCALES(uint64_t, UINT64_C(1) << 60, 4, 9, 0, UINT64_C(1) << 63, 4, 1);
 374   MATCH_SCALES(uint64_t, UINT64_C(1) << 59, 4, 9, 0, UINT64_C(1) << 63, 9, 0);
 375   MATCH_SCALES(uint64_t, 7, 1, 0, 100, 7, 0, 1);
 376   MATCH_SCALES(uint64_t, 9, 0, UINT64_C(1) << 63, 1, 4, UINT64_C(1) << 63, 1);
 377   MATCH_SCALES(uint64_t, 9, 0, UINT64_C(1) << 63, 2, 2, UINT64_C(1) << 63, 2);
 378   MATCH_SCALES(uint64_t, 9, 0, UINT64_C(1) << 63, 3, 1, UINT64_C(1) << 63, 3);
 379   MATCH_SCALES(uint64_t, 9, 0, UINT64_C(1) << 63, 4, 0, UINT64_C(1) << 63, 4);
 380   MATCH_SCALES(uint64_t, 9, 0, UINT64_C(1) << 62, 4, 1, UINT64_C(1) << 63, 3);
 381   MATCH_SCALES(uint64_t, 9, 0, UINT64_C(1) << 61, 4, 2, UINT64_C(1) << 63, 2);
 382   MATCH_SCALES(uint64_t, 9, 0, UINT64_C(1) << 60, 4, 4, UINT64_C(1) << 63, 1);
 383   MATCH_SCALES(uint64_t, 9, 0, UINT64_C(1) << 59, 4, 9, UINT64_C(1) << 63, 0);
 384 }
 385
 386 TEST(ScaledNumberHelpersTest, getSum) {
 387   // Zero.
 388   EXPECT_EQ(SP32(1, 0), getSum32(0, 0, 1, 0));
 389   EXPECT_EQ(SP32(8, -3), getSum32(0, 0, 8, -3));
 390   EXPECT_EQ(SP32(UINT32_MAX, 0), getSum32(0, 0, UINT32_MAX, 0));
 391
 392   // Basic.
 393   EXPECT_EQ(SP32(2, 0), getSum32(1, 0, 1, 0));
 394   EXPECT_EQ(SP32(3, 0), getSum32(1, 0, 2, 0));
 395   EXPECT_EQ(SP32(67, 0), getSum32(7, 0, 60, 0));
 396
 397   // Different scales.
 398   EXPECT_EQ(SP32(3, 0), getSum32(1, 0, 1, 1));
 399   EXPECT_EQ(SP32(4, 0), getSum32(2, 0, 1, 1));
 400
 401   // Loss of precision.
 402   EXPECT_EQ(SP32(UINT32_C(1) << 31, 1), getSum32(1, 32, 1, 0));
 403   EXPECT_EQ(SP32(UINT32_C(1) << 31, -31), getSum32(1, -32, 1, 0));
 404
 405   // Not quite loss of precision.
 406   EXPECT_EQ(SP32((UINT32_C(1) << 31) + 1, 1), getSum32(1, 32, 1, 1));
 407   EXPECT_EQ(SP32((UINT32_C(1) << 31) + 1, -32), getSum32(1, -32, 1, -1));
 408
 409   // Overflow.
 410   EXPECT_EQ(SP32(UINT32_C(1) << 31, 1), getSum32(1, 0, UINT32_MAX, 0));
 411
 412   // Reverse operand order.
 413   EXPECT_EQ(SP32(1, 0), getSum32(1, 0, 0, 0));
 414   EXPECT_EQ(SP32(8, -3), getSum32(8, -3, 0, 0));
 415   EXPECT_EQ(SP32(UINT32_MAX, 0), getSum32(UINT32_MAX, 0, 0, 0));
 416   EXPECT_EQ(SP32(3, 0), getSum32(2, 0, 1, 0));
 417   EXPECT_EQ(SP32(67, 0), getSum32(60, 0, 7, 0));
 418   EXPECT_EQ(SP32(3, 0), getSum32(1, 1, 1, 0));
 419   EXPECT_EQ(SP32(4, 0), getSum32(1, 1, 2, 0));
 420   EXPECT_EQ(SP32(UINT32_C(1) << 31, 1), getSum32(1, 0, 1, 32));
 421   EXPECT_EQ(SP32(UINT32_C(1) << 31, -31), getSum32(1, 0, 1, -32));
 422   EXPECT_EQ(SP32((UINT32_C(1) << 31) + 1, 1), getSum32(1, 1, 1, 32));
 423   EXPECT_EQ(SP32((UINT32_C(1) << 31) + 1, -32), getSum32(1, -1, 1, -32));
 424   EXPECT_EQ(SP32(UINT32_C(1) << 31, 1), getSum32(UINT32_MAX, 0, 1, 0));
 425
 426   // Zero.
 427   EXPECT_EQ(SP64(1, 0), getSum64(0, 0, 1, 0));
 428   EXPECT_EQ(SP64(8, -3), getSum64(0, 0, 8, -3));
 429   EXPECT_EQ(SP64(UINT64_MAX, 0), getSum64(0, 0, UINT64_MAX, 0));
 430
 431   // Basic.
 432   EXPECT_EQ(SP64(2, 0), getSum64(1, 0, 1, 0));
 433   EXPECT_EQ(SP64(3, 0), getSum64(1, 0, 2, 0));
 434   EXPECT_EQ(SP64(67, 0), getSum64(7, 0, 60, 0));
 435
 436   // Different scales.
 437   EXPECT_EQ(SP64(3, 0), getSum64(1, 0, 1, 1));
 438   EXPECT_EQ(SP64(4, 0), getSum64(2, 0, 1, 1));
 439
 440   // Loss of precision.
 441   EXPECT_EQ(SP64(UINT64_C(1) << 63, 1), getSum64(1, 64, 1, 0));
 442   EXPECT_EQ(SP64(UINT64_C(1) << 63, -63), getSum64(1, -64, 1, 0));
 443
 444   // Not quite loss of precision.
 445   EXPECT_EQ(SP64((UINT64_C(1) << 63) + 1, 1), getSum64(1, 64, 1, 1));
 446   EXPECT_EQ(SP64((UINT64_C(1) << 63) + 1, -64), getSum64(1, -64, 1, -1));
 447
 448   // Overflow.
 449   EXPECT_EQ(SP64(UINT64_C(1) << 63, 1), getSum64(1, 0, UINT64_MAX, 0));
 450
 451   // Reverse operand order.
 452   EXPECT_EQ(SP64(1, 0), getSum64(1, 0, 0, 0));
 453   EXPECT_EQ(SP64(8, -3), getSum64(8, -3, 0, 0));
 454   EXPECT_EQ(SP64(UINT64_MAX, 0), getSum64(UINT64_MAX, 0, 0, 0));
 455   EXPECT_EQ(SP64(3, 0), getSum64(2, 0, 1, 0));
 456   EXPECT_EQ(SP64(67, 0), getSum64(60, 0, 7, 0));
 457   EXPECT_EQ(SP64(3, 0), getSum64(1, 1, 1, 0));
 458   EXPECT_EQ(SP64(4, 0), getSum64(1, 1, 2, 0));
 459   EXPECT_EQ(SP64(UINT64_C(1) << 63, 1), getSum64(1, 0, 1, 64));
 460   EXPECT_EQ(SP64(UINT64_C(1) << 63, -63), getSum64(1, 0, 1, -64));
 461   EXPECT_EQ(SP64((UINT64_C(1) << 63) + 1, 1), getSum64(1, 1, 1, 64));
 462   EXPECT_EQ(SP64((UINT64_C(1) << 63) + 1, -64), getSum64(1, -1, 1, -64));
 463   EXPECT_EQ(SP64(UINT64_C(1) << 63, 1), getSum64(UINT64_MAX, 0, 1, 0));
 464 }
 465
 466 TEST(ScaledNumberHelpersTest, getDifference) {
 467   // Basic.
 468   EXPECT_EQ(SP32(0, 0), getDifference32(1, 0, 1, 0));
 469   EXPECT_EQ(SP32(1, 0), getDifference32(2, 0, 1, 0));
 470   EXPECT_EQ(SP32(53, 0), getDifference32(60, 0, 7, 0));
 471
 472   // Equals "0", different scales.
 473   EXPECT_EQ(SP32(0, 0), getDifference32(2, 0, 1, 1));
 474
 475   // Subtract "0".
 476   EXPECT_EQ(SP32(1, 0), getDifference32(1, 0, 0, 0));
 477   EXPECT_EQ(SP32(8, -3), getDifference32(8, -3, 0, 0));
 478   EXPECT_EQ(SP32(UINT32_MAX, 0), getDifference32(UINT32_MAX, 0, 0, 0));
 479
 480   // Loss of precision.
 481   EXPECT_EQ(SP32((UINT32_C(1) << 31) + 1, 1),
 482             getDifference32((UINT32_C(1) << 31) + 1, 1, 1, 0));
 483   EXPECT_EQ(SP32((UINT32_C(1) << 31) + 1, -31),
 484             getDifference32((UINT32_C(1) << 31) + 1, -31, 1, -32));
 485
 486   // Not quite loss of precision.
 487   EXPECT_EQ(SP32(UINT32_MAX, 0), getDifference32(1, 32, 1, 0));
 488   EXPECT_EQ(SP32(UINT32_MAX, -32), getDifference32(1, 0, 1, -32));
 489
 490   // Saturate to "0".
 491   EXPECT_EQ(SP32(0, 0), getDifference32(0, 0, 1, 0));
 492   EXPECT_EQ(SP32(0, 0), getDifference32(0, 0, 8, -3));
 493   EXPECT_EQ(SP32(0, 0), getDifference32(0, 0, UINT32_MAX, 0));
 494   EXPECT_EQ(SP32(0, 0), getDifference32(7, 0, 60, 0));
 495   EXPECT_EQ(SP32(0, 0), getDifference32(1, 0, 1, 1));
 496   EXPECT_EQ(SP32(0, 0), getDifference32(1, -32, 1, 0));
 497   EXPECT_EQ(SP32(0, 0), getDifference32(1, -32, 1, -1));
 498
 499   // Regression tests for cases that failed during bringup.
 500   EXPECT_EQ(SP32(UINT32_C(1) << 26, -31),
 501             getDifference32(1, 0, UINT32_C(31) << 27, -32));
 502
 503   // Basic.
 504   EXPECT_EQ(SP64(0, 0), getDifference64(1, 0, 1, 0));
 505   EXPECT_EQ(SP64(1, 0), getDifference64(2, 0, 1, 0));
 506   EXPECT_EQ(SP64(53, 0), getDifference64(60, 0, 7, 0));
 507
 508   // Equals "0", different scales.
 509   EXPECT_EQ(SP64(0, 0), getDifference64(2, 0, 1, 1));
 510
 511   // Subtract "0".
 512   EXPECT_EQ(SP64(1, 0), getDifference64(1, 0, 0, 0));
 513   EXPECT_EQ(SP64(8, -3), getDifference64(8, -3, 0, 0));
 514   EXPECT_EQ(SP64(UINT64_MAX, 0), getDifference64(UINT64_MAX, 0, 0, 0));
 515
 516   // Loss of precision.
 517   EXPECT_EQ(SP64((UINT64_C(1) << 63) + 1, 1),
 518             getDifference64((UINT64_C(1) << 63) + 1, 1, 1, 0));
 519   EXPECT_EQ(SP64((UINT64_C(1) << 63) + 1, -63),
 520             getDifference64((UINT64_C(1) << 63) + 1, -63, 1, -64));
 521
 522   // Not quite loss of precision.
 523   EXPECT_EQ(SP64(UINT64_MAX, 0), getDifference64(1, 64, 1, 0));
 524   EXPECT_EQ(SP64(UINT64_MAX, -64), getDifference64(1, 0, 1, -64));
 525
 526   // Saturate to "0".
 527   EXPECT_EQ(SP64(0, 0), getDifference64(0, 0, 1, 0));
 528   EXPECT_EQ(SP64(0, 0), getDifference64(0, 0, 8, -3));
 529   EXPECT_EQ(SP64(0, 0), getDifference64(0, 0, UINT64_MAX, 0));
 530   EXPECT_EQ(SP64(0, 0), getDifference64(7, 0, 60, 0));
 531   EXPECT_EQ(SP64(0, 0), getDifference64(1, 0, 1, 1));
 532   EXPECT_EQ(SP64(0, 0), getDifference64(1, -64, 1, 0));
 533   EXPECT_EQ(SP64(0, 0), getDifference64(1, -64, 1, -1));
 534 }
 535
 536 TEST(ScaledNumberHelpersTest, arithmeticOperators) {
 537   EXPECT_EQ(ScaledNumber<uint32_t>(10, 0),
 538             ScaledNumber<uint32_t>(1, 3) + ScaledNumber<uint32_t>(1, 1));
 539   EXPECT_EQ(ScaledNumber<uint32_t>(6, 0),
 540             ScaledNumber<uint32_t>(1, 3) - ScaledNumber<uint32_t>(1, 1));
 541   EXPECT_EQ(ScaledNumber<uint32_t>(2, 3),
 542             ScaledNumber<uint32_t>(1, 3) * ScaledNumber<uint32_t>(1, 1));
 543   EXPECT_EQ(ScaledNumber<uint32_t>(1, 2),
 544             ScaledNumber<uint32_t>(1, 3) / ScaledNumber<uint32_t>(1, 1));
 545   EXPECT_EQ(ScaledNumber<uint32_t>(1, 2), ScaledNumber<uint32_t>(1, 3) >> 1);
 546   EXPECT_EQ(ScaledNumber<uint32_t>(1, 4), ScaledNumber<uint32_t>(1, 3) << 1);
 547
 548   EXPECT_EQ(ScaledNumber<uint64_t>(10, 0),
 549             ScaledNumber<uint64_t>(1, 3) + ScaledNumber<uint64_t>(1, 1));
 550   EXPECT_EQ(ScaledNumber<uint64_t>(6, 0),
 551             ScaledNumber<uint64_t>(1, 3) - ScaledNumber<uint64_t>(1, 1));
 552   EXPECT_EQ(ScaledNumber<uint64_t>(2, 3),
 553             ScaledNumber<uint64_t>(1, 3) * ScaledNumber<uint64_t>(1, 1));
 554   EXPECT_EQ(ScaledNumber<uint64_t>(1, 2),
 555             ScaledNumber<uint64_t>(1, 3) / ScaledNumber<uint64_t>(1, 1));
 556   EXPECT_EQ(ScaledNumber<uint64_t>(1, 2), ScaledNumber<uint64_t>(1, 3) >> 1);
 557   EXPECT_EQ(ScaledNumber<uint64_t>(1, 4), ScaledNumber<uint64_t>(1, 3) << 1);
 558 }
 559
 560 TEST(ScaledNumberHelpersTest, toIntBug) {
 561   ScaledNumber<uint32_t> n(1, 0);
 562   EXPECT_EQ(1u, (n * n).toInt<uint32_t>());
 563 }
 564
 565 static_assert(std::is_trivially_copyable_v<ScaledNumber<uint32_t>>,
 566               "trivially copyable");
 567
 568 } // end namespace