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