xref: /freebsd/contrib/llvm-project/llvm/lib/Support/NativeFormatting.cpp (revision 2f513db72b034fd5ef7f080b11be5c711c15186a)
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 
9 #include "llvm/Support/NativeFormatting.h"
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,
89                          IntegerStyle Style) {
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,
104                          IntegerStyle Style) {
105   write_unsigned(S, N, MinDigits, Style);
106 }
107 
108 void llvm::write_integer(raw_ostream &S, int N, size_t MinDigits,
109                          IntegerStyle Style) {
110   write_signed(S, N, MinDigits, Style);
111 }
112 
113 void llvm::write_integer(raw_ostream &S, unsigned long N, size_t MinDigits,
114                          IntegerStyle Style) {
115   write_unsigned(S, N, MinDigits, Style);
116 }
117 
118 void llvm::write_integer(raw_ostream &S, long N, size_t MinDigits,
119                          IntegerStyle Style) {
120   write_signed(S, N, MinDigits, Style);
121 }
122 
123 void llvm::write_integer(raw_ostream &S, unsigned long long N, size_t MinDigits,
124                          IntegerStyle Style) {
125   write_unsigned(S, N, MinDigits, Style);
126 }
127 
128 void llvm::write_integer(raw_ostream &S, long long N, size_t MinDigits,
129                          IntegerStyle Style) {
130   write_signed(S, N, MinDigits, Style);
131 }
132 
133 void llvm::write_hex(raw_ostream &S, uint64_t N, HexPrintStyle Style,
134                      Optional<size_t> Width) {
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 
163 void llvm::write_double(raw_ostream &S, double N, FloatStyle Style,
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 
249 bool llvm::isPrefixedHexStyle(HexPrintStyle S) {
250   return (S == HexPrintStyle::PrefixLower || S == HexPrintStyle::PrefixUpper);
251 }
252 
253 size_t llvm::getDefaultPrecision(FloatStyle Style) {
254   switch (Style) {
255   case FloatStyle::Exponent:
256   case FloatStyle::ExponentUpper:
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 }
264