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