Revert "Resubmit "Add support for advanced number formatting.""

This reverts commits 284436 and 284437 because they still break AArch64 bots:

Value of: format_number(-10, IntegerStyle::Integer, 1)
  Actual: "-0"
  Expected: "-10"

llvm-svn: 284462

1 files changed, 80 insertions, 309 deletions

diff --git a/llvm/lib/Support/NativeFormatting.cpp b/llvm/lib/Support/NativeFormatting.cpp
index 4bbd8cb9e07..9989488ddcc 100644
--- a/llvm/lib/Support/NativeFormatting.cpp
+++ b/llvm/lib/Support/NativeFormatting.cpp
@@ -9,252 +9,107 @@
 
 #include "llvm/Support/NativeFormatting.h"
 
-#include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/Support/Format.h"
 
 using namespace llvm;
 
-static bool isHexStyle(IntegerStyle S) {
-  switch (S) {
-  case IntegerStyle::HexLowerNoPrefix:
-  case IntegerStyle::HexLowerPrefix:
-  case IntegerStyle::HexUpperNoPrefix:
-  case IntegerStyle::HexUpperPrefix:
-    return true;
-  default:
-    return false;
-  }
-  LLVM_BUILTIN_UNREACHABLE;
-}
-
-static HexPrintStyle intHexStyleToHexStyle(IntegerStyle S) {
-  assert(isHexStyle(S));
-  switch (S) {
-  case IntegerStyle::HexLowerNoPrefix:
-    return HexPrintStyle::Lower;
-  case IntegerStyle::HexLowerPrefix:
-    return HexPrintStyle::PrefixLower;
-  case IntegerStyle::HexUpperNoPrefix:
-    return HexPrintStyle::Upper;
-  case IntegerStyle::HexUpperPrefix:
-    return HexPrintStyle::PrefixUpper;
-  default:
-    break;
-  }
-  LLVM_BUILTIN_UNREACHABLE;
-}
-
-static void writePadding(raw_ostream &S, Optional<int> FieldWidth,
-                         size_t Chars) {
-  if (!FieldWidth.hasValue())
-    return;
-
-  int Pad = *FieldWidth - Chars;
-  if (Pad > 0)
-    S.indent(Pad);
-}
-
 template<typename T, std::size_t N>
 static int format_to_buffer(T Value, char (&Buffer)[N]) {
   char *EndPtr = std::end(Buffer);
   char *CurPtr = EndPtr;
 
-  do {
+  while (Value) {
     *--CurPtr = '0' + char(Value % 10);
     Value /= 10;
-  } while (Value);
-  return EndPtr - CurPtr;
-}
-
-static void repeat_char(raw_ostream &S, char C, size_t Times) {
-  for (size_t I = 0; I < Times; ++I)
-    S << C;
-}
-
-static void writeWithCommas(raw_ostream &S, ArrayRef<char> Buffer) {
-  assert(!Buffer.empty());
-
-  ArrayRef<char> ThisGroup;
-  int InitialDigits = ((Buffer.size() - 1) % 3) + 1;
-  ThisGroup = Buffer.take_front(InitialDigits);
-  S.write(ThisGroup.data(), ThisGroup.size());
-
-  Buffer = Buffer.drop_front(InitialDigits);
-  assert(Buffer.size() % 3 == 0);
-  while (!Buffer.empty()) {
-    S << ',';
-    ThisGroup = Buffer.take_front(3);
-    S.write(ThisGroup.data(), 3);
-    Buffer = Buffer.drop_front(3);
   }
+  return EndPtr - CurPtr;
 }
 
-template <typename T>
-static void write_unsigned_impl(raw_ostream &S, T N, IntegerStyle Style,
-                                Optional<size_t> Precision, Optional<int> Width,
-                                bool IsNegative) {
-  static_assert(std::is_unsigned<T>::value, "Value is not unsigned!");
-
-  if (Style == IntegerStyle::Exponent) {
-    write_double(S, static_cast<double>(N), FloatStyle::Exponent, Precision,
-                 Width);
-    return;
-  } else if (Style == IntegerStyle::ExponentUpper) {
-    write_double(S, static_cast<double>(N), FloatStyle::ExponentUpper,
-                 Precision, Width);
-    return;
-  } else if (isHexStyle(Style)) {
-    write_hex(S, N, intHexStyleToHexStyle(Style), Precision, Width);
+void llvm::write_ulong(raw_ostream &S, unsigned long N, std::size_t MinWidth) {
+  // Zero is a special case.
+  if (N == 0) {
+    if (MinWidth > 0)
+      S.indent(MinWidth - 1);
+    S << '0';
     return;
   }
 
-  size_t Prec = Precision.getValueOr(getDefaultPrecision(Style));
-  char NumberBuffer[128];
-  std::memset(NumberBuffer, '0', sizeof(NumberBuffer));
-
-  size_t Len = 0;
-  Len = format_to_buffer(N, NumberBuffer);
-
-  bool WriteDecimal =
-      ((Style == IntegerStyle::Fixed || Style == IntegerStyle::Percent) &&
-       Prec > 0);
-
-  size_t LeadingZeros = 0;
-  if ((Style == IntegerStyle::Integer || Style == IntegerStyle::Number) &&
-      Prec > 0) {
-    if (Prec > Len)
-      LeadingZeros = Prec - Len;
-  }
-
-  Len += LeadingZeros;
-
-  // One for the decimal sign, one for each point of precision.
-  size_t DecimalChars = WriteDecimal ? 1 + Prec : 0;
-
-  // One character for the negative sign.
-  size_t Neg = (IsNegative) ? 1 : 0;
-
-  // One comma for each group of 3 digits.
-  size_t Commas = (Style != IntegerStyle::Number) ? 0 : (Len - 1) / 3;
-
-  size_t PercentChars = 0;
-  if (Style == IntegerStyle::Percent) {
-    // For all numbers except 0, we append two additional 0s.
-    PercentChars = (N == 0) ? 1 : 3;
-  }
-
-  writePadding(S, Width, Len + DecimalChars + Neg + Commas + PercentChars);
-
-  if (IsNegative)
-    S << '-';
-  if (Style == IntegerStyle::Number) {
-    writeWithCommas(S, ArrayRef<char>(std::end(NumberBuffer) - Len, Len));
-  } else {
-    S.write(std::end(NumberBuffer) - Len, Len);
-    if (Style == IntegerStyle::Percent && N != 0) {
-      // Rather than multiply by 100, write the characters manually, in case the
-      // multiplication would overflow.
-      S << "00";
-    }
-  }
-
-  if (WriteDecimal) {
-    S << '.';
-    repeat_char(S, '0', Prec);
-  }
-  if (Style == IntegerStyle::Percent)
-    S << '%';
-}
-
-template <typename T>
-static void write_unsigned(raw_ostream &S, T N, IntegerStyle Style,
-                           Optional<size_t> Precision, Optional<int> Width,
-                           bool IsNegative = false) {
-  // Output using 32-bit div/mod if possible.
-  if (N == static_cast<uint32_t>(N))
-    write_unsigned_impl(S, static_cast<uint32_t>(N), Style, Precision, Width,
-                        IsNegative);
-  else
-    write_unsigned_impl(S, N, Style, Precision, Width, IsNegative);
+  char NumberBuffer[20];
+  int Len = format_to_buffer(N, NumberBuffer);
+  int Pad = (MinWidth == 0) ? 0 : MinWidth - Len;
+  if (Pad > 0)
+    S.indent(Pad);
+  S.write(std::end(NumberBuffer) - Len, Len);
 }
 
-template <typename T>
-static void write_signed(raw_ostream &S, T N, IntegerStyle Style,
-                         Optional<size_t> Precision, Optional<int> Width) {
-  static_assert(std::is_signed<T>::value, "Value is not signed!");
-
-  using UnsignedT = typename std::make_unsigned<T>::type;
-
+void llvm::write_long(raw_ostream &S, long N, std::size_t MinWidth) {
   if (N >= 0) {
-    write_unsigned(S, static_cast<UnsignedT>(N), Style, Precision, Width);
+    write_ulong(S, static_cast<unsigned long>(N), MinWidth);
     return;
   }
 
-  UnsignedT UN = -(UnsignedT)N;
-  if (isHexStyle(Style)) {
-    static_assert(sizeof(UnsignedT) == sizeof(T),
-                  "Types do not have the same size!");
-    std::memcpy(&UN, &N, sizeof(N));
-    write_hex(S, UN, intHexStyleToHexStyle(Style), Precision, Width);
-    return;
-  }
-  write_unsigned(S, UN, Style, Precision, Width, true);
-}
+  unsigned long UN = -(unsigned long)N;
+  if (MinWidth > 0)
+    --MinWidth;
 
-void llvm::write_integer(raw_ostream &S, unsigned int N, IntegerStyle Style,
-                         Optional<size_t> Precision, Optional<int> Width) {
-  write_unsigned(S, N, Style, Precision, Width);
+  char NumberBuffer[20];
+  int Len = format_to_buffer(UN, NumberBuffer);
+  int Pad = (MinWidth == 0) ? 0 : MinWidth - Len;
+  if (Pad > 0)
+    S.indent(Pad);
+  S.write('-');
+  S.write(std::end(NumberBuffer) - Len, Len);
 }
 
-void llvm::write_integer(raw_ostream &S, int N, IntegerStyle Style,
-                         Optional<size_t> Precision, Optional<int> Width) {
-  write_signed(S, N, Style, Precision, Width);
-}
+void llvm::write_ulonglong(raw_ostream &S, unsigned long long N,
+                           std::size_t MinWidth) {
+  // Output using 32-bit div/mod when possible.
+  if (N == static_cast<unsigned long>(N)) {
+    write_ulong(S, static_cast<unsigned long>(N), MinWidth);
+    return;
+  }
 
-void llvm::write_integer(raw_ostream &S, unsigned long N, IntegerStyle Style,
-                         Optional<size_t> Precision, Optional<int> Width) {
-  write_unsigned(S, N, Style, Precision, Width);
+  char NumberBuffer[32];
+  int Len = format_to_buffer(N, NumberBuffer);
+  int Pad = (MinWidth == 0) ? 0 : MinWidth - Len;
+  if (Pad > 0)
+    S.indent(Pad);
+  S.write(std::end(NumberBuffer) - Len, Len);
 }
 
-void llvm::write_integer(raw_ostream &S, long N, IntegerStyle Style,
-                         Optional<size_t> Precision, Optional<int> Width) {
-  write_signed(S, N, Style, Precision, Width);
-}
+void llvm::write_longlong(raw_ostream &S, long long N, std::size_t MinWidth) {
+  if (N >= 0) {
+    write_ulonglong(S, static_cast<unsigned long long>(N), MinWidth);
+    return;
+  }
 
-void llvm::write_integer(raw_ostream &S, unsigned long long N,
-                         IntegerStyle Style, Optional<size_t> Precision,
-                         Optional<int> Width) {
-  write_unsigned(S, N, Style, Precision, Width);
-}
+  // Avoid undefined behavior on INT64_MIN with a cast.
+  unsigned long long UN = -(unsigned long long)N;
+  if (MinWidth > 0)
+    --MinWidth;
 
-void llvm::write_integer(raw_ostream &S, long long N, IntegerStyle Style,
-                         Optional<size_t> Precision, Optional<int> Width) {
-  write_signed(S, N, Style, Precision, Width);
+  char NumberBuffer[32];
+  int Len = format_to_buffer(UN, NumberBuffer);
+  int Pad = (MinWidth == 0) ? 0 : MinWidth - Len;
+  if (Pad > 0)
+    S.indent(Pad);
+  S.write('-');
+  S.write(std::end(NumberBuffer) - Len, Len);
 }
 
-void llvm::write_hex(raw_ostream &S, uint64_t N, HexPrintStyle Style,
-                     Optional<size_t> Precision, Optional<int> Width) {
-  const size_t kMaxWidth = 128u;
-
-  size_t Prec =
-      std::min(kMaxWidth, Precision.getValueOr(getDefaultPrecision(Style)));
-
+void llvm::write_hex(raw_ostream &S, unsigned long long N, std::size_t MinWidth,
+                     bool Upper, bool Prefix) {
   unsigned Nibbles = (64 - countLeadingZeros(N) + 3) / 4;
-  bool Prefix = (Style == HexPrintStyle::PrefixLower ||
-                 Style == HexPrintStyle::PrefixUpper);
-  bool Upper =
-      (Style == HexPrintStyle::Upper || Style == HexPrintStyle::PrefixUpper);
   unsigned PrefixChars = Prefix ? 2 : 0;
-  unsigned NumChars = std::max(static_cast<unsigned>(Prec),
-                               std::max(1u, Nibbles) + PrefixChars);
+  unsigned Width = std::max(static_cast<unsigned>(MinWidth),
+                            std::max(1u, Nibbles) + PrefixChars);
 
-  char NumberBuffer[kMaxWidth];
-  ::memset(NumberBuffer, '0', llvm::array_lengthof(NumberBuffer));
-  if (Prefix)
-    NumberBuffer[1] = 'x';
-  char *EndPtr = NumberBuffer + NumChars;
+  char NumberBuffer[20] = "0x0000000000000000";
+  if (!Prefix)
+    NumberBuffer[1] = '0';
+  char *EndPtr = NumberBuffer + Width;
   char *CurPtr = EndPtr;
   while (N) {
     unsigned char x = static_cast<unsigned char>(N) % 16;
@@ -262,37 +117,22 @@ void llvm::write_hex(raw_ostream &S, uint64_t N, HexPrintStyle Style,
     N /= 16;
   }
 
-  writePadding(S, Width, NumChars);
-  S.write(NumberBuffer, NumChars);
+  S.write(NumberBuffer, Width);
 }
 
-void llvm::write_double(raw_ostream &S, double N, FloatStyle Style,
-                        Optional<size_t> Precision, Optional<int> Width) {
-  size_t Prec = Precision.getValueOr(getDefaultPrecision(Style));
-
-  if (std::isnan(N)) {
-    writePadding(S, Width, 3);
-    S << "nan";
-    return;
-  } else if (std::isinf(N)) {
-    writePadding(S, Width, 3);
-    S << "INF";
-    return;
-  }
-
-  char Letter;
-  if (Style == FloatStyle::Exponent)
-    Letter = 'e';
-  else if (Style == FloatStyle::ExponentUpper)
-    Letter = 'E';
-  else
-    Letter = 'f';
-
+void llvm::write_double(raw_ostream &S, double N, std::size_t MinWidth,
+                        std::size_t MinDecimals, FloatStyle Style) {
+  char Letter = (Style == FloatStyle::Exponent) ? 'e' : 'f';
   SmallString<8> Spec;
   llvm::raw_svector_ostream Out(Spec);
-  Out << "%." << Prec << Letter;
-
-  if (Style == FloatStyle::Exponent || Style == FloatStyle::ExponentUpper) {
+  Out << '%';
+  if (MinWidth > 0)
+    Out << MinWidth;
+  if (MinDecimals > 0)
+    Out << '.' << MinDecimals;
+  Out << Letter;
+
+  if (Style == FloatStyle::Exponent) {
 #ifdef _WIN32
 // On MSVCRT and compatible, output of %e is incompatible to Posix
 // by default. Number of exponent digits should be at least 2. "%+03d"
@@ -300,9 +140,7 @@ void llvm::write_double(raw_ostream &S, double N, FloatStyle Style,
 #if defined(__MINGW32__)
     // FIXME: It should be generic to C++11.
     if (N == 0.0 && std::signbit(N)) {
-      const char *NegativeZero = "-0.000000e+00";
-      writePadding(S, Width, strlen(NegativeZero));
-      S << NegativeZero;
+      S << "-0.000000e+00";
       return;
     }
 #else
@@ -310,19 +148,16 @@ void llvm::write_double(raw_ostream &S, double N, FloatStyle Style,
 
     // negative zero
     if (fpcl == _FPCLASS_NZ) {
-      const char *NegativeZero = "-0.000000e+00";
-      writePadding(S, Width, strlen(NegativeZero));
-      S << NegativeZero;
+      S << "-0.000000e+00";
       return;
     }
 #endif
 
-    char buf[32];
+    char buf[16];
     unsigned len;
     len = format(Spec.c_str(), N).snprint(buf, sizeof(buf));
     if (len <= sizeof(buf) - 2) {
-      if (len >= 5 && (buf[len - 5] == 'e' || buf[len - 5] == 'E') &&
-          buf[len - 3] == '0') {
+      if (len >= 5 && buf[len - 5] == 'e' && buf[len - 3] == '0') {
         int cs = buf[len - 4];
         if (cs == '+' || cs == '-') {
           int c1 = buf[len - 2];
@@ -336,75 +171,11 @@ void llvm::write_double(raw_ostream &S, double N, FloatStyle Style,
           }
         }
       }
-      writePadding(S, Width, len);
       S << buf;
       return;
     }
 #endif
   }
 
-  if (Style == FloatStyle::Percent)
-    N *= 100.0;
-
-  char Buf[32];
-  unsigned Len;
-  Len = format(Spec.c_str(), N).snprint(Buf, sizeof(Buf));
-  if (Style == FloatStyle::Percent)
-    ++Len;
-  writePadding(S, Width, Len);
-  S << Buf;
-  if (Style == FloatStyle::Percent)
-    S << '%';
-}
-
-IntegerStyle llvm::hexStyleToIntHexStyle(HexPrintStyle S) {
-  switch (S) {
-  case HexPrintStyle::Upper:
-    return IntegerStyle::HexUpperNoPrefix;
-  case HexPrintStyle::Lower:
-    return IntegerStyle::HexLowerNoPrefix;
-  case HexPrintStyle::PrefixUpper:
-    return IntegerStyle::HexUpperPrefix;
-  case HexPrintStyle::PrefixLower:
-    return IntegerStyle::HexLowerPrefix;
-  }
-  LLVM_BUILTIN_UNREACHABLE;
-}
-
-size_t llvm::getDefaultPrecision(FloatStyle Style) {
-  switch (Style) {
-  case FloatStyle::Exponent:
-  case FloatStyle::ExponentUpper:
-    return 6; // Number of decimal places.
-  case FloatStyle::Fixed:
-  case FloatStyle::Percent:
-    return 2; // Number of decimal places.
-  }
-  LLVM_BUILTIN_UNREACHABLE;
-}
-
-size_t llvm::getDefaultPrecision(IntegerStyle Style) {
-  switch (Style) {
-  case IntegerStyle::Exponent:
-  case IntegerStyle::ExponentUpper:
-    return 6; // Number of decimal places.
-  case IntegerStyle::Number:
-  case IntegerStyle::Integer:
-    return 0; // Minimum number of digits required.
-  case IntegerStyle::Fixed:
-    return 2; // Number of decimal places.
-  case IntegerStyle::Percent:
-    return 0; // Number of decimal places.
-  case IntegerStyle::HexLowerNoPrefix:
-  case IntegerStyle::HexLowerPrefix:
-  case IntegerStyle::HexUpperNoPrefix:
-  case IntegerStyle::HexUpperPrefix:
-    return getDefaultPrecision(intHexStyleToHexStyle(Style));
-  }
-  LLVM_BUILTIN_UNREACHABLE;
-}
-
-size_t llvm::getDefaultPrecision(HexPrintStyle) {
-  // Number of digits in the resulting string.
-  return 0;
+  S << format(Spec.c_str(), N);
 }