File: | lib/Support/raw_ostream.cpp |
Location: | line 315, column 42 |
Description: | Division by zero |
1 | //===--- raw_ostream.cpp - Implement the raw_ostream classes --------------===// | |||
2 | // | |||
3 | // The LLVM Compiler Infrastructure | |||
4 | // | |||
5 | // This file is distributed under the University of Illinois Open Source | |||
6 | // License. See LICENSE.TXT for details. | |||
7 | // | |||
8 | //===----------------------------------------------------------------------===// | |||
9 | // | |||
10 | // This implements support for bulk buffered stream output. | |||
11 | // | |||
12 | //===----------------------------------------------------------------------===// | |||
13 | ||||
14 | #include "llvm/Support/raw_ostream.h" | |||
15 | #include "llvm/ADT/STLExtras.h" | |||
16 | #include "llvm/ADT/SmallVector.h" | |||
17 | #include "llvm/ADT/StringExtras.h" | |||
18 | #include "llvm/Config/config.h" | |||
19 | #include "llvm/Support/Compiler.h" | |||
20 | #include "llvm/Support/ErrorHandling.h" | |||
21 | #include "llvm/Support/FileSystem.h" | |||
22 | #include "llvm/Support/Format.h" | |||
23 | #include "llvm/Support/MathExtras.h" | |||
24 | #include "llvm/Support/Process.h" | |||
25 | #include "llvm/Support/Program.h" | |||
26 | #include <cctype> | |||
27 | #include <cerrno> | |||
28 | #include <sys/stat.h> | |||
29 | #include <system_error> | |||
30 | ||||
31 | // <fcntl.h> may provide O_BINARY. | |||
32 | #if defined(HAVE_FCNTL_H1) | |||
33 | # include <fcntl.h> | |||
34 | #endif | |||
35 | ||||
36 | #if defined(HAVE_UNISTD_H1) | |||
37 | # include <unistd.h> | |||
38 | #endif | |||
39 | #if defined(HAVE_SYS_UIO_H1) && defined(HAVE_WRITEV1) | |||
40 | # include <sys/uio.h> | |||
41 | #endif | |||
42 | ||||
43 | #if defined(__CYGWIN__) | |||
44 | #include <io.h> | |||
45 | #endif | |||
46 | ||||
47 | #if defined(_MSC_VER) | |||
48 | #include <io.h> | |||
49 | #ifndef STDIN_FILENO0 | |||
50 | # define STDIN_FILENO0 0 | |||
51 | #endif | |||
52 | #ifndef STDOUT_FILENO1 | |||
53 | # define STDOUT_FILENO1 1 | |||
54 | #endif | |||
55 | #ifndef STDERR_FILENO2 | |||
56 | # define STDERR_FILENO2 2 | |||
57 | #endif | |||
58 | #endif | |||
59 | ||||
60 | using namespace llvm; | |||
61 | ||||
62 | raw_ostream::~raw_ostream() { | |||
63 | // raw_ostream's subclasses should take care to flush the buffer | |||
64 | // in their destructors. | |||
65 | assert(OutBufCur == OutBufStart &&((OutBufCur == OutBufStart && "raw_ostream destructor called with non-empty buffer!" ) ? static_cast<void> (0) : __assert_fail ("OutBufCur == OutBufStart && \"raw_ostream destructor called with non-empty buffer!\"" , "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn224007/lib/Support/raw_ostream.cpp" , 66, __PRETTY_FUNCTION__)) | |||
66 | "raw_ostream destructor called with non-empty buffer!")((OutBufCur == OutBufStart && "raw_ostream destructor called with non-empty buffer!" ) ? static_cast<void> (0) : __assert_fail ("OutBufCur == OutBufStart && \"raw_ostream destructor called with non-empty buffer!\"" , "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn224007/lib/Support/raw_ostream.cpp" , 66, __PRETTY_FUNCTION__)); | |||
67 | ||||
68 | if (BufferMode == InternalBuffer) | |||
69 | delete [] OutBufStart; | |||
70 | } | |||
71 | ||||
72 | // An out of line virtual method to provide a home for the class vtable. | |||
73 | void raw_ostream::handle() {} | |||
74 | ||||
75 | size_t raw_ostream::preferred_buffer_size() const { | |||
76 | // BUFSIZ is intended to be a reasonable default. | |||
77 | return BUFSIZ8192; | |||
78 | } | |||
79 | ||||
80 | void raw_ostream::SetBuffered() { | |||
81 | // Ask the subclass to determine an appropriate buffer size. | |||
82 | if (size_t Size = preferred_buffer_size()) | |||
83 | SetBufferSize(Size); | |||
84 | else | |||
85 | // It may return 0, meaning this stream should be unbuffered. | |||
86 | SetUnbuffered(); | |||
87 | } | |||
88 | ||||
89 | void raw_ostream::SetBufferAndMode(char *BufferStart, size_t Size, | |||
90 | BufferKind Mode) { | |||
91 | assert(((Mode == Unbuffered && !BufferStart && Size == 0) ||((((Mode == Unbuffered && !BufferStart && Size == 0) || (Mode != Unbuffered && BufferStart && Size != 0)) && "stream must be unbuffered or have at least one byte" ) ? static_cast<void> (0) : __assert_fail ("((Mode == Unbuffered && !BufferStart && Size == 0) || (Mode != Unbuffered && BufferStart && Size != 0)) && \"stream must be unbuffered or have at least one byte\"" , "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn224007/lib/Support/raw_ostream.cpp" , 93, __PRETTY_FUNCTION__)) | |||
92 | (Mode != Unbuffered && BufferStart && Size != 0)) &&((((Mode == Unbuffered && !BufferStart && Size == 0) || (Mode != Unbuffered && BufferStart && Size != 0)) && "stream must be unbuffered or have at least one byte" ) ? static_cast<void> (0) : __assert_fail ("((Mode == Unbuffered && !BufferStart && Size == 0) || (Mode != Unbuffered && BufferStart && Size != 0)) && \"stream must be unbuffered or have at least one byte\"" , "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn224007/lib/Support/raw_ostream.cpp" , 93, __PRETTY_FUNCTION__)) | |||
93 | "stream must be unbuffered or have at least one byte")((((Mode == Unbuffered && !BufferStart && Size == 0) || (Mode != Unbuffered && BufferStart && Size != 0)) && "stream must be unbuffered or have at least one byte" ) ? static_cast<void> (0) : __assert_fail ("((Mode == Unbuffered && !BufferStart && Size == 0) || (Mode != Unbuffered && BufferStart && Size != 0)) && \"stream must be unbuffered or have at least one byte\"" , "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn224007/lib/Support/raw_ostream.cpp" , 93, __PRETTY_FUNCTION__)); | |||
94 | // Make sure the current buffer is free of content (we can't flush here; the | |||
95 | // child buffer management logic will be in write_impl). | |||
96 | assert(GetNumBytesInBuffer() == 0 && "Current buffer is non-empty!")((GetNumBytesInBuffer() == 0 && "Current buffer is non-empty!" ) ? static_cast<void> (0) : __assert_fail ("GetNumBytesInBuffer() == 0 && \"Current buffer is non-empty!\"" , "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn224007/lib/Support/raw_ostream.cpp" , 96, __PRETTY_FUNCTION__)); | |||
97 | ||||
98 | if (BufferMode == InternalBuffer) | |||
99 | delete [] OutBufStart; | |||
100 | OutBufStart = BufferStart; | |||
101 | OutBufEnd = OutBufStart+Size; | |||
102 | OutBufCur = OutBufStart; | |||
103 | BufferMode = Mode; | |||
104 | ||||
105 | assert(OutBufStart <= OutBufEnd && "Invalid size!")((OutBufStart <= OutBufEnd && "Invalid size!") ? static_cast <void> (0) : __assert_fail ("OutBufStart <= OutBufEnd && \"Invalid size!\"" , "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn224007/lib/Support/raw_ostream.cpp" , 105, __PRETTY_FUNCTION__)); | |||
106 | } | |||
107 | ||||
108 | raw_ostream &raw_ostream::operator<<(unsigned long N) { | |||
109 | // Zero is a special case. | |||
110 | if (N == 0) | |||
111 | return *this << '0'; | |||
112 | ||||
113 | char NumberBuffer[20]; | |||
114 | char *EndPtr = NumberBuffer+sizeof(NumberBuffer); | |||
115 | char *CurPtr = EndPtr; | |||
116 | ||||
117 | while (N) { | |||
118 | *--CurPtr = '0' + char(N % 10); | |||
119 | N /= 10; | |||
120 | } | |||
121 | return write(CurPtr, EndPtr-CurPtr); | |||
122 | } | |||
123 | ||||
124 | raw_ostream &raw_ostream::operator<<(long N) { | |||
125 | if (N < 0) { | |||
126 | *this << '-'; | |||
127 | // Avoid undefined behavior on LONG_MIN with a cast. | |||
128 | N = -(unsigned long)N; | |||
129 | } | |||
130 | ||||
131 | return this->operator<<(static_cast<unsigned long>(N)); | |||
132 | } | |||
133 | ||||
134 | raw_ostream &raw_ostream::operator<<(unsigned long long N) { | |||
135 | // Output using 32-bit div/mod when possible. | |||
136 | if (N == static_cast<unsigned long>(N)) | |||
137 | return this->operator<<(static_cast<unsigned long>(N)); | |||
138 | ||||
139 | char NumberBuffer[20]; | |||
140 | char *EndPtr = NumberBuffer+sizeof(NumberBuffer); | |||
141 | char *CurPtr = EndPtr; | |||
142 | ||||
143 | while (N) { | |||
144 | *--CurPtr = '0' + char(N % 10); | |||
145 | N /= 10; | |||
146 | } | |||
147 | return write(CurPtr, EndPtr-CurPtr); | |||
148 | } | |||
149 | ||||
150 | raw_ostream &raw_ostream::operator<<(long long N) { | |||
151 | if (N < 0) { | |||
| ||||
152 | *this << '-'; | |||
153 | // Avoid undefined behavior on INT64_MIN with a cast. | |||
154 | N = -(unsigned long long)N; | |||
155 | } | |||
156 | ||||
157 | return this->operator<<(static_cast<unsigned long long>(N)); | |||
158 | } | |||
159 | ||||
160 | raw_ostream &raw_ostream::write_hex(unsigned long long N) { | |||
161 | // Zero is a special case. | |||
162 | if (N == 0) | |||
163 | return *this << '0'; | |||
164 | ||||
165 | char NumberBuffer[20]; | |||
166 | char *EndPtr = NumberBuffer+sizeof(NumberBuffer); | |||
167 | char *CurPtr = EndPtr; | |||
168 | ||||
169 | while (N) { | |||
170 | uintptr_t x = N % 16; | |||
171 | *--CurPtr = (x < 10 ? '0' + x : 'a' + x - 10); | |||
172 | N /= 16; | |||
173 | } | |||
174 | ||||
175 | return write(CurPtr, EndPtr-CurPtr); | |||
176 | } | |||
177 | ||||
178 | raw_ostream &raw_ostream::write_escaped(StringRef Str, | |||
179 | bool UseHexEscapes) { | |||
180 | for (unsigned i = 0, e = Str.size(); i != e; ++i) { | |||
181 | unsigned char c = Str[i]; | |||
182 | ||||
183 | switch (c) { | |||
184 | case '\\': | |||
185 | *this << '\\' << '\\'; | |||
186 | break; | |||
187 | case '\t': | |||
188 | *this << '\\' << 't'; | |||
189 | break; | |||
190 | case '\n': | |||
191 | *this << '\\' << 'n'; | |||
192 | break; | |||
193 | case '"': | |||
194 | *this << '\\' << '"'; | |||
195 | break; | |||
196 | default: | |||
197 | if (std::isprint(c)) { | |||
198 | *this << c; | |||
199 | break; | |||
200 | } | |||
201 | ||||
202 | // Write out the escaped representation. | |||
203 | if (UseHexEscapes) { | |||
204 | *this << '\\' << 'x'; | |||
205 | *this << hexdigit((c >> 4 & 0xF)); | |||
206 | *this << hexdigit((c >> 0) & 0xF); | |||
207 | } else { | |||
208 | // Always use a full 3-character octal escape. | |||
209 | *this << '\\'; | |||
210 | *this << char('0' + ((c >> 6) & 7)); | |||
211 | *this << char('0' + ((c >> 3) & 7)); | |||
212 | *this << char('0' + ((c >> 0) & 7)); | |||
213 | } | |||
214 | } | |||
215 | } | |||
216 | ||||
217 | return *this; | |||
218 | } | |||
219 | ||||
220 | raw_ostream &raw_ostream::operator<<(const void *P) { | |||
221 | *this << '0' << 'x'; | |||
222 | ||||
223 | return write_hex((uintptr_t) P); | |||
224 | } | |||
225 | ||||
226 | raw_ostream &raw_ostream::operator<<(double N) { | |||
227 | #ifdef _WIN32 | |||
228 | // On MSVCRT and compatible, output of %e is incompatible to Posix | |||
229 | // by default. Number of exponent digits should be at least 2. "%+03d" | |||
230 | // FIXME: Implement our formatter to here or Support/Format.h! | |||
231 | #if __cplusplus201103L >= 201103L && defined(__MINGW32__) | |||
232 | // FIXME: It should be generic to C++11. | |||
233 | if (N == 0.0 && std::signbit(N)) | |||
234 | return *this << "-0.000000e+00"; | |||
235 | #else | |||
236 | int fpcl = _fpclass(N); | |||
237 | ||||
238 | // negative zero | |||
239 | if (fpcl == _FPCLASS_NZ) | |||
240 | return *this << "-0.000000e+00"; | |||
241 | #endif | |||
242 | ||||
243 | char buf[16]; | |||
244 | unsigned len; | |||
245 | len = snprintf(buf, sizeof(buf), "%e", N); | |||
246 | if (len <= sizeof(buf) - 2) { | |||
247 | if (len >= 5 && buf[len - 5] == 'e' && buf[len - 3] == '0') { | |||
248 | int cs = buf[len - 4]; | |||
249 | if (cs == '+' || cs == '-') { | |||
250 | int c1 = buf[len - 2]; | |||
251 | int c0 = buf[len - 1]; | |||
252 | if (isdigit(static_cast<unsigned char>(c1)) && | |||
253 | isdigit(static_cast<unsigned char>(c0))) { | |||
254 | // Trim leading '0': "...e+012" -> "...e+12\0" | |||
255 | buf[len - 3] = c1; | |||
256 | buf[len - 2] = c0; | |||
257 | buf[--len] = 0; | |||
258 | } | |||
259 | } | |||
260 | } | |||
261 | return this->operator<<(buf); | |||
262 | } | |||
263 | #endif | |||
264 | return this->operator<<(format("%e", N)); | |||
265 | } | |||
266 | ||||
267 | ||||
268 | ||||
269 | void raw_ostream::flush_nonempty() { | |||
270 | assert(OutBufCur > OutBufStart && "Invalid call to flush_nonempty.")((OutBufCur > OutBufStart && "Invalid call to flush_nonempty." ) ? static_cast<void> (0) : __assert_fail ("OutBufCur > OutBufStart && \"Invalid call to flush_nonempty.\"" , "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn224007/lib/Support/raw_ostream.cpp" , 270, __PRETTY_FUNCTION__)); | |||
271 | size_t Length = OutBufCur - OutBufStart; | |||
272 | OutBufCur = OutBufStart; | |||
273 | write_impl(OutBufStart, Length); | |||
274 | } | |||
275 | ||||
276 | raw_ostream &raw_ostream::write(unsigned char C) { | |||
277 | // Group exceptional cases into a single branch. | |||
278 | if (LLVM_UNLIKELY(OutBufCur >= OutBufEnd)__builtin_expect((bool)(OutBufCur >= OutBufEnd), false)) { | |||
279 | if (LLVM_UNLIKELY(!OutBufStart)__builtin_expect((bool)(!OutBufStart), false)) { | |||
280 | if (BufferMode == Unbuffered) { | |||
281 | write_impl(reinterpret_cast<char*>(&C), 1); | |||
282 | return *this; | |||
283 | } | |||
284 | // Set up a buffer and start over. | |||
285 | SetBuffered(); | |||
286 | return write(C); | |||
287 | } | |||
288 | ||||
289 | flush_nonempty(); | |||
290 | } | |||
291 | ||||
292 | *OutBufCur++ = C; | |||
293 | return *this; | |||
294 | } | |||
295 | ||||
296 | raw_ostream &raw_ostream::write(const char *Ptr, size_t Size) { | |||
297 | // Group exceptional cases into a single branch. | |||
298 | if (LLVM_UNLIKELY(size_t(OutBufEnd - OutBufCur) < Size)__builtin_expect((bool)(size_t(OutBufEnd - OutBufCur) < Size ), false)) { | |||
299 | if (LLVM_UNLIKELY(!OutBufStart)__builtin_expect((bool)(!OutBufStart), false)) { | |||
300 | if (BufferMode == Unbuffered) { | |||
301 | write_impl(Ptr, Size); | |||
302 | return *this; | |||
303 | } | |||
304 | // Set up a buffer and start over. | |||
305 | SetBuffered(); | |||
306 | return write(Ptr, Size); | |||
307 | } | |||
308 | ||||
309 | size_t NumBytes = OutBufEnd - OutBufCur; | |||
310 | ||||
311 | // If the buffer is empty at this point we have a string that is larger | |||
312 | // than the buffer. Directly write the chunk that is a multiple of the | |||
313 | // preferred buffer size and put the remainder in the buffer. | |||
314 | if (LLVM_UNLIKELY(OutBufCur == OutBufStart)__builtin_expect((bool)(OutBufCur == OutBufStart), false)) { | |||
315 | size_t BytesToWrite = Size - (Size % NumBytes); | |||
| ||||
316 | write_impl(Ptr, BytesToWrite); | |||
317 | size_t BytesRemaining = Size - BytesToWrite; | |||
318 | if (BytesRemaining > size_t(OutBufEnd - OutBufCur)) { | |||
319 | // Too much left over to copy into our buffer. | |||
320 | return write(Ptr + BytesToWrite, BytesRemaining); | |||
321 | } | |||
322 | copy_to_buffer(Ptr + BytesToWrite, BytesRemaining); | |||
323 | return *this; | |||
324 | } | |||
325 | ||||
326 | // We don't have enough space in the buffer to fit the string in. Insert as | |||
327 | // much as possible, flush and start over with the remainder. | |||
328 | copy_to_buffer(Ptr, NumBytes); | |||
329 | flush_nonempty(); | |||
330 | return write(Ptr + NumBytes, Size - NumBytes); | |||
331 | } | |||
332 | ||||
333 | copy_to_buffer(Ptr, Size); | |||
334 | ||||
335 | return *this; | |||
336 | } | |||
337 | ||||
338 | void raw_ostream::copy_to_buffer(const char *Ptr, size_t Size) { | |||
339 | assert(Size <= size_t(OutBufEnd - OutBufCur) && "Buffer overrun!")((Size <= size_t(OutBufEnd - OutBufCur) && "Buffer overrun!" ) ? static_cast<void> (0) : __assert_fail ("Size <= size_t(OutBufEnd - OutBufCur) && \"Buffer overrun!\"" , "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn224007/lib/Support/raw_ostream.cpp" , 339, __PRETTY_FUNCTION__)); | |||
340 | ||||
341 | // Handle short strings specially, memcpy isn't very good at very short | |||
342 | // strings. | |||
343 | switch (Size) { | |||
344 | case 4: OutBufCur[3] = Ptr[3]; // FALL THROUGH | |||
345 | case 3: OutBufCur[2] = Ptr[2]; // FALL THROUGH | |||
346 | case 2: OutBufCur[1] = Ptr[1]; // FALL THROUGH | |||
347 | case 1: OutBufCur[0] = Ptr[0]; // FALL THROUGH | |||
348 | case 0: break; | |||
349 | default: | |||
350 | memcpy(OutBufCur, Ptr, Size); | |||
351 | break; | |||
352 | } | |||
353 | ||||
354 | OutBufCur += Size; | |||
355 | } | |||
356 | ||||
357 | // Formatted output. | |||
358 | raw_ostream &raw_ostream::operator<<(const format_object_base &Fmt) { | |||
359 | // If we have more than a few bytes left in our output buffer, try | |||
360 | // formatting directly onto its end. | |||
361 | size_t NextBufferSize = 127; | |||
362 | size_t BufferBytesLeft = OutBufEnd - OutBufCur; | |||
363 | if (BufferBytesLeft > 3) { | |||
364 | size_t BytesUsed = Fmt.print(OutBufCur, BufferBytesLeft); | |||
365 | ||||
366 | // Common case is that we have plenty of space. | |||
367 | if (BytesUsed <= BufferBytesLeft) { | |||
368 | OutBufCur += BytesUsed; | |||
369 | return *this; | |||
370 | } | |||
371 | ||||
372 | // Otherwise, we overflowed and the return value tells us the size to try | |||
373 | // again with. | |||
374 | NextBufferSize = BytesUsed; | |||
375 | } | |||
376 | ||||
377 | // If we got here, we didn't have enough space in the output buffer for the | |||
378 | // string. Try printing into a SmallVector that is resized to have enough | |||
379 | // space. Iterate until we win. | |||
380 | SmallVector<char, 128> V; | |||
381 | ||||
382 | while (1) { | |||
383 | V.resize(NextBufferSize); | |||
384 | ||||
385 | // Try formatting into the SmallVector. | |||
386 | size_t BytesUsed = Fmt.print(V.data(), NextBufferSize); | |||
387 | ||||
388 | // If BytesUsed fit into the vector, we win. | |||
389 | if (BytesUsed <= NextBufferSize) | |||
390 | return write(V.data(), BytesUsed); | |||
391 | ||||
392 | // Otherwise, try again with a new size. | |||
393 | assert(BytesUsed > NextBufferSize && "Didn't grow buffer!?")((BytesUsed > NextBufferSize && "Didn't grow buffer!?" ) ? static_cast<void> (0) : __assert_fail ("BytesUsed > NextBufferSize && \"Didn't grow buffer!?\"" , "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn224007/lib/Support/raw_ostream.cpp" , 393, __PRETTY_FUNCTION__)); | |||
394 | NextBufferSize = BytesUsed; | |||
395 | } | |||
396 | } | |||
397 | ||||
398 | raw_ostream &raw_ostream::operator<<(const FormattedString &FS) { | |||
399 | unsigned Len = FS.Str.size(); | |||
400 | int PadAmount = FS.Width - Len; | |||
401 | if (FS.RightJustify && (PadAmount > 0)) | |||
402 | this->indent(PadAmount); | |||
403 | this->operator<<(FS.Str); | |||
404 | if (!FS.RightJustify && (PadAmount > 0)) | |||
405 | this->indent(PadAmount); | |||
406 | return *this; | |||
407 | } | |||
408 | ||||
409 | raw_ostream &raw_ostream::operator<<(const FormattedNumber &FN) { | |||
410 | if (FN.Hex) { | |||
411 | unsigned Nibbles = (64 - countLeadingZeros(FN.HexValue)+3)/4; | |||
412 | unsigned Width = (FN.Width > Nibbles+2) ? FN.Width : Nibbles+2; | |||
413 | ||||
414 | char NumberBuffer[20] = "0x0000000000000000"; | |||
415 | char *EndPtr = NumberBuffer+Width; | |||
416 | char *CurPtr = EndPtr; | |||
417 | const char A = FN.Upper ? 'A' : 'a'; | |||
418 | unsigned long long N = FN.HexValue; | |||
419 | while (N) { | |||
420 | uintptr_t x = N % 16; | |||
421 | *--CurPtr = (x < 10 ? '0' + x : A + x - 10); | |||
422 | N /= 16; | |||
423 | } | |||
424 | ||||
425 | return write(NumberBuffer, Width); | |||
426 | } else { | |||
427 | // Zero is a special case. | |||
428 | if (FN.DecValue == 0) { | |||
429 | this->indent(FN.Width-1); | |||
430 | return *this << '0'; | |||
431 | } | |||
432 | char NumberBuffer[32]; | |||
433 | char *EndPtr = NumberBuffer+sizeof(NumberBuffer); | |||
434 | char *CurPtr = EndPtr; | |||
435 | bool Neg = (FN.DecValue < 0); | |||
436 | uint64_t N = Neg ? -static_cast<uint64_t>(FN.DecValue) : FN.DecValue; | |||
437 | while (N) { | |||
438 | *--CurPtr = '0' + char(N % 10); | |||
439 | N /= 10; | |||
440 | } | |||
441 | int Len = EndPtr - CurPtr; | |||
442 | int Pad = FN.Width - Len; | |||
443 | if (Neg) | |||
444 | --Pad; | |||
445 | if (Pad > 0) | |||
446 | this->indent(Pad); | |||
447 | if (Neg) | |||
448 | *this << '-'; | |||
449 | return write(CurPtr, Len); | |||
450 | } | |||
451 | } | |||
452 | ||||
453 | ||||
454 | /// indent - Insert 'NumSpaces' spaces. | |||
455 | raw_ostream &raw_ostream::indent(unsigned NumSpaces) { | |||
456 | static const char Spaces[] = " " | |||
457 | " " | |||
458 | " "; | |||
459 | ||||
460 | // Usually the indentation is small, handle it with a fastpath. | |||
461 | if (NumSpaces < array_lengthof(Spaces)) | |||
462 | return write(Spaces, NumSpaces); | |||
463 | ||||
464 | while (NumSpaces) { | |||
465 | unsigned NumToWrite = std::min(NumSpaces, | |||
466 | (unsigned)array_lengthof(Spaces)-1); | |||
467 | write(Spaces, NumToWrite); | |||
468 | NumSpaces -= NumToWrite; | |||
469 | } | |||
470 | return *this; | |||
471 | } | |||
472 | ||||
473 | ||||
474 | //===----------------------------------------------------------------------===// | |||
475 | // Formatted Output | |||
476 | //===----------------------------------------------------------------------===// | |||
477 | ||||
478 | // Out of line virtual method. | |||
479 | void format_object_base::home() { | |||
480 | } | |||
481 | ||||
482 | //===----------------------------------------------------------------------===// | |||
483 | // raw_fd_ostream | |||
484 | //===----------------------------------------------------------------------===// | |||
485 | ||||
486 | raw_fd_ostream::raw_fd_ostream(StringRef Filename, std::error_code &EC, | |||
487 | sys::fs::OpenFlags Flags) | |||
488 | : Error(false), UseAtomicWrites(false), pos(0) { | |||
489 | EC = std::error_code(); | |||
490 | // Handle "-" as stdout. Note that when we do this, we consider ourself | |||
491 | // the owner of stdout. This means that we can do things like close the | |||
492 | // file descriptor when we're done and set the "binary" flag globally. | |||
493 | if (Filename == "-") { | |||
494 | FD = STDOUT_FILENO1; | |||
495 | // If user requested binary then put stdout into binary mode if | |||
496 | // possible. | |||
497 | if (!(Flags & sys::fs::F_Text)) | |||
498 | sys::ChangeStdoutToBinary(); | |||
499 | // Close stdout when we're done, to detect any output errors. | |||
500 | ShouldClose = true; | |||
501 | return; | |||
502 | } | |||
503 | ||||
504 | EC = sys::fs::openFileForWrite(Filename, FD, Flags); | |||
505 | ||||
506 | if (EC) { | |||
507 | ShouldClose = false; | |||
508 | return; | |||
509 | } | |||
510 | ||||
511 | // Ok, we successfully opened the file, so it'll need to be closed. | |||
512 | ShouldClose = true; | |||
513 | } | |||
514 | ||||
515 | /// raw_fd_ostream ctor - FD is the file descriptor that this writes to. If | |||
516 | /// ShouldClose is true, this closes the file when the stream is destroyed. | |||
517 | raw_fd_ostream::raw_fd_ostream(int fd, bool shouldClose, bool unbuffered) | |||
518 | : raw_ostream(unbuffered), FD(fd), | |||
519 | ShouldClose(shouldClose), Error(false), UseAtomicWrites(false) { | |||
520 | #ifdef O_BINARY | |||
521 | // Setting STDOUT to binary mode is necessary in Win32 | |||
522 | // to avoid undesirable linefeed conversion. | |||
523 | // Don't touch STDERR, or w*printf() (in assert()) would barf wide chars. | |||
524 | if (fd == STDOUT_FILENO1) | |||
525 | setmode(fd, O_BINARY); | |||
526 | #endif | |||
527 | ||||
528 | // Get the starting position. | |||
529 | off_t loc = ::lseek(FD, 0, SEEK_CUR1); | |||
530 | if (loc == (off_t)-1) | |||
531 | pos = 0; | |||
532 | else | |||
533 | pos = static_cast<uint64_t>(loc); | |||
534 | } | |||
535 | ||||
536 | raw_fd_ostream::~raw_fd_ostream() { | |||
537 | if (FD >= 0) { | |||
538 | flush(); | |||
539 | if (ShouldClose && sys::Process::SafelyCloseFileDescriptor(FD)) | |||
540 | error_detected(); | |||
541 | } | |||
542 | ||||
543 | #ifdef __MINGW32__ | |||
544 | // On mingw, global dtors should not call exit(). | |||
545 | // report_fatal_error() invokes exit(). We know report_fatal_error() | |||
546 | // might not write messages to stderr when any errors were detected | |||
547 | // on FD == 2. | |||
548 | if (FD == 2) return; | |||
549 | #endif | |||
550 | ||||
551 | // If there are any pending errors, report them now. Clients wishing | |||
552 | // to avoid report_fatal_error calls should check for errors with | |||
553 | // has_error() and clear the error flag with clear_error() before | |||
554 | // destructing raw_ostream objects which may have errors. | |||
555 | if (has_error()) | |||
556 | report_fatal_error("IO failure on output stream.", /*GenCrashDiag=*/false); | |||
557 | } | |||
558 | ||||
559 | ||||
560 | void raw_fd_ostream::write_impl(const char *Ptr, size_t Size) { | |||
561 | assert(FD >= 0 && "File already closed.")((FD >= 0 && "File already closed.") ? static_cast <void> (0) : __assert_fail ("FD >= 0 && \"File already closed.\"" , "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn224007/lib/Support/raw_ostream.cpp" , 561, __PRETTY_FUNCTION__)); | |||
562 | pos += Size; | |||
563 | ||||
564 | do { | |||
565 | ssize_t ret; | |||
566 | ||||
567 | // Check whether we should attempt to use atomic writes. | |||
568 | if (LLVM_LIKELY(!UseAtomicWrites)__builtin_expect((bool)(!UseAtomicWrites), true)) { | |||
569 | ret = ::write(FD, Ptr, Size); | |||
570 | } else { | |||
571 | // Use ::writev() where available. | |||
572 | #if defined(HAVE_WRITEV1) | |||
573 | const void *Addr = static_cast<const void *>(Ptr); | |||
574 | struct iovec IOV = {const_cast<void *>(Addr), Size }; | |||
575 | ret = ::writev(FD, &IOV, 1); | |||
576 | #else | |||
577 | ret = ::write(FD, Ptr, Size); | |||
578 | #endif | |||
579 | } | |||
580 | ||||
581 | if (ret < 0) { | |||
582 | // If it's a recoverable error, swallow it and retry the write. | |||
583 | // | |||
584 | // Ideally we wouldn't ever see EAGAIN or EWOULDBLOCK here, since | |||
585 | // raw_ostream isn't designed to do non-blocking I/O. However, some | |||
586 | // programs, such as old versions of bjam, have mistakenly used | |||
587 | // O_NONBLOCK. For compatibility, emulate blocking semantics by | |||
588 | // spinning until the write succeeds. If you don't want spinning, | |||
589 | // don't use O_NONBLOCK file descriptors with raw_ostream. | |||
590 | if (errno(*__errno_location ()) == EINTR4 || errno(*__errno_location ()) == EAGAIN11 | |||
591 | #ifdef EWOULDBLOCK11 | |||
592 | || errno(*__errno_location ()) == EWOULDBLOCK11 | |||
593 | #endif | |||
594 | ) | |||
595 | continue; | |||
596 | ||||
597 | // Otherwise it's a non-recoverable error. Note it and quit. | |||
598 | error_detected(); | |||
599 | break; | |||
600 | } | |||
601 | ||||
602 | // The write may have written some or all of the data. Update the | |||
603 | // size and buffer pointer to reflect the remainder that needs | |||
604 | // to be written. If there are no bytes left, we're done. | |||
605 | Ptr += ret; | |||
606 | Size -= ret; | |||
607 | } while (Size > 0); | |||
608 | } | |||
609 | ||||
610 | void raw_fd_ostream::close() { | |||
611 | assert(ShouldClose)((ShouldClose) ? static_cast<void> (0) : __assert_fail ( "ShouldClose", "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn224007/lib/Support/raw_ostream.cpp" , 611, __PRETTY_FUNCTION__)); | |||
612 | ShouldClose = false; | |||
613 | flush(); | |||
614 | if (sys::Process::SafelyCloseFileDescriptor(FD)) | |||
615 | error_detected(); | |||
616 | FD = -1; | |||
617 | } | |||
618 | ||||
619 | uint64_t raw_fd_ostream::seek(uint64_t off) { | |||
620 | flush(); | |||
621 | pos = ::lseek(FD, off, SEEK_SET0); | |||
622 | if (pos != off) | |||
623 | error_detected(); | |||
624 | return pos; | |||
625 | } | |||
626 | ||||
627 | size_t raw_fd_ostream::preferred_buffer_size() const { | |||
628 | #if !defined(_MSC_VER) && !defined(__MINGW32__) && !defined(__minix) | |||
629 | // Windows and Minix have no st_blksize. | |||
630 | assert(FD >= 0 && "File not yet open!")((FD >= 0 && "File not yet open!") ? static_cast< void> (0) : __assert_fail ("FD >= 0 && \"File not yet open!\"" , "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn224007/lib/Support/raw_ostream.cpp" , 630, __PRETTY_FUNCTION__)); | |||
631 | struct stat statbuf; | |||
632 | if (fstat(FD, &statbuf) != 0) | |||
633 | return 0; | |||
634 | ||||
635 | // If this is a terminal, don't use buffering. Line buffering | |||
636 | // would be a more traditional thing to do, but it's not worth | |||
637 | // the complexity. | |||
638 | if (S_ISCHR(statbuf.st_mode)((((statbuf.st_mode)) & 0170000) == (0020000)) && isatty(FD)) | |||
639 | return 0; | |||
640 | // Return the preferred block size. | |||
641 | return statbuf.st_blksize; | |||
642 | #else | |||
643 | return raw_ostream::preferred_buffer_size(); | |||
644 | #endif | |||
645 | } | |||
646 | ||||
647 | raw_ostream &raw_fd_ostream::changeColor(enum Colors colors, bool bold, | |||
648 | bool bg) { | |||
649 | if (sys::Process::ColorNeedsFlush()) | |||
650 | flush(); | |||
651 | const char *colorcode = | |||
652 | (colors == SAVEDCOLOR) ? sys::Process::OutputBold(bg) | |||
653 | : sys::Process::OutputColor(colors, bold, bg); | |||
654 | if (colorcode) { | |||
655 | size_t len = strlen(colorcode); | |||
656 | write(colorcode, len); | |||
657 | // don't account colors towards output characters | |||
658 | pos -= len; | |||
659 | } | |||
660 | return *this; | |||
661 | } | |||
662 | ||||
663 | raw_ostream &raw_fd_ostream::resetColor() { | |||
664 | if (sys::Process::ColorNeedsFlush()) | |||
665 | flush(); | |||
666 | const char *colorcode = sys::Process::ResetColor(); | |||
667 | if (colorcode) { | |||
668 | size_t len = strlen(colorcode); | |||
669 | write(colorcode, len); | |||
670 | // don't account colors towards output characters | |||
671 | pos -= len; | |||
672 | } | |||
673 | return *this; | |||
674 | } | |||
675 | ||||
676 | raw_ostream &raw_fd_ostream::reverseColor() { | |||
677 | if (sys::Process::ColorNeedsFlush()) | |||
678 | flush(); | |||
679 | const char *colorcode = sys::Process::OutputReverse(); | |||
680 | if (colorcode) { | |||
681 | size_t len = strlen(colorcode); | |||
682 | write(colorcode, len); | |||
683 | // don't account colors towards output characters | |||
684 | pos -= len; | |||
685 | } | |||
686 | return *this; | |||
687 | } | |||
688 | ||||
689 | bool raw_fd_ostream::is_displayed() const { | |||
690 | return sys::Process::FileDescriptorIsDisplayed(FD); | |||
691 | } | |||
692 | ||||
693 | bool raw_fd_ostream::has_colors() const { | |||
694 | return sys::Process::FileDescriptorHasColors(FD); | |||
695 | } | |||
696 | ||||
697 | //===----------------------------------------------------------------------===// | |||
698 | // outs(), errs(), nulls() | |||
699 | //===----------------------------------------------------------------------===// | |||
700 | ||||
701 | /// outs() - This returns a reference to a raw_ostream for standard output. | |||
702 | /// Use it like: outs() << "foo" << "bar"; | |||
703 | raw_ostream &llvm::outs() { | |||
704 | // Set buffer settings to model stdout behavior. | |||
705 | // Delete the file descriptor when the program exits, forcing error | |||
706 | // detection. If you don't want this behavior, don't use outs(). | |||
707 | static raw_fd_ostream S(STDOUT_FILENO1, true); | |||
708 | return S; | |||
709 | } | |||
710 | ||||
711 | /// errs() - This returns a reference to a raw_ostream for standard error. | |||
712 | /// Use it like: errs() << "foo" << "bar"; | |||
713 | raw_ostream &llvm::errs() { | |||
714 | // Set standard error to be unbuffered by default. | |||
715 | static raw_fd_ostream S(STDERR_FILENO2, false, true); | |||
716 | return S; | |||
717 | } | |||
718 | ||||
719 | /// nulls() - This returns a reference to a raw_ostream which discards output. | |||
720 | raw_ostream &llvm::nulls() { | |||
721 | static raw_null_ostream S; | |||
722 | return S; | |||
723 | } | |||
724 | ||||
725 | ||||
726 | //===----------------------------------------------------------------------===// | |||
727 | // raw_string_ostream | |||
728 | //===----------------------------------------------------------------------===// | |||
729 | ||||
730 | raw_string_ostream::~raw_string_ostream() { | |||
731 | flush(); | |||
732 | } | |||
733 | ||||
734 | void raw_string_ostream::write_impl(const char *Ptr, size_t Size) { | |||
735 | OS.append(Ptr, Size); | |||
736 | } | |||
737 | ||||
738 | //===----------------------------------------------------------------------===// | |||
739 | // raw_svector_ostream | |||
740 | //===----------------------------------------------------------------------===// | |||
741 | ||||
742 | // The raw_svector_ostream implementation uses the SmallVector itself as the | |||
743 | // buffer for the raw_ostream. We guarantee that the raw_ostream buffer is | |||
744 | // always pointing past the end of the vector, but within the vector | |||
745 | // capacity. This allows raw_ostream to write directly into the correct place, | |||
746 | // and we only need to set the vector size when the data is flushed. | |||
747 | ||||
748 | raw_svector_ostream::raw_svector_ostream(SmallVectorImpl<char> &O) : OS(O) { | |||
749 | // Set up the initial external buffer. We make sure that the buffer has at | |||
750 | // least 128 bytes free; raw_ostream itself only requires 64, but we want to | |||
751 | // make sure that we don't grow the buffer unnecessarily on destruction (when | |||
752 | // the data is flushed). See the FIXME below. | |||
753 | OS.reserve(OS.size() + 128); | |||
754 | SetBuffer(OS.end(), OS.capacity() - OS.size()); | |||
755 | } | |||
756 | ||||
757 | raw_svector_ostream::~raw_svector_ostream() { | |||
758 | // FIXME: Prevent resizing during this flush(). | |||
759 | flush(); | |||
760 | } | |||
761 | ||||
762 | /// resync - This is called when the SmallVector we're appending to is changed | |||
763 | /// outside of the raw_svector_ostream's control. It is only safe to do this | |||
764 | /// if the raw_svector_ostream has previously been flushed. | |||
765 | void raw_svector_ostream::resync() { | |||
766 | assert(GetNumBytesInBuffer() == 0 && "Didn't flush before mutating vector")((GetNumBytesInBuffer() == 0 && "Didn't flush before mutating vector" ) ? static_cast<void> (0) : __assert_fail ("GetNumBytesInBuffer() == 0 && \"Didn't flush before mutating vector\"" , "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn224007/lib/Support/raw_ostream.cpp" , 766, __PRETTY_FUNCTION__)); | |||
767 | ||||
768 | if (OS.capacity() - OS.size() < 64) | |||
769 | OS.reserve(OS.capacity() * 2); | |||
770 | SetBuffer(OS.end(), OS.capacity() - OS.size()); | |||
771 | } | |||
772 | ||||
773 | void raw_svector_ostream::write_impl(const char *Ptr, size_t Size) { | |||
774 | if (Ptr == OS.end()) { | |||
775 | // Grow the buffer to include the scratch area without copying. | |||
776 | size_t NewSize = OS.size() + Size; | |||
777 | assert(NewSize <= OS.capacity() && "Invalid write_impl() call!")((NewSize <= OS.capacity() && "Invalid write_impl() call!" ) ? static_cast<void> (0) : __assert_fail ("NewSize <= OS.capacity() && \"Invalid write_impl() call!\"" , "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn224007/lib/Support/raw_ostream.cpp" , 777, __PRETTY_FUNCTION__)); | |||
778 | OS.set_size(NewSize); | |||
779 | } else { | |||
780 | assert(!GetNumBytesInBuffer())((!GetNumBytesInBuffer()) ? static_cast<void> (0) : __assert_fail ("!GetNumBytesInBuffer()", "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn224007/lib/Support/raw_ostream.cpp" , 780, __PRETTY_FUNCTION__)); | |||
781 | OS.append(Ptr, Ptr + Size); | |||
782 | } | |||
783 | ||||
784 | OS.reserve(OS.size() + 64); | |||
785 | SetBuffer(OS.end(), OS.capacity() - OS.size()); | |||
786 | } | |||
787 | ||||
788 | uint64_t raw_svector_ostream::current_pos() const { | |||
789 | return OS.size(); | |||
790 | } | |||
791 | ||||
792 | StringRef raw_svector_ostream::str() { | |||
793 | flush(); | |||
794 | return StringRef(OS.begin(), OS.size()); | |||
795 | } | |||
796 | ||||
797 | //===----------------------------------------------------------------------===// | |||
798 | // raw_null_ostream | |||
799 | //===----------------------------------------------------------------------===// | |||
800 | ||||
801 | raw_null_ostream::~raw_null_ostream() { | |||
802 | #ifndef NDEBUG | |||
803 | // ~raw_ostream asserts that the buffer is empty. This isn't necessary | |||
804 | // with raw_null_ostream, but it's better to have raw_null_ostream follow | |||
805 | // the rules than to change the rules just for raw_null_ostream. | |||
806 | flush(); | |||
807 | #endif | |||
808 | } | |||
809 | ||||
810 | void raw_null_ostream::write_impl(const char *Ptr, size_t Size) { | |||
811 | } | |||
812 | ||||
813 | uint64_t raw_null_ostream::current_pos() const { | |||
814 | return 0; | |||
815 | } |