LLVM  7.0.0svn
NativeFormatting.cpp
Go to the documentation of this file.
1 //===- NativeFormatting.cpp - Low level formatting helpers -------*- 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 
11 
12 #include "llvm/ADT/ArrayRef.h"
13 #include "llvm/ADT/SmallString.h"
14 #include "llvm/ADT/StringExtras.h"
15 #include "llvm/Support/Format.h"
16 
17 #include <float.h>
18 
19 using namespace llvm;
20 
21 template<typename T, std::size_t N>
22 static int format_to_buffer(T Value, char (&Buffer)[N]) {
23  char *EndPtr = std::end(Buffer);
24  char *CurPtr = EndPtr;
25 
26  do {
27  *--CurPtr = '0' + char(Value % 10);
28  Value /= 10;
29  } while (Value);
30  return EndPtr - CurPtr;
31 }
32 
33 static void writeWithCommas(raw_ostream &S, ArrayRef<char> Buffer) {
34  assert(!Buffer.empty());
35 
36  ArrayRef<char> ThisGroup;
37  int InitialDigits = ((Buffer.size() - 1) % 3) + 1;
38  ThisGroup = Buffer.take_front(InitialDigits);
39  S.write(ThisGroup.data(), ThisGroup.size());
40 
41  Buffer = Buffer.drop_front(InitialDigits);
42  assert(Buffer.size() % 3 == 0);
43  while (!Buffer.empty()) {
44  S << ',';
45  ThisGroup = Buffer.take_front(3);
46  S.write(ThisGroup.data(), 3);
47  Buffer = Buffer.drop_front(3);
48  }
49 }
50 
51 template <typename T>
52 static void write_unsigned_impl(raw_ostream &S, T N, size_t MinDigits,
53  IntegerStyle Style, bool IsNegative) {
54  static_assert(std::is_unsigned<T>::value, "Value is not unsigned!");
55 
56  char NumberBuffer[128];
57  std::memset(NumberBuffer, '0', sizeof(NumberBuffer));
58 
59  size_t Len = 0;
60  Len = format_to_buffer(N, NumberBuffer);
61 
62  if (IsNegative)
63  S << '-';
64 
65  if (Len < MinDigits && Style != IntegerStyle::Number) {
66  for (size_t I = Len; I < MinDigits; ++I)
67  S << '0';
68  }
69 
70  if (Style == IntegerStyle::Number) {
71  writeWithCommas(S, ArrayRef<char>(std::end(NumberBuffer) - Len, Len));
72  } else {
73  S.write(std::end(NumberBuffer) - Len, Len);
74  }
75 }
76 
77 template <typename T>
78 static void write_unsigned(raw_ostream &S, T N, size_t MinDigits,
79  IntegerStyle Style, bool IsNegative = false) {
80  // Output using 32-bit div/mod if possible.
81  if (N == static_cast<uint32_t>(N))
82  write_unsigned_impl(S, static_cast<uint32_t>(N), MinDigits, Style,
83  IsNegative);
84  else
85  write_unsigned_impl(S, N, MinDigits, Style, IsNegative);
86 }
87 
88 template <typename T>
89 static void write_signed(raw_ostream &S, T N, size_t MinDigits,
91  static_assert(std::is_signed<T>::value, "Value is not signed!");
92 
93  using UnsignedT = typename std::make_unsigned<T>::type;
94 
95  if (N >= 0) {
96  write_unsigned(S, static_cast<UnsignedT>(N), MinDigits, Style);
97  return;
98  }
99 
100  UnsignedT UN = -(UnsignedT)N;
101  write_unsigned(S, UN, MinDigits, Style, true);
102 }
103 
104 void llvm::write_integer(raw_ostream &S, unsigned int N, size_t MinDigits,
106  write_unsigned(S, N, MinDigits, Style);
107 }
108 
109 void llvm::write_integer(raw_ostream &S, int N, size_t MinDigits,
111  write_signed(S, N, MinDigits, Style);
112 }
113 
114 void llvm::write_integer(raw_ostream &S, unsigned long N, size_t MinDigits,
116  write_unsigned(S, N, MinDigits, Style);
117 }
118 
119 void llvm::write_integer(raw_ostream &S, long N, size_t MinDigits,
121  write_signed(S, N, MinDigits, Style);
122 }
123 
124 void llvm::write_integer(raw_ostream &S, unsigned long long N, size_t MinDigits,
126  write_unsigned(S, N, MinDigits, Style);
127 }
128 
129 void llvm::write_integer(raw_ostream &S, long long N, size_t MinDigits,
131  write_signed(S, N, MinDigits, Style);
132 }
133 
135  Optional<size_t> Width) {
136  const size_t kMaxWidth = 128u;
137 
138  size_t W = std::min(kMaxWidth, Width.getValueOr(0u));
139 
140  unsigned Nibbles = (64 - countLeadingZeros(N) + 3) / 4;
141  bool Prefix = (Style == HexPrintStyle::PrefixLower ||
142  Style == HexPrintStyle::PrefixUpper);
143  bool Upper =
144  (Style == HexPrintStyle::Upper || Style == HexPrintStyle::PrefixUpper);
145  unsigned PrefixChars = Prefix ? 2 : 0;
146  unsigned NumChars =
147  std::max(static_cast<unsigned>(W), std::max(1u, Nibbles) + PrefixChars);
148 
149  char NumberBuffer[kMaxWidth];
150  ::memset(NumberBuffer, '0', llvm::array_lengthof(NumberBuffer));
151  if (Prefix)
152  NumberBuffer[1] = 'x';
153  char *EndPtr = NumberBuffer + NumChars;
154  char *CurPtr = EndPtr;
155  while (N) {
156  unsigned char x = static_cast<unsigned char>(N) % 16;
157  *--CurPtr = hexdigit(x, !Upper);
158  N /= 16;
159  }
160 
161  S.write(NumberBuffer, NumChars);
162 }
163 
165  Optional<size_t> Precision) {
166  size_t Prec = Precision.getValueOr(getDefaultPrecision(Style));
167 
168  if (std::isnan(N)) {
169  S << "nan";
170  return;
171  } else if (std::isinf(N)) {
172  S << "INF";
173  return;
174  }
175 
176  char Letter;
177  if (Style == FloatStyle::Exponent)
178  Letter = 'e';
179  else if (Style == FloatStyle::ExponentUpper)
180  Letter = 'E';
181  else
182  Letter = 'f';
183 
184  SmallString<8> Spec;
185  llvm::raw_svector_ostream Out(Spec);
186  Out << "%." << Prec << Letter;
187 
188  if (Style == FloatStyle::Exponent || Style == FloatStyle::ExponentUpper) {
189 #ifdef _WIN32
190 // On MSVCRT and compatible, output of %e is incompatible to Posix
191 // by default. Number of exponent digits should be at least 2. "%+03d"
192 // FIXME: Implement our formatter to here or Support/Format.h!
193 #if defined(__MINGW32__)
194  // FIXME: It should be generic to C++11.
195  if (N == 0.0 && std::signbit(N)) {
196  char NegativeZero[] = "-0.000000e+00";
197  if (Style == FloatStyle::ExponentUpper)
198  NegativeZero[strlen(NegativeZero) - 4] = 'E';
199  S << NegativeZero;
200  return;
201  }
202 #else
203  int fpcl = _fpclass(N);
204 
205  // negative zero
206  if (fpcl == _FPCLASS_NZ) {
207  char NegativeZero[] = "-0.000000e+00";
208  if (Style == FloatStyle::ExponentUpper)
209  NegativeZero[strlen(NegativeZero) - 4] = 'E';
210  S << NegativeZero;
211  return;
212  }
213 #endif
214 
215  char buf[32];
216  unsigned len;
217  len = format(Spec.c_str(), N).snprint(buf, sizeof(buf));
218  if (len <= sizeof(buf) - 2) {
219  if (len >= 5 && (buf[len - 5] == 'e' || buf[len - 5] == 'E') &&
220  buf[len - 3] == '0') {
221  int cs = buf[len - 4];
222  if (cs == '+' || cs == '-') {
223  int c1 = buf[len - 2];
224  int c0 = buf[len - 1];
225  if (isdigit(static_cast<unsigned char>(c1)) &&
226  isdigit(static_cast<unsigned char>(c0))) {
227  // Trim leading '0': "...e+012" -> "...e+12\0"
228  buf[len - 3] = c1;
229  buf[len - 2] = c0;
230  buf[--len] = 0;
231  }
232  }
233  }
234  S << buf;
235  return;
236  }
237 #endif
238  }
239 
240  if (Style == FloatStyle::Percent)
241  N *= 100.0;
242 
243  char Buf[32];
244  format(Spec.c_str(), N).snprint(Buf, sizeof(Buf));
245  S << Buf;
246  if (Style == FloatStyle::Percent)
247  S << '%';
248 }
249 
252 }
253 
255  switch (Style) {
258  return 6; // Number of decimal places.
259  case FloatStyle::Fixed:
260  case FloatStyle::Percent:
261  return 2; // Number of decimal places.
262  }
263  LLVM_BUILTIN_UNREACHABLE;
264 }
const_iterator end(StringRef path)
Get end iterator over path.
Definition: Path.cpp:245
ArrayRef< T > take_front(size_t N=1) const
Return a copy of *this with only the first N elements.
Definition: ArrayRef.h:212
GCNRegPressure max(const GCNRegPressure &P1, const GCNRegPressure &P2)
Compute iterated dominance frontiers using a linear time algorithm.
Definition: AllocatorList.h:24
static void write_unsigned(raw_ostream &S, T N, size_t MinDigits, IntegerStyle Style, bool IsNegative=false)
static void write_signed(raw_ostream &S, T N, size_t MinDigits, IntegerStyle Style)
constexpr T getValueOr(U &&value) const LLVM_LVALUE_FUNCTION
Definition: Optional.h:190
format_object< Ts... > format(const char *Fmt, const Ts &... Vals)
These are helper functions used to produce formatted output.
Definition: Format.h:124
A raw_ostream that writes to an SmallVector or SmallString.
Definition: raw_ostream.h:489
std::size_t countLeadingZeros(T Val, ZeroBehavior ZB=ZB_Width)
Count number of 0&#39;s from the most significant bit to the least stopping at the first 1...
Definition: MathExtras.h:181
void write_double(raw_ostream &S, double D, FloatStyle Style, Optional< size_t > Precision=None)
size_t getDefaultPrecision(FloatStyle Style)
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory)...
Definition: APInt.h:33
bool isPrefixedHexStyle(HexPrintStyle S)
char hexdigit(unsigned X, bool LowerCase=false)
hexdigit - Return the hexadecimal character for the given number X (which should be less than 16)...
Definition: StringExtras.h:37
size_t size() const
size - Get the array size.
Definition: ArrayRef.h:149
raw_ostream & write(unsigned char C)
constexpr size_t array_lengthof(T(&)[N])
Find the length of an array.
Definition: STLExtras.h:721
void write_hex(raw_ostream &S, uint64_t N, HexPrintStyle Style, Optional< size_t > Width=None)
ArrayRef< T > drop_front(size_t N=1) const
Drop the first N elements of the array.
Definition: ArrayRef.h:188
static int format_to_buffer(T Value, char(&Buffer)[N])
const char * c_str()
Definition: SmallString.h:270
#define I(x, y, z)
Definition: MD5.cpp:58
#define N
static void writeWithCommas(raw_ostream &S, ArrayRef< char > Buffer)
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
LLVM Value Representation.
Definition: Value.h:73
This class implements an extremely fast bulk output stream that can only output to a stream...
Definition: raw_ostream.h:44
void write_integer(raw_ostream &S, unsigned int N, size_t MinDigits, IntegerStyle Style)
bool empty() const
empty - Check if the array is empty.
Definition: ArrayRef.h:144
static void write_unsigned_impl(raw_ostream &S, T N, size_t MinDigits, IntegerStyle Style, bool IsNegative)