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