lib/Support/ScaledNumber.cpp

   1 //==- lib/Support/ScaledNumber.cpp - Support for scaled numbers -*- C++ -*-===//
   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 // Implementation of some scaled number algorithms.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "llvm/Support/ScaledNumber.h"
  15 #include "llvm/ADT/APFloat.h"
  16 #include "llvm/ADT/ArrayRef.h"
  17 #include "llvm/Support/Debug.h"
  18 #include "llvm/Support/raw_ostream.h"
  19
  20 using namespace llvm;
  21 using namespace llvm::ScaledNumbers;
  22
  23 std::pair<uint64_t, int16_t> ScaledNumbers::multiply64(uint64_t LHS,
  24                                                        uint64_t RHS) {
  25   // Separate into two 32-bit digits (U.L).
  26   auto getU = [](uint64_t N) { return N >> 32; };
  27   auto getL = [](uint64_t N) { return N & UINT32_MAX; };
  28   uint64_t UL = getU(LHS), LL = getL(LHS), UR = getU(RHS), LR = getL(RHS);
  29
  30   // Compute cross products.
  31   uint64_t P1 = UL * UR, P2 = UL * LR, P3 = LL * UR, P4 = LL * LR;
  32
  33   // Sum into two 64-bit digits.
  34   uint64_t Upper = P1, Lower = P4;
  35   auto addWithCarry = [&](uint64_t N) {
  36     uint64_t NewLower = Lower + (getL(N) << 32);
  37     Upper += getU(N) + (NewLower < Lower);
  38     Lower = NewLower;
  39   };
  40   addWithCarry(P2);
  41   addWithCarry(P3);
  42
  43   // Check whether the upper digit is empty.
  44   if (!Upper)
  45     return std::make_pair(Lower, 0);
  46
  47   // Shift as little as possible to maximize precision.
  48   unsigned LeadingZeros = countLeadingZeros(Upper);
  49   int Shift = 64 - LeadingZeros;
  50   if (LeadingZeros)
  51     Upper = Upper << LeadingZeros | Lower >> Shift;
  52   return getRounded(Upper, Shift,
  53                     Shift && (Lower & UINT64_C(1) << (Shift - 1)));
  54 }
  55
  56 static uint64_t getHalf(uint64_t N) { return (N >> 1) + (N & 1); }
  57
  58 std::pair<uint32_t, int16_t> ScaledNumbers::divide32(uint32_t Dividend,
  59                                                      uint32_t Divisor) {
  60   assert(Dividend && "expected non-zero dividend");
  61   assert(Divisor && "expected non-zero divisor");
  62
  63   // Use 64-bit math and canonicalize the dividend to gain precision.
  64   uint64_t Dividend64 = Dividend;
  65   int Shift = 0;
  66   if (int Zeros = countLeadingZeros(Dividend64)) {
  67     Shift -= Zeros;
  68     Dividend64 <<= Zeros;
  69   }
  70   uint64_t Quotient = Dividend64 / Divisor;
  71   uint64_t Remainder = Dividend64 % Divisor;
  72
  73   // If Quotient needs to be shifted, leave the rounding to getAdjusted().
  74   if (Quotient > UINT32_MAX)
  75     return getAdjusted<uint32_t>(Quotient, Shift);
  76
  77   // Round based on the value of the next bit.
  78   return getRounded<uint32_t>(Quotient, Shift, Remainder >= getHalf(Divisor));
  79 }
  80
  81 std::pair<uint64_t, int16_t> ScaledNumbers::divide64(uint64_t Dividend,
  82                                                      uint64_t Divisor) {
  83   assert(Dividend && "expected non-zero dividend");
  84   assert(Divisor && "expected non-zero divisor");
  85
  86   // Minimize size of divisor.
  87   int Shift = 0;
  88   if (int Zeros = countTrailingZeros(Divisor)) {
  89     Shift -= Zeros;
  90     Divisor >>= Zeros;
  91   }
  92
  93   // Check for powers of two.
  94   if (Divisor == 1)
  95     return std::make_pair(Dividend, Shift);
  96
  97   // Maximize size of dividend.
  98   if (int Zeros = countLeadingZeros(Dividend)) {
  99     Shift -= Zeros;
 100     Dividend <<= Zeros;
 101   }
 102
 103   // Start with the result of a divide.
 104   uint64_t Quotient = Dividend / Divisor;
 105   Dividend %= Divisor;
 106
 107   // Continue building the quotient with long division.
 108   while (!(Quotient >> 63) && Dividend) {
 109     // Shift Dividend and check for overflow.
 110     bool IsOverflow = Dividend >> 63;
 111     Dividend <<= 1;
 112     --Shift;
 113
 114     // Get the next bit of Quotient.
 115     Quotient <<= 1;
 116     if (IsOverflow || Divisor <= Dividend) {
 117       Quotient |= 1;
 118       Dividend -= Divisor;
 119     }
 120   }
 121
 122   return getRounded(Quotient, Shift, Dividend >= getHalf(Divisor));
 123 }
 124
 125 int ScaledNumbers::compareImpl(uint64_t L, uint64_t R, int ScaleDiff) {
 126   assert(ScaleDiff >= 0 && "wrong argument order");
 127   assert(ScaleDiff < 64 && "numbers too far apart");
 128
 129   uint64_t L_adjusted = L >> ScaleDiff;
 130   if (L_adjusted < R)
 131     return -1;
 132   if (L_adjusted > R)
 133     return 1;
 134
 135   return L > L_adjusted << ScaleDiff ? 1 : 0;
 136 }
 137
 138 static void appendDigit(std::string &Str, unsigned D) {
 139   assert(D < 10);
 140   Str += '0' + D % 10;
 141 }
 142
 143 static void appendNumber(std::string &Str, uint64_t N) {
 144   while (N) {
 145     appendDigit(Str, N % 10);
 146     N /= 10;
 147   }
 148 }
 149
 150 static bool doesRoundUp(char Digit) {
 151   switch (Digit) {
 152   case '5':
 153   case '6':
 154   case '7':
 155   case '8':
 156   case '9':
 157     return true;
 158   default:
 159     return false;
 160   }
 161 }
 162
 163 static std::string toStringAPFloat(uint64_t D, int E, unsigned Precision) {
 164   assert(E >= ScaledNumbers::MinScale);
 165   assert(E <= ScaledNumbers::MaxScale);
 166
 167   // Find a new E, but don't let it increase past MaxScale.
 168   int LeadingZeros = ScaledNumberBase::countLeadingZeros64(D);
 169   int NewE = std::min(ScaledNumbers::MaxScale, E + 63 - LeadingZeros);
 170   int Shift = 63 - (NewE - E);
 171   assert(Shift <= LeadingZeros);
 172   assert(Shift == LeadingZeros || NewE == ScaledNumbers::MaxScale);
 173   assert(Shift >= 0 && Shift < 64 && "undefined behavior");
 174   D <<= Shift;
 175   E = NewE;
 176
 177   // Check for a denormal.
 178   unsigned AdjustedE = E + 16383;
 179   if (!(D >> 63)) {
 180     assert(E == ScaledNumbers::MaxScale);
 181     AdjustedE = 0;
 182   }
 183
 184   // Build the float and print it.
 185   uint64_t RawBits[2] = {D, AdjustedE};
 186   APFloat Float(APFloat::x87DoubleExtended(), APInt(80, RawBits));
 187   SmallVector<char, 24> Chars;
 188   Float.toString(Chars, Precision, 0);
 189   return std::string(Chars.begin(), Chars.end());
 190 }
 191
 192 static std::string stripTrailingZeros(const std::string &Float) {
 193   size_t NonZero = Float.find_last_not_of('0');
 194   assert(NonZero != std::string::npos && "no . in floating point string");
 195
 196   if (Float[NonZero] == '.')
 197     ++NonZero;
 198
 199   return Float.substr(0, NonZero + 1);
 200 }
 201
 202 std::string ScaledNumberBase::toString(uint64_t D, int16_t E, int Width,
 203                                        unsigned Precision) {
 204   if (!D)
 205     return "0.0";
 206
 207   // Canonicalize exponent and digits.
 208   uint64_t Above0 = 0;
 209   uint64_t Below0 = 0;
 210   uint64_t Extra = 0;
 211   int ExtraShift = 0;
 212   if (E == 0) {
 213     Above0 = D;
 214   } else if (E > 0) {
 215     if (int Shift = std::min(int16_t(countLeadingZeros64(D)), E)) {
 216       D <<= Shift;
 217       E -= Shift;
 218
 219       if (!E)
 220         Above0 = D;
 221     }
 222   } else if (E > -64) {
 223     Above0 = D >> -E;
 224     Below0 = D << (64 + E);
 225   } else if (E == -64) {
 226     // Special case: shift by 64 bits is undefined behavior.
 227     Below0 = D;
 228   } else if (E > -120) {
 229     Below0 = D >> (-E - 64);
 230     Extra = D << (128 + E);
 231     ExtraShift = -64 - E;
 232   }
 233
 234   // Fall back on APFloat for very small and very large numbers.
 235   if (!Above0 && !Below0)
 236     return toStringAPFloat(D, E, Precision);
 237
 238   // Append the digits before the decimal.
 239   std::string Str;
 240   size_t DigitsOut = 0;
 241   if (Above0) {
 242     appendNumber(Str, Above0);
 243     DigitsOut = Str.size();
 244   } else
 245     appendDigit(Str, 0);
 246   std::reverse(Str.begin(), Str.end());
 247
 248   // Return early if there's nothing after the decimal.
 249   if (!Below0)
 250     return Str + ".0";
 251
 252   // Append the decimal and beyond.
 253   Str += '.';
 254   uint64_t Error = UINT64_C(1) << (64 - Width);
 255
 256   // We need to shift Below0 to the right to make space for calculating
 257   // digits.  Save the precision we're losing in Extra.
 258   Extra = (Below0 & 0xf) << 56 | (Extra >> 8);
 259   Below0 >>= 4;
 260   size_t SinceDot = 0;
 261   size_t AfterDot = Str.size();
 262   do {
 263     if (ExtraShift) {
 264       --ExtraShift;
 265       Error *= 5;
 266     } else
 267       Error *= 10;
 268
 269     Below0 *= 10;
 270     Extra *= 10;
 271     Below0 += (Extra >> 60);
 272     Extra = Extra & (UINT64_MAX >> 4);
 273     appendDigit(Str, Below0 >> 60);
 274     Below0 = Below0 & (UINT64_MAX >> 4);
 275     if (DigitsOut || Str.back() != '0')
 276       ++DigitsOut;
 277     ++SinceDot;
 278   } while (Error && (Below0 << 4 | Extra >> 60) >= Error / 2 &&
 279            (!Precision || DigitsOut <= Precision || SinceDot < 2));
 280
 281   // Return early for maximum precision.
 282   if (!Precision || DigitsOut <= Precision)
 283     return stripTrailingZeros(Str);
 284
 285   // Find where to truncate.
 286   size_t Truncate =
 287       std::max(Str.size() - (DigitsOut - Precision), AfterDot + 1);
 288
 289   // Check if there's anything to truncate.
 290   if (Truncate >= Str.size())
 291     return stripTrailingZeros(Str);
 292
 293   bool Carry = doesRoundUp(Str[Truncate]);
 294   if (!Carry)
 295     return stripTrailingZeros(Str.substr(0, Truncate));
 296
 297   // Round with the first truncated digit.
 298   for (std::string::reverse_iterator I(Str.begin() + Truncate), E = Str.rend();
 299        I != E; ++I) {
 300     if (*I == '.')
 301       continue;
 302     if (*I == '9') {
 303       *I = '0';
 304       continue;
 305     }
 306
 307     ++*I;
 308     Carry = false;
 309     break;
 310   }
 311
 312   // Add "1" in front if we still need to carry.
 313   return stripTrailingZeros(std::string(Carry, '1') + Str.substr(0, Truncate));
 314 }
 315
 316 raw_ostream &ScaledNumberBase::print(raw_ostream &OS, uint64_t D, int16_t E,
 317                                      int Width, unsigned Precision) {
 318   return OS << toString(D, E, Width, Precision);
 319 }
 320
 321 void ScaledNumberBase::dump(uint64_t D, int16_t E, int Width) {
 322   print(dbgs(), D, E, Width, 0) << "[" << Width << ":" << D << "*2^" << E
 323                                 << "]";
 324 }