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