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/raw_ostream.h" 15 16 #include <cmath> 17 18 #if defined(_WIN32) && !defined(__MINGW32__) 19 #include <float.h> // For _fpclass in llvm::write_double. 20 #endif 21 22 using namespace llvm; 23 24 template<typename T, std::size_t N> 25 static int format_to_buffer(T Value, char (&Buffer)[N]) { 26 char *EndPtr = std::end(Buffer); 27 char *CurPtr = EndPtr; 28 29 do { 30 *--CurPtr = '0' + char(Value % 10); 31 Value /= 10; 32 } while (Value); 33 return EndPtr - CurPtr; 34 } 35 36 static void writeWithCommas(raw_ostream &S, ArrayRef<char> Buffer) { 37 assert(!Buffer.empty()); 38 39 ArrayRef<char> ThisGroup; 40 int InitialDigits = ((Buffer.size() - 1) % 3) + 1; 41 ThisGroup = Buffer.take_front(InitialDigits); 42 S.write(ThisGroup.data(), ThisGroup.size()); 43 44 Buffer = Buffer.drop_front(InitialDigits); 45 assert(Buffer.size() % 3 == 0); 46 while (!Buffer.empty()) { 47 S << ','; 48 ThisGroup = Buffer.take_front(3); 49 S.write(ThisGroup.data(), 3); 50 Buffer = Buffer.drop_front(3); 51 } 52 } 53 54 template <typename T> 55 static void write_unsigned_impl(raw_ostream &S, T N, size_t MinDigits, 56 IntegerStyle Style, bool IsNegative) { 57 static_assert(std::is_unsigned_v<T>, "Value is not unsigned!"); 58 59 char NumberBuffer[128]; 60 size_t 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, 90 IntegerStyle Style) { 91 static_assert(std::is_signed_v<T>, "Value is not signed!"); 92 93 using UnsignedT = std::make_unsigned_t<T>; 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, 105 IntegerStyle Style) { 106 write_unsigned(S, N, MinDigits, Style); 107 } 108 109 void llvm::write_integer(raw_ostream &S, int N, size_t MinDigits, 110 IntegerStyle Style) { 111 write_signed(S, N, MinDigits, Style); 112 } 113 114 void llvm::write_integer(raw_ostream &S, unsigned long N, size_t MinDigits, 115 IntegerStyle Style) { 116 write_unsigned(S, N, MinDigits, Style); 117 } 118 119 void llvm::write_integer(raw_ostream &S, long N, size_t MinDigits, 120 IntegerStyle Style) { 121 write_signed(S, N, MinDigits, Style); 122 } 123 124 void llvm::write_integer(raw_ostream &S, unsigned long long N, size_t MinDigits, 125 IntegerStyle Style) { 126 write_unsigned(S, N, MinDigits, Style); 127 } 128 129 void llvm::write_integer(raw_ostream &S, long long N, size_t MinDigits, 130 IntegerStyle Style) { 131 write_signed(S, N, MinDigits, Style); 132 } 133 134 void llvm::write_hex(raw_ostream &S, uint64_t N, HexPrintStyle Style, 135 std::optional<size_t> Width) { 136 const size_t kMaxWidth = 128u; 137 138 size_t W = std::min(kMaxWidth, Width.value_or(0u)); 139 140 unsigned Nibbles = (llvm::bit_width(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', std::size(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 164 void llvm::write_double(raw_ostream &S, double N, FloatStyle Style, 165 std::optional<size_t> Precision) { 166 size_t Prec = Precision.value_or(getDefaultPrecision(Style)); 167 168 if (std::isnan(N)) { 169 S << "nan"; 170 return; 171 } else if (std::isinf(N)) { 172 S << (std::signbit(N) ? "-INF" : "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 250 bool llvm::isPrefixedHexStyle(HexPrintStyle S) { 251 return (S == HexPrintStyle::PrefixLower || S == HexPrintStyle::PrefixUpper); 252 } 253 254 size_t llvm::getDefaultPrecision(FloatStyle Style) { 255 switch (Style) { 256 case FloatStyle::Exponent: 257 case FloatStyle::ExponentUpper: 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_unreachable("Unknown FloatStyle enum"); 264 } 265