Bug Summary

File:src/gnu/usr.bin/clang/libLLVMSupport/../../../llvm/llvm/lib/Support/raw_ostream.cpp
Warning:line 295, column 5
Null pointer passed as 1st argument to memory copy function

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -cc1 -cc1 -triple amd64-unknown-openbsd7.0 -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name raw_ostream.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model static -mframe-pointer=all -relaxed-aliasing -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/usr/src/gnu/usr.bin/clang/libLLVMSupport/obj -resource-dir /usr/local/lib/clang/13.0.0 -I /usr/src/gnu/usr.bin/clang/libLLVMSupport/../../../llvm/llvm/include/llvm/ADT -I /usr/src/gnu/usr.bin/clang/libLLVMSupport/../../../llvm/llvm/include/llvm/Support -I /usr/src/gnu/usr.bin/clang/libLLVMSupport/../../../llvm/llvm/include -I /usr/src/gnu/usr.bin/clang/libLLVMSupport/../include -I /usr/src/gnu/usr.bin/clang/libLLVMSupport/obj -I /usr/src/gnu/usr.bin/clang/libLLVMSupport/obj/../include -D NDEBUG -D __STDC_LIMIT_MACROS -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D LLVM_PREFIX="/usr" -internal-isystem /usr/include/c++/v1 -internal-isystem /usr/local/lib/clang/13.0.0/include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-comment -std=c++14 -fdeprecated-macro -fdebug-compilation-dir=/usr/src/gnu/usr.bin/clang/libLLVMSupport/obj -ferror-limit 19 -fvisibility-inlines-hidden -fwrapv -stack-protector 2 -fno-rtti -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -fno-builtin-malloc -fno-builtin-calloc -fno-builtin-realloc -fno-builtin-valloc -fno-builtin-free -fno-builtin-strdup -fno-builtin-strndup -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /home/ben/Projects/vmm/scan-build/2022-01-12-194120-40624-1 -x c++ /usr/src/gnu/usr.bin/clang/libLLVMSupport/../../../llvm/llvm/lib/Support/raw_ostream.cpp

/usr/src/gnu/usr.bin/clang/libLLVMSupport/../../../llvm/llvm/lib/Support/raw_ostream.cpp

→
1//===--- raw_ostream.cpp - Implement the raw_ostream classes --------------===//
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// This implements support for bulk buffered stream output.
10//
11//===----------------------------------------------------------------------===//
12
13#include "llvm/Support/raw_ostream.h"
14#include "llvm/ADT/STLExtras.h"
15#include "llvm/ADT/StringExtras.h"
16#include "llvm/Config/config.h"
17#include "llvm/Support/Compiler.h"
18#include "llvm/Support/ErrorHandling.h"
19#include "llvm/Support/FileSystem.h"
20#include "llvm/Support/Format.h"
21#include "llvm/Support/FormatVariadic.h"
22#include "llvm/Support/MathExtras.h"
23#include "llvm/Support/NativeFormatting.h"
24#include "llvm/Support/Process.h"
25#include "llvm/Support/Program.h"
26#include <algorithm>
27#include <cctype>
28#include <cerrno>
29#include <cstdio>
30#include <iterator>
31#include <sys/stat.h>
32
33// <fcntl.h> may provide O_BINARY.
34#if defined(HAVE_FCNTL_H1)
35# include <fcntl.h>
36#endif
37
38#if defined(HAVE_UNISTD_H1)
39# include <unistd.h>
40#endif
41
42#if defined(__CYGWIN__)
43#include <io.h>
44#endif
45
46#if defined(_MSC_VER)
47#include <io.h>
48#ifndef STDIN_FILENO0
49# define STDIN_FILENO0 0
50#endif
51#ifndef STDOUT_FILENO1
52# define STDOUT_FILENO1 1
53#endif
54#ifndef STDERR_FILENO2
55# define STDERR_FILENO2 2
56#endif
57#endif
58
59#ifdef _WIN32
60#include "llvm/Support/ConvertUTF.h"
61#include "llvm/Support/Windows/WindowsSupport.h"
62#endif
63
64using namespace llvm;
65
66constexpr raw_ostream::Colors raw_ostream::BLACK;
67constexpr raw_ostream::Colors raw_ostream::RED;
68constexpr raw_ostream::Colors raw_ostream::GREEN;
69constexpr raw_ostream::Colors raw_ostream::YELLOW;
70constexpr raw_ostream::Colors raw_ostream::BLUE;
71constexpr raw_ostream::Colors raw_ostream::MAGENTA;
72constexpr raw_ostream::Colors raw_ostream::CYAN;
73constexpr raw_ostream::Colors raw_ostream::WHITE;
74constexpr raw_ostream::Colors raw_ostream::SAVEDCOLOR;
75constexpr raw_ostream::Colors raw_ostream::RESET;
76
77raw_ostream::~raw_ostream() {
78 // raw_ostream's subclasses should take care to flush the buffer
79 // in their destructors.
80 assert(OutBufCur == OutBufStart &&((void)0)
81 "raw_ostream destructor called with non-empty buffer!")((void)0);
82
83 if (BufferMode == BufferKind::InternalBuffer)
84 delete [] OutBufStart;
85}
86
87size_t raw_ostream::preferred_buffer_size() const {
88 // BUFSIZ is intended to be a reasonable default.
89 return BUFSIZ1024;
90}
91
92void raw_ostream::SetBuffered() {
93 // Ask the subclass to determine an appropriate buffer size.
94 if (size_t Size = preferred_buffer_size())
26
←
Assuming 'Size' is 0
→
27
←
Taking false branch
→
95 SetBufferSize(Size);
96 else
97 // It may return 0, meaning this stream should be unbuffered.
98 SetUnbuffered();
28
←
Calling 'raw_ostream::SetUnbuffered'
→
36
←
Returning from 'raw_ostream::SetUnbuffered'
→
99}
100
101void raw_ostream::SetBufferAndMode(char *BufferStart, size_t Size,
102 BufferKind Mode) {
103 assert(((Mode == BufferKind::Unbuffered && !BufferStart && Size == 0) ||((void)0)
104 (Mode != BufferKind::Unbuffered && BufferStart && Size != 0)) &&((void)0)
105 "stream must be unbuffered or have at least one byte")((void)0);
106 // Make sure the current buffer is free of content (we can't flush here; the
107 // child buffer management logic will be in write_impl).
108 assert(GetNumBytesInBuffer() == 0 && "Current buffer is non-empty!")((void)0);
109
110 if (BufferMode == BufferKind::InternalBuffer)
31
←
Assuming field 'BufferMode' is not equal to InternalBuffer
→
32
←
Taking false branch
→
111 delete [] OutBufStart;
112 OutBufStart = BufferStart;
33
←
Null pointer value stored to field 'OutBufStart'
→
113 OutBufEnd = OutBufStart+Size;
114 OutBufCur = OutBufStart;
34
←
Null pointer value stored to field 'OutBufCur'
→
115 BufferMode = Mode;
116
117 assert(OutBufStart <= OutBufEnd && "Invalid size!")((void)0);
118}
119
120raw_ostream &raw_ostream::operator<<(unsigned long N) {
121 write_integer(*this, static_cast<uint64_t>(N), 0, IntegerStyle::Integer);
122 return *this;
123}
124
125raw_ostream &raw_ostream::operator<<(long N) {
126 write_integer(*this, static_cast<int64_t>(N), 0, IntegerStyle::Integer);
127 return *this;
128}
129
130raw_ostream &raw_ostream::operator<<(unsigned long long N) {
131 write_integer(*this, static_cast<uint64_t>(N), 0, IntegerStyle::Integer);
132 return *this;
133}
134
135raw_ostream &raw_ostream::operator<<(long long N) {
136 write_integer(*this, static_cast<int64_t>(N), 0, IntegerStyle::Integer);
137 return *this;
138}
139
140raw_ostream &raw_ostream::write_hex(unsigned long long N) {
141 llvm::write_hex(*this, N, HexPrintStyle::Lower);
142 return *this;
143}
144
145raw_ostream &raw_ostream::operator<<(Colors C) {
146 if (C == Colors::RESET)
147 resetColor();
148 else
149 changeColor(C);
150 return *this;
151}
152
153raw_ostream &raw_ostream::write_uuid(const uuid_t UUID) {
154 for (int Idx = 0; Idx < 16; ++Idx) {
1
Loop condition is true. Entering loop body
→
155 *this << format("%02" PRIX32"X", UUID[Idx]);
2
←
Calling 'raw_ostream::operator<<'
→
156 if (Idx == 3 || Idx == 5 || Idx == 7 || Idx == 9)
157 *this << "-";
158 }
159 return *this;
160}
161
162
163raw_ostream &raw_ostream::write_escaped(StringRef Str,
164 bool UseHexEscapes) {
165 for (unsigned char c : Str) {
166 switch (c) {
167 case '\\':
168 *this << '\\' << '\\';
169 break;
170 case '\t':
171 *this << '\\' << 't';
172 break;
173 case '\n':
174 *this << '\\' << 'n';
175 break;
176 case '"':
177 *this << '\\' << '"';
178 break;
179 default:
180 if (isPrint(c)) {
181 *this << c;
182 break;
183 }
184
185 // Write out the escaped representation.
186 if (UseHexEscapes) {
187 *this << '\\' << 'x';
188 *this << hexdigit((c >> 4 & 0xF));
189 *this << hexdigit((c >> 0) & 0xF);
190 } else {
191 // Always use a full 3-character octal escape.
192 *this << '\\';
193 *this << char('0' + ((c >> 6) & 7));
194 *this << char('0' + ((c >> 3) & 7));
195 *this << char('0' + ((c >> 0) & 7));
196 }
197 }
198 }
199
200 return *this;
201}
202
203raw_ostream &raw_ostream::operator<<(const void *P) {
204 llvm::write_hex(*this, (uintptr_t)P, HexPrintStyle::PrefixLower);
205 return *this;
206}
207
208raw_ostream &raw_ostream::operator<<(double N) {
209 llvm::write_double(*this, N, FloatStyle::Exponent);
210 return *this;
211}
212
213void raw_ostream::flush_nonempty() {
214 assert(OutBufCur > OutBufStart && "Invalid call to flush_nonempty.")((void)0);
215 size_t Length = OutBufCur - OutBufStart;
216 OutBufCur = OutBufStart;
217 flush_tied_then_write(OutBufStart, Length);
218}
219
220raw_ostream &raw_ostream::write(unsigned char C) {
221 // Group exceptional cases into a single branch.
222 if (LLVM_UNLIKELY(OutBufCur >= OutBufEnd)__builtin_expect((bool)(OutBufCur >= OutBufEnd), false)) {
223 if (LLVM_UNLIKELY(!OutBufStart)__builtin_expect((bool)(!OutBufStart), false)) {
224 if (BufferMode == BufferKind::Unbuffered) {
225 flush_tied_then_write(reinterpret_cast<char *>(&C), 1);
226 return *this;
227 }
228 // Set up a buffer and start over.
229 SetBuffered();
230 return write(C);
231 }
232
233 flush_nonempty();
234 }
235
236 *OutBufCur++ = C;
237 return *this;
238}
239
240raw_ostream &raw_ostream::write(const char *Ptr, size_t Size) {
241 // Group exceptional cases into a single branch.
242 if (LLVM_UNLIKELY(size_t(OutBufEnd - OutBufCur) < Size)__builtin_expect((bool)(size_t(OutBufEnd - OutBufCur) < Size
), false)) {
19
←
Assuming the condition is true
→
20
←
Taking true branch
→
39
←
Assuming the condition is false
→
40
←
Taking false branch
→
243 if (LLVM_UNLIKELY(!OutBufStart)__builtin_expect((bool)(!OutBufStart), false)) {
21
←
Assuming field 'OutBufStart' is null
→
22
←
Taking true branch
→
244 if (BufferMode == BufferKind::Unbuffered) {
23
←
Assuming field 'BufferMode' is not equal to Unbuffered
→
24
←
Taking false branch
→
245 flush_tied_then_write(Ptr, Size);
246 return *this;
247 }
248 // Set up a buffer and start over.
249 SetBuffered();
25
←
Calling 'raw_ostream::SetBuffered'
→
37
←
Returning from 'raw_ostream::SetBuffered'
→
250 return write(Ptr, Size);
38
←
Calling 'raw_ostream::write'
→
251 }
252
253 size_t NumBytes = OutBufEnd - OutBufCur;
254
255 // If the buffer is empty at this point we have a string that is larger
256 // than the buffer. Directly write the chunk that is a multiple of the
257 // preferred buffer size and put the remainder in the buffer.
258 if (LLVM_UNLIKELY(OutBufCur == OutBufStart)__builtin_expect((bool)(OutBufCur == OutBufStart), false)) {
259 assert(NumBytes != 0 && "undefined behavior")((void)0);
260 size_t BytesToWrite = Size - (Size % NumBytes);
261 flush_tied_then_write(Ptr, BytesToWrite);
262 size_t BytesRemaining = Size - BytesToWrite;
263 if (BytesRemaining > size_t(OutBufEnd - OutBufCur)) {
264 // Too much left over to copy into our buffer.
265 return write(Ptr + BytesToWrite, BytesRemaining);
266 }
267 copy_to_buffer(Ptr + BytesToWrite, BytesRemaining);
268 return *this;
269 }
270
271 // We don't have enough space in the buffer to fit the string in. Insert as
272 // much as possible, flush and start over with the remainder.
273 copy_to_buffer(Ptr, NumBytes);
274 flush_nonempty();
275 return write(Ptr + NumBytes, Size - NumBytes);
276 }
277
278 copy_to_buffer(Ptr, Size);
41
←
Calling 'raw_ostream::copy_to_buffer'
→
279
280 return *this;
281}
282
283void raw_ostream::copy_to_buffer(const char *Ptr, size_t Size) {
284 assert(Size <= size_t(OutBufEnd - OutBufCur) && "Buffer overrun!")((void)0);
285
286 // Handle short strings specially, memcpy isn't very good at very short
287 // strings.
288 switch (Size) {
42
←
Control jumps to the 'default' case at line 294
→
289 case 4: OutBufCur[3] = Ptr[3]; LLVM_FALLTHROUGH[[gnu::fallthrough]];
290 case 3: OutBufCur[2] = Ptr[2]; LLVM_FALLTHROUGH[[gnu::fallthrough]];
291 case 2: OutBufCur[1] = Ptr[1]; LLVM_FALLTHROUGH[[gnu::fallthrough]];
292 case 1: OutBufCur[0] = Ptr[0]; LLVM_FALLTHROUGH[[gnu::fallthrough]];
293 case 0: break;
294 default:
295 memcpy(OutBufCur, Ptr, Size);
43
←
Null pointer passed as 1st argument to memory copy function
296 break;
297 }
298
299 OutBufCur += Size;
300}
301
302void raw_ostream::flush_tied_then_write(const char *Ptr, size_t Size) {
303 if (TiedStream)
304 TiedStream->flush();
305 write_impl(Ptr, Size);
306}
307
308// Formatted output.
309raw_ostream &raw_ostream::operator<<(const format_object_base &Fmt) {
310 // If we have more than a few bytes left in our output buffer, try
311 // formatting directly onto its end.
312 size_t NextBufferSize = 127;
313 size_t BufferBytesLeft = OutBufEnd - OutBufCur;
314 if (BufferBytesLeft > 3) {
3
←
Assuming 'BufferBytesLeft' is <= 3
→
4
←
Taking false branch
→
315 size_t BytesUsed = Fmt.print(OutBufCur, BufferBytesLeft);
316
317 // Common case is that we have plenty of space.
318 if (BytesUsed <= BufferBytesLeft) {
319 OutBufCur += BytesUsed;
320 return *this;
321 }
322
323 // Otherwise, we overflowed and the return value tells us the size to try
324 // again with.
325 NextBufferSize = BytesUsed;
326 }
327
328 // If we got here, we didn't have enough space in the output buffer for the
329 // string. Try printing into a SmallVector that is resized to have enough
330 // space. Iterate until we win.
331 SmallVector<char, 128> V;
332
333 while (true) {
5
←
Loop condition is true. Entering loop body
→
8
←
Loop condition is true. Entering loop body
→
334 V.resize(NextBufferSize);
335
336 // Try formatting into the SmallVector.
337 size_t BytesUsed = Fmt.print(V.data(), NextBufferSize);
9
←
Calling 'format_object_base::print'
→
15
←
Returning from 'format_object_base::print'
→
338
339 // If BytesUsed fit into the vector, we win.
340 if (BytesUsed <= NextBufferSize)
6
←
Assuming 'BytesUsed' is > 'NextBufferSize'
→
7
←
Taking false branch
→
16
←
Assuming 'BytesUsed' is <= 'NextBufferSize'
→
17
←
Taking true branch
→
341 return write(V.data(), BytesUsed);
18
←
Calling 'raw_ostream::write'
→
342
343 // Otherwise, try again with a new size.
344 assert(BytesUsed > NextBufferSize && "Didn't grow buffer!?")((void)0);
345 NextBufferSize = BytesUsed;
346 }
347}
348
349raw_ostream &raw_ostream::operator<<(const formatv_object_base &Obj) {
350 Obj.format(*this);
351 return *this;
352}
353
354raw_ostream &raw_ostream::operator<<(const FormattedString &FS) {
355 unsigned LeftIndent = 0;
356 unsigned RightIndent = 0;
357 const ssize_t Difference = FS.Width - FS.Str.size();
358 if (Difference > 0) {
359 switch (FS.Justify) {
360 case FormattedString::JustifyNone:
361 break;
362 case FormattedString::JustifyLeft:
363 RightIndent = Difference;
364 break;
365 case FormattedString::JustifyRight:
366 LeftIndent = Difference;
367 break;
368 case FormattedString::JustifyCenter:
369 LeftIndent = Difference / 2;
370 RightIndent = Difference - LeftIndent;
371 break;
372 }
373 }
374 indent(LeftIndent);
375 (*this) << FS.Str;
376 indent(RightIndent);
377 return *this;
378}
379
380raw_ostream &raw_ostream::operator<<(const FormattedNumber &FN) {
381 if (FN.Hex) {
382 HexPrintStyle Style;
383 if (FN.Upper && FN.HexPrefix)
384 Style = HexPrintStyle::PrefixUpper;
385 else if (FN.Upper && !FN.HexPrefix)
386 Style = HexPrintStyle::Upper;
387 else if (!FN.Upper && FN.HexPrefix)
388 Style = HexPrintStyle::PrefixLower;
389 else
390 Style = HexPrintStyle::Lower;
391 llvm::write_hex(*this, FN.HexValue, Style, FN.Width);
392 } else {
393 llvm::SmallString<16> Buffer;
394 llvm::raw_svector_ostream Stream(Buffer);
395 llvm::write_integer(Stream, FN.DecValue, 0, IntegerStyle::Integer);
396 if (Buffer.size() < FN.Width)
397 indent(FN.Width - Buffer.size());
398 (*this) << Buffer;
399 }
400 return *this;
401}
402
403raw_ostream &raw_ostream::operator<<(const FormattedBytes &FB) {
404 if (FB.Bytes.empty())
405 return *this;
406
407 size_t LineIndex = 0;
408 auto Bytes = FB.Bytes;
409 const size_t Size = Bytes.size();
410 HexPrintStyle HPS = FB.Upper ? HexPrintStyle::Upper : HexPrintStyle::Lower;
411 uint64_t OffsetWidth = 0;
412 if (FB.FirstByteOffset.hasValue()) {
413 // Figure out how many nibbles are needed to print the largest offset
414 // represented by this data set, so that we can align the offset field
415 // to the right width.
416 size_t Lines = Size / FB.NumPerLine;
417 uint64_t MaxOffset = *FB.FirstByteOffset + Lines * FB.NumPerLine;
418 unsigned Power = 0;
419 if (MaxOffset > 0)
420 Power = llvm::Log2_64_Ceil(MaxOffset);
421 OffsetWidth = std::max<uint64_t>(4, llvm::alignTo(Power, 4) / 4);
422 }
423
424 // The width of a block of data including all spaces for group separators.
425 unsigned NumByteGroups =
426 alignTo(FB.NumPerLine, FB.ByteGroupSize) / FB.ByteGroupSize;
427 unsigned BlockCharWidth = FB.NumPerLine * 2 + NumByteGroups - 1;
428
429 while (!Bytes.empty()) {
430 indent(FB.IndentLevel);
431
432 if (FB.FirstByteOffset.hasValue()) {
433 uint64_t Offset = FB.FirstByteOffset.getValue();
434 llvm::write_hex(*this, Offset + LineIndex, HPS, OffsetWidth);
435 *this << ": ";
436 }
437
438 auto Line = Bytes.take_front(FB.NumPerLine);
439
440 size_t CharsPrinted = 0;
441 // Print the hex bytes for this line in groups
442 for (size_t I = 0; I < Line.size(); ++I, CharsPrinted += 2) {
443 if (I && (I % FB.ByteGroupSize) == 0) {
444 ++CharsPrinted;
445 *this << " ";
446 }
447 llvm::write_hex(*this, Line[I], HPS, 2);
448 }
449
450 if (FB.ASCII) {
451 // Print any spaces needed for any bytes that we didn't print on this
452 // line so that the ASCII bytes are correctly aligned.
453 assert(BlockCharWidth >= CharsPrinted)((void)0);
454 indent(BlockCharWidth - CharsPrinted + 2);
455 *this << "|";
456
457 // Print the ASCII char values for each byte on this line
458 for (uint8_t Byte : Line) {
459 if (isPrint(Byte))
460 *this << static_cast<char>(Byte);
461 else
462 *this << '.';
463 }
464 *this << '|';
465 }
466
467 Bytes = Bytes.drop_front(Line.size());
468 LineIndex += Line.size();
469 if (LineIndex < Size)
470 *this << '\n';
471 }
472 return *this;
473}
474
475template <char C>
476static raw_ostream &write_padding(raw_ostream &OS, unsigned NumChars) {
477 static const char Chars[] = {C, C, C, C, C, C, C, C, C, C, C, C, C, C, C, C,
478 C, C, C, C, C, C, C, C, C, C, C, C, C, C, C, C,
479 C, C, C, C, C, C, C, C, C, C, C, C, C, C, C, C,
480 C, C, C, C, C, C, C, C, C, C, C, C, C, C, C, C,
481 C, C, C, C, C, C, C, C, C, C, C, C, C, C, C, C};
482
483 // Usually the indentation is small, handle it with a fastpath.
484 if (NumChars < array_lengthof(Chars))
485 return OS.write(Chars, NumChars);
486
487 while (NumChars) {
488 unsigned NumToWrite = std::min(NumChars,
489 (unsigned)array_lengthof(Chars)-1);
490 OS.write(Chars, NumToWrite);
491 NumChars -= NumToWrite;
492 }
493 return OS;
494}
495
496/// indent - Insert 'NumSpaces' spaces.
497raw_ostream &raw_ostream::indent(unsigned NumSpaces) {
498 return write_padding<' '>(*this, NumSpaces);
499}
500
501/// write_zeros - Insert 'NumZeros' nulls.
502raw_ostream &raw_ostream::write_zeros(unsigned NumZeros) {
503 return write_padding<'\0'>(*this, NumZeros);
504}
505
506bool raw_ostream::prepare_colors() {
507 // Colors were explicitly disabled.
508 if (!ColorEnabled)
509 return false;
510
511 // Colors require changing the terminal but this stream is not going to a
512 // terminal.
513 if (sys::Process::ColorNeedsFlush() && !is_displayed())
514 return false;
515
516 if (sys::Process::ColorNeedsFlush())
517 flush();
518
519 return true;
520}
521
522raw_ostream &raw_ostream::changeColor(enum Colors colors, bool bold, bool bg) {
523 if (!prepare_colors())
524 return *this;
525
526 const char *colorcode =
527 (colors == SAVEDCOLOR)
528 ? sys::Process::OutputBold(bg)
529 : sys::Process::OutputColor(static_cast<char>(colors), bold, bg);
530 if (colorcode)
531 write(colorcode, strlen(colorcode));
532 return *this;
533}
534
535raw_ostream &raw_ostream::resetColor() {
536 if (!prepare_colors())
537 return *this;
538
539 if (const char *colorcode = sys::Process::ResetColor())
540 write(colorcode, strlen(colorcode));
541 return *this;
542}
543
544raw_ostream &raw_ostream::reverseColor() {
545 if (!prepare_colors())
546 return *this;
547
548 if (const char *colorcode = sys::Process::OutputReverse())
549 write(colorcode, strlen(colorcode));
550 return *this;
551}
552
553void raw_ostream::anchor() {}
554
555//===----------------------------------------------------------------------===//
556// Formatted Output
557//===----------------------------------------------------------------------===//
558
559// Out of line virtual method.
560void format_object_base::home() {
561}
562
563//===----------------------------------------------------------------------===//
564// raw_fd_ostream
565//===----------------------------------------------------------------------===//
566
567static int getFD(StringRef Filename, std::error_code &EC,
568 sys::fs::CreationDisposition Disp, sys::fs::FileAccess Access,
569 sys::fs::OpenFlags Flags) {
570 assert((Access & sys::fs::FA_Write) &&((void)0)
571 "Cannot make a raw_ostream from a read-only descriptor!")((void)0);
572
573 // Handle "-" as stdout. Note that when we do this, we consider ourself
574 // the owner of stdout and may set the "binary" flag globally based on Flags.
575 if (Filename == "-") {
576 EC = std::error_code();
577 // Change stdout's text/binary mode based on the Flags.
578 sys::ChangeStdoutMode(Flags);
579 return STDOUT_FILENO1;
580 }
581
582 int FD;
583 if (Access & sys::fs::FA_Read)
584 EC = sys::fs::openFileForReadWrite(Filename, FD, Disp, Flags);
585 else
586 EC = sys::fs::openFileForWrite(Filename, FD, Disp, Flags);
587 if (EC)
588 return -1;
589
590 return FD;
591}
592
593raw_fd_ostream::raw_fd_ostream(StringRef Filename, std::error_code &EC)
594 : raw_fd_ostream(Filename, EC, sys::fs::CD_CreateAlways, sys::fs::FA_Write,
595 sys::fs::OF_None) {}
596
597raw_fd_ostream::raw_fd_ostream(StringRef Filename, std::error_code &EC,
598 sys::fs::CreationDisposition Disp)
599 : raw_fd_ostream(Filename, EC, Disp, sys::fs::FA_Write, sys::fs::OF_None) {}
600
601raw_fd_ostream::raw_fd_ostream(StringRef Filename, std::error_code &EC,
602 sys::fs::FileAccess Access)
603 : raw_fd_ostream(Filename, EC, sys::fs::CD_CreateAlways, Access,
604 sys::fs::OF_None) {}
605
606raw_fd_ostream::raw_fd_ostream(StringRef Filename, std::error_code &EC,
607 sys::fs::OpenFlags Flags)
608 : raw_fd_ostream(Filename, EC, sys::fs::CD_CreateAlways, sys::fs::FA_Write,
609 Flags) {}
610
611raw_fd_ostream::raw_fd_ostream(StringRef Filename, std::error_code &EC,
612 sys::fs::CreationDisposition Disp,
613 sys::fs::FileAccess Access,
614 sys::fs::OpenFlags Flags)
615 : raw_fd_ostream(getFD(Filename, EC, Disp, Access, Flags), true) {}
616
617/// FD is the file descriptor that this writes to. If ShouldClose is true, this
618/// closes the file when the stream is destroyed.
619raw_fd_ostream::raw_fd_ostream(int fd, bool shouldClose, bool unbuffered,
620 OStreamKind K)
621 : raw_pwrite_stream(unbuffered, K), FD(fd), ShouldClose(shouldClose) {
622 if (FD < 0 ) {
623 ShouldClose = false;
624 return;
625 }
626
627 enable_colors(true);
628
629 // Do not attempt to close stdout or stderr. We used to try to maintain the
630 // property that tools that support writing file to stdout should not also
631 // write informational output to stdout, but in practice we were never able to
632 // maintain this invariant. Many features have been added to LLVM and clang
633 // (-fdump-record-layouts, optimization remarks, etc) that print to stdout, so
634 // users must simply be aware that mixed output and remarks is a possibility.
635 if (FD <= STDERR_FILENO2)
636 ShouldClose = false;
637
638#ifdef _WIN32
639 // Check if this is a console device. This is not equivalent to isatty.
640 IsWindowsConsole =
641 ::GetFileType((HANDLE)::_get_osfhandle(fd)) == FILE_TYPE_CHAR;
642#endif
643
644 // Get the starting position.
645 off_t loc = ::lseek(FD, 0, SEEK_CUR1);
646#ifdef _WIN32
647 // MSVCRT's _lseek(SEEK_CUR) doesn't return -1 for pipes.
648 sys::fs::file_status Status;
649 std::error_code EC = status(FD, Status);
650 SupportsSeeking = !EC && Status.type() == sys::fs::file_type::regular_file;
651#else
652 SupportsSeeking = loc != (off_t)-1;
653#endif
654 if (!SupportsSeeking)
655 pos = 0;
656 else
657 pos = static_cast<uint64_t>(loc);
658}
659
660raw_fd_ostream::~raw_fd_ostream() {
661 if (FD >= 0) {
662 flush();
663 if (ShouldClose) {
664 if (auto EC = sys::Process::SafelyCloseFileDescriptor(FD))
665 error_detected(EC);
666 }
667 }
668
669#ifdef __MINGW32__
670 // On mingw, global dtors should not call exit().
671 // report_fatal_error() invokes exit(). We know report_fatal_error()
672 // might not write messages to stderr when any errors were detected
673 // on FD == 2.
674 if (FD == 2) return;
675#endif
676
677 // If there are any pending errors, report them now. Clients wishing
678 // to avoid report_fatal_error calls should check for errors with
679 // has_error() and clear the error flag with clear_error() before
680 // destructing raw_ostream objects which may have errors.
681 if (has_error())
682 report_fatal_error("IO failure on output stream: " + error().message(),
683 /*gen_crash_diag=*/false);
684}
685
686#if defined(_WIN32)
687// The most reliable way to print unicode in a Windows console is with
688// WriteConsoleW. To use that, first transcode from UTF-8 to UTF-16. This
689// assumes that LLVM programs always print valid UTF-8 to the console. The data
690// might not be UTF-8 for two major reasons:
691// 1. The program is printing binary (-filetype=obj -o -), in which case it
692// would have been gibberish anyway.
693// 2. The program is printing text in a semi-ascii compatible codepage like
694// shift-jis or cp1252.
695//
696// Most LLVM programs don't produce non-ascii text unless they are quoting
697// user source input. A well-behaved LLVM program should either validate that
698// the input is UTF-8 or transcode from the local codepage to UTF-8 before
699// quoting it. If they don't, this may mess up the encoding, but this is still
700// probably the best compromise we can make.
701static bool write_console_impl(int FD, StringRef Data) {
702 SmallVector<wchar_t, 256> WideText;
703
704 // Fall back to ::write if it wasn't valid UTF-8.
705 if (auto EC = sys::windows::UTF8ToUTF16(Data, WideText))
706 return false;
707
708 // On Windows 7 and earlier, WriteConsoleW has a low maximum amount of data
709 // that can be written to the console at a time.
710 size_t MaxWriteSize = WideText.size();
711 if (!RunningWindows8OrGreater())
712 MaxWriteSize = 32767;
713
714 size_t WCharsWritten = 0;
715 do {
716 size_t WCharsToWrite =
717 std::min(MaxWriteSize, WideText.size() - WCharsWritten);
718 DWORD ActuallyWritten;
719 bool Success =
720 ::WriteConsoleW((HANDLE)::_get_osfhandle(FD), &WideText[WCharsWritten],
721 WCharsToWrite, &ActuallyWritten,
722 /*Reserved=*/nullptr);
723
724 // The most likely reason for WriteConsoleW to fail is that FD no longer
725 // points to a console. Fall back to ::write. If this isn't the first loop
726 // iteration, something is truly wrong.
727 if (!Success)
728 return false;
729
730 WCharsWritten += ActuallyWritten;
731 } while (WCharsWritten != WideText.size());
732 return true;
733}
734#endif
735
736void raw_fd_ostream::write_impl(const char *Ptr, size_t Size) {
737 assert(FD >= 0 && "File already closed.")((void)0);
738 pos += Size;
739
740#if defined(_WIN32)
741 // If this is a Windows console device, try re-encoding from UTF-8 to UTF-16
742 // and using WriteConsoleW. If that fails, fall back to plain write().
743 if (IsWindowsConsole)
744 if (write_console_impl(FD, StringRef(Ptr, Size)))
745 return;
746#endif
747
748 // The maximum write size is limited to INT32_MAX. A write
749 // greater than SSIZE_MAX is implementation-defined in POSIX,
750 // and Windows _write requires 32 bit input.
751 size_t MaxWriteSize = INT32_MAX0x7fffffff;
752
753#if defined(__linux__)
754 // It is observed that Linux returns EINVAL for a very large write (>2G).
755 // Make it a reasonably small value.
756 MaxWriteSize = 1024 * 1024 * 1024;
757#endif
758
759 do {
760 size_t ChunkSize = std::min(Size, MaxWriteSize);
761 ssize_t ret = ::write(FD, Ptr, ChunkSize);
762
763 if (ret < 0) {
764 // If it's a recoverable error, swallow it and retry the write.
765 //
766 // Ideally we wouldn't ever see EAGAIN or EWOULDBLOCK here, since
767 // raw_ostream isn't designed to do non-blocking I/O. However, some
768 // programs, such as old versions of bjam, have mistakenly used
769 // O_NONBLOCK. For compatibility, emulate blocking semantics by
770 // spinning until the write succeeds. If you don't want spinning,
771 // don't use O_NONBLOCK file descriptors with raw_ostream.
772 if (errno(*__errno()) == EINTR4 || errno(*__errno()) == EAGAIN35
773#ifdef EWOULDBLOCK35
774 || errno(*__errno()) == EWOULDBLOCK35
775#endif
776 )
777 continue;
778
779 // Otherwise it's a non-recoverable error. Note it and quit.
780 error_detected(std::error_code(errno(*__errno()), std::generic_category()));
781 break;
782 }
783
784 // The write may have written some or all of the data. Update the
785 // size and buffer pointer to reflect the remainder that needs
786 // to be written. If there are no bytes left, we're done.
787 Ptr += ret;
788 Size -= ret;
789 } while (Size > 0);
790}
791
792void raw_fd_ostream::close() {
793 assert(ShouldClose)((void)0);
794 ShouldClose = false;
795 flush();
796 if (auto EC = sys::Process::SafelyCloseFileDescriptor(FD))
797 error_detected(EC);
798 FD = -1;
799}
800
801uint64_t raw_fd_ostream::seek(uint64_t off) {
802 assert(SupportsSeeking && "Stream does not support seeking!")((void)0);
803 flush();
804#ifdef _WIN32
805 pos = ::_lseeki64(FD, off, SEEK_SET0);
806#elif defined(HAVE_LSEEK64)
807 pos = ::lseek64(FD, off, SEEK_SET0);
808#else
809 pos = ::lseek(FD, off, SEEK_SET0);
810#endif
811 if (pos == (uint64_t)-1)
812 error_detected(std::error_code(errno(*__errno()), std::generic_category()));
813 return pos;
814}
815
816void raw_fd_ostream::pwrite_impl(const char *Ptr, size_t Size,
817 uint64_t Offset) {
818 uint64_t Pos = tell();
819 seek(Offset);
820 write(Ptr, Size);
821 seek(Pos);
822}
823
824size_t raw_fd_ostream::preferred_buffer_size() const {
825#if defined(_WIN32)
826 // Disable buffering for console devices. Console output is re-encoded from
827 // UTF-8 to UTF-16 on Windows, and buffering it would require us to split the
828 // buffer on a valid UTF-8 codepoint boundary. Terminal buffering is disabled
829 // below on most other OSs, so do the same thing on Windows and avoid that
830 // complexity.
831 if (IsWindowsConsole)
832 return 0;
833 return raw_ostream::preferred_buffer_size();
834#elif !defined(__minix)
835 // Minix has no st_blksize.
836 assert(FD >= 0 && "File not yet open!")((void)0);
837 struct stat statbuf;
838 if (fstat(FD, &statbuf) != 0)
839 return 0;
840
841 // If this is a terminal, don't use buffering. Line buffering
842 // would be a more traditional thing to do, but it's not worth
843 // the complexity.
844 if (S_ISCHR(statbuf.st_mode)((statbuf.st_mode & 0170000) == 0020000) && is_displayed())
845 return 0;
846 // Return the preferred block size.
847 return statbuf.st_blksize;
848#else
849 return raw_ostream::preferred_buffer_size();
850#endif
851}
852
853bool raw_fd_ostream::is_displayed() const {
854 return sys::Process::FileDescriptorIsDisplayed(FD);
855}
856
857bool raw_fd_ostream::has_colors() const {
858 if (!HasColors)
859 HasColors = sys::Process::FileDescriptorHasColors(FD);
860 return *HasColors;
861}
862
863Expected<sys::fs::FileLocker> raw_fd_ostream::lock() {
864 std::error_code EC = sys::fs::lockFile(FD);
865 if (!EC)
866 return sys::fs::FileLocker(FD);
867 return errorCodeToError(EC);
868}
869
870Expected<sys::fs::FileLocker>
871raw_fd_ostream::tryLockFor(std::chrono::milliseconds Timeout) {
872 std::error_code EC = sys::fs::tryLockFile(FD, Timeout);
873 if (!EC)
874 return sys::fs::FileLocker(FD);
875 return errorCodeToError(EC);
876}
877
878void raw_fd_ostream::anchor() {}
879
880//===----------------------------------------------------------------------===//
881// outs(), errs(), nulls()
882//===----------------------------------------------------------------------===//
883
884raw_fd_ostream &llvm::outs() {
885 // Set buffer settings to model stdout behavior.
886 std::error_code EC;
887 static raw_fd_ostream S("-", EC, sys::fs::OF_None);
888 assert(!EC)((void)0);
889 return S;
890}
891
892raw_fd_ostream &llvm::errs() {
893 // Set standard error to be unbuffered and tied to outs() by default.
894 static raw_fd_ostream S(STDERR_FILENO2, false, true);
895 return S;
896}
897
898/// nulls() - This returns a reference to a raw_ostream which discards output.
899raw_ostream &llvm::nulls() {
900 static raw_null_ostream S;
901 return S;
902}
903
904//===----------------------------------------------------------------------===//
905// File Streams
906//===----------------------------------------------------------------------===//
907
908raw_fd_stream::raw_fd_stream(StringRef Filename, std::error_code &EC)
909 : raw_fd_ostream(getFD(Filename, EC, sys::fs::CD_CreateAlways,
910 sys::fs::FA_Write | sys::fs::FA_Read,
911 sys::fs::OF_None),
912 true, false, OStreamKind::OK_FDStream) {
913 if (EC)
914 return;
915
916 // Do not support non-seekable files.
917 if (!supportsSeeking())
918 EC = std::make_error_code(std::errc::invalid_argument);
919}
920
921ssize_t raw_fd_stream::read(char *Ptr, size_t Size) {
922 assert(get_fd() >= 0 && "File already closed.")((void)0);
923 ssize_t Ret = ::read(get_fd(), (void *)Ptr, Size);
924 if (Ret >= 0)
925 inc_pos(Ret);
926 else
927 error_detected(std::error_code(errno(*__errno()), std::generic_category()));
928 return Ret;
929}
930
931bool raw_fd_stream::classof(const raw_ostream *OS) {
932 return OS->get_kind() == OStreamKind::OK_FDStream;
933}
934
935//===----------------------------------------------------------------------===//
936// raw_string_ostream
937//===----------------------------------------------------------------------===//
938
939raw_string_ostream::~raw_string_ostream() {
940 flush();
941}
942
943void raw_string_ostream::write_impl(const char *Ptr, size_t Size) {
944 OS.append(Ptr, Size);
945}
946
947//===----------------------------------------------------------------------===//
948// raw_svector_ostream
949//===----------------------------------------------------------------------===//
950
951uint64_t raw_svector_ostream::current_pos() const { return OS.size(); }
952
953void raw_svector_ostream::write_impl(const char *Ptr, size_t Size) {
954 OS.append(Ptr, Ptr + Size);
955}
956
957void raw_svector_ostream::pwrite_impl(const char *Ptr, size_t Size,
958 uint64_t Offset) {
959 memcpy(OS.data() + Offset, Ptr, Size);
960}
961
962//===----------------------------------------------------------------------===//
963// raw_null_ostream
964//===----------------------------------------------------------------------===//
965
966raw_null_ostream::~raw_null_ostream() {
967#ifndef NDEBUG1
968 // ~raw_ostream asserts that the buffer is empty. This isn't necessary
969 // with raw_null_ostream, but it's better to have raw_null_ostream follow
970 // the rules than to change the rules just for raw_null_ostream.
971 flush();
972#endif
973}
974
975void raw_null_ostream::write_impl(const char *Ptr, size_t Size) {
976}
977
978uint64_t raw_null_ostream::current_pos() const {
979 return 0;
980}
981
982void raw_null_ostream::pwrite_impl(const char *Ptr, size_t Size,
983 uint64_t Offset) {}
984
985void raw_pwrite_stream::anchor() {}
986
987void buffer_ostream::anchor() {}
988
989void buffer_unique_ostream::anchor() {}
990
991Error llvm::writeToOutput(StringRef OutputFileName,
992 std::function<Error(raw_ostream &)> Write) {
993 if (OutputFileName == "-")
994 return Write(outs());
995
996 if (OutputFileName == "/dev/null") {
997 raw_null_ostream Out;
998 return Write(Out);
999 }
1000
1001 unsigned Mode = sys::fs::all_read | sys::fs::all_write | sys::fs::all_exe;
1002 Expected<sys::fs::TempFile> Temp =
1003 sys::fs::TempFile::create(OutputFileName + ".temp-stream-%%%%%%", Mode);
1004 if (!Temp)
1005 return createFileError(OutputFileName, Temp.takeError());
1006
1007 raw_fd_ostream Out(Temp->FD, false);
1008
1009 if (Error E = Write(Out)) {
1010 if (Error DiscardError = Temp->discard())
1011 return joinErrors(std::move(E), std::move(DiscardError));
1012 return E;
1013 }
1014 Out.flush();
1015
1016 return Temp->keep(OutputFileName);
1017}
←

/usr/src/gnu/usr.bin/clang/libLLVMSupport/../../../llvm/llvm/include/llvm/Support/Format.h

→
1//===- Format.h - Efficient printf-style formatting for streams -*- 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// This file implements the format() function, which can be used with other
10// LLVM subsystems to provide printf-style formatting. This gives all the power
11// and risk of printf. This can be used like this (with raw_ostreams as an
12// example):
13//
14// OS << "mynumber: " << format("%4.5f", 1234.412) << '\n';
15//
16// Or if you prefer:
17//
18// OS << format("mynumber: %4.5f\n", 1234.412);
19//
20//===----------------------------------------------------------------------===//
21
22#ifndef LLVM_SUPPORT_FORMAT_H
23#define LLVM_SUPPORT_FORMAT_H
24
25#include "llvm/ADT/ArrayRef.h"
26#include "llvm/ADT/STLExtras.h"
27#include "llvm/ADT/StringRef.h"
28#include "llvm/Support/DataTypes.h"
29#include <cassert>
30#include <cstdio>
31#include <tuple>
32#include <utility>
33
34namespace llvm {
35
36/// This is a helper class used for handling formatted output. It is the
37/// abstract base class of a templated derived class.
38class format_object_base {
39protected:
40 const char *Fmt;
41 ~format_object_base() = default; // Disallow polymorphic deletion.
42 format_object_base(const format_object_base &) = default;
43 virtual void home(); // Out of line virtual method.
44
45 /// Call snprintf() for this object, on the given buffer and size.
46 virtual int snprint(char *Buffer, unsigned BufferSize) const = 0;
47
48public:
49 format_object_base(const char *fmt) : Fmt(fmt) {}
50
51 /// Format the object into the specified buffer. On success, this returns
52 /// the length of the formatted string. If the buffer is too small, this
53 /// returns a length to retry with, which will be larger than BufferSize.
54 unsigned print(char *Buffer, unsigned BufferSize) const {
55 assert(BufferSize && "Invalid buffer size!")((void)0);
56
57 // Print the string, leaving room for the terminating null.
58 int N = snprint(Buffer, BufferSize);
59
60 // VC++ and old GlibC return negative on overflow, just double the size.
61 if (N < 0)
10
←
Assuming 'N' is >= 0
→
11
←
Taking false branch
→
62 return BufferSize * 2;
63
64 // Other implementations yield number of bytes needed, not including the
65 // final '\0'.
66 if (unsigned(N) >= BufferSize)
12
←
Assuming 'N' is >= 'BufferSize'
→
13
←
Taking true branch
→
67 return N + 1;
14
←
Returning value, which participates in a condition later
→
68
69 // Otherwise N is the length of output (not including the final '\0').
70 return N;
71 }
72};
73
74/// These are templated helper classes used by the format function that
75/// capture the object to be formatted and the format string. When actually
76/// printed, this synthesizes the string into a temporary buffer provided and
77/// returns whether or not it is big enough.
78
79// Helper to validate that format() parameters are scalars or pointers.
80template <typename... Args> struct validate_format_parameters;
81template <typename Arg, typename... Args>
82struct validate_format_parameters<Arg, Args...> {
83 static_assert(std::is_scalar<Arg>::value,
84 "format can't be used with non fundamental / non pointer type");
85 validate_format_parameters() { validate_format_parameters<Args...>(); }
86};
87template <> struct validate_format_parameters<> {};
88
89template <typename... Ts>
90class format_object final : public format_object_base {
91 std::tuple<Ts...> Vals;
92
93 template <std::size_t... Is>
94 int snprint_tuple(char *Buffer, unsigned BufferSize,
95 std::index_sequence<Is...>) const {
96#ifdef _MSC_VER
97 return _snprintf(Buffer, BufferSize, Fmt, std::get<Is>(Vals)...);
98#else
99 return snprintf(Buffer, BufferSize, Fmt, std::get<Is>(Vals)...);
100#endif
101 }
102
103public:
104 format_object(const char *fmt, const Ts &... vals)
105 : format_object_base(fmt), Vals(vals...) {
106 validate_format_parameters<Ts...>();
107 }
108
109 int snprint(char *Buffer, unsigned BufferSize) const override {
110 return snprint_tuple(Buffer, BufferSize, std::index_sequence_for<Ts...>());
111 }
112};
113
114/// These are helper functions used to produce formatted output. They use
115/// template type deduction to construct the appropriate instance of the
116/// format_object class to simplify their construction.
117///
118/// This is typically used like:
119/// \code
120/// OS << format("%0.4f", myfloat) << '\n';
121/// \endcode
122
123template <typename... Ts>
124inline format_object<Ts...> format(const char *Fmt, const Ts &... Vals) {
125 return format_object<Ts...>(Fmt, Vals...);
126}
127
128/// This is a helper class for left_justify, right_justify, and center_justify.
129class FormattedString {
130public:
131 enum Justification { JustifyNone, JustifyLeft, JustifyRight, JustifyCenter };
132 FormattedString(StringRef S, unsigned W, Justification J)
133 : Str(S), Width(W), Justify(J) {}
134
135private:
136 StringRef Str;
137 unsigned Width;
138 Justification Justify;
139 friend class raw_ostream;
140};
141
142/// left_justify - append spaces after string so total output is
143/// \p Width characters. If \p Str is larger that \p Width, full string
144/// is written with no padding.
145inline FormattedString left_justify(StringRef Str, unsigned Width) {
146 return FormattedString(Str, Width, FormattedString::JustifyLeft);
147}
148
149/// right_justify - add spaces before string so total output is
150/// \p Width characters. If \p Str is larger that \p Width, full string
151/// is written with no padding.
152inline FormattedString right_justify(StringRef Str, unsigned Width) {
153 return FormattedString(Str, Width, FormattedString::JustifyRight);
154}
155
156/// center_justify - add spaces before and after string so total output is
157/// \p Width characters. If \p Str is larger that \p Width, full string
158/// is written with no padding.
159inline FormattedString center_justify(StringRef Str, unsigned Width) {
160 return FormattedString(Str, Width, FormattedString::JustifyCenter);
161}
162
163/// This is a helper class used for format_hex() and format_decimal().
164class FormattedNumber {
165 uint64_t HexValue;
166 int64_t DecValue;
167 unsigned Width;
168 bool Hex;
169 bool Upper;
170 bool HexPrefix;
171 friend class raw_ostream;
172
173public:
174 FormattedNumber(uint64_t HV, int64_t DV, unsigned W, bool H, bool U,
175 bool Prefix)
176 : HexValue(HV), DecValue(DV), Width(W), Hex(H), Upper(U),
177 HexPrefix(Prefix) {}
178};
179
180/// format_hex - Output \p N as a fixed width hexadecimal. If number will not
181/// fit in width, full number is still printed. Examples:
182/// OS << format_hex(255, 4) => 0xff
183/// OS << format_hex(255, 4, true) => 0xFF
184/// OS << format_hex(255, 6) => 0x00ff
185/// OS << format_hex(255, 2) => 0xff
186inline FormattedNumber format_hex(uint64_t N, unsigned Width,
187 bool Upper = false) {
188 assert(Width <= 18 && "hex width must be <= 18")((void)0);
189 return FormattedNumber(N, 0, Width, true, Upper, true);
190}
191
192/// format_hex_no_prefix - Output \p N as a fixed width hexadecimal. Does not
193/// prepend '0x' to the outputted string. If number will not fit in width,
194/// full number is still printed. Examples:
195/// OS << format_hex_no_prefix(255, 2) => ff
196/// OS << format_hex_no_prefix(255, 2, true) => FF
197/// OS << format_hex_no_prefix(255, 4) => 00ff
198/// OS << format_hex_no_prefix(255, 1) => ff
199inline FormattedNumber format_hex_no_prefix(uint64_t N, unsigned Width,
200 bool Upper = false) {
201 assert(Width <= 16 && "hex width must be <= 16")((void)0);
202 return FormattedNumber(N, 0, Width, true, Upper, false);
203}
204
205/// format_decimal - Output \p N as a right justified, fixed-width decimal. If
206/// number will not fit in width, full number is still printed. Examples:
207/// OS << format_decimal(0, 5) => " 0"
208/// OS << format_decimal(255, 5) => " 255"
209/// OS << format_decimal(-1, 3) => " -1"
210/// OS << format_decimal(12345, 3) => "12345"
211inline FormattedNumber format_decimal(int64_t N, unsigned Width) {
212 return FormattedNumber(0, N, Width, false, false, false);
213}
214
215class FormattedBytes {
216 ArrayRef<uint8_t> Bytes;
217
218 // If not None, display offsets for each line relative to starting value.
219 Optional<uint64_t> FirstByteOffset;
220 uint32_t IndentLevel; // Number of characters to indent each line.
221 uint32_t NumPerLine; // Number of bytes to show per line.
222 uint8_t ByteGroupSize; // How many hex bytes are grouped without spaces
223 bool Upper; // Show offset and hex bytes as upper case.
224 bool ASCII; // Show the ASCII bytes for the hex bytes to the right.
225 friend class raw_ostream;
226
227public:
228 FormattedBytes(ArrayRef<uint8_t> B, uint32_t IL, Optional<uint64_t> O,
229 uint32_t NPL, uint8_t BGS, bool U, bool A)
230 : Bytes(B), FirstByteOffset(O), IndentLevel(IL), NumPerLine(NPL),
231 ByteGroupSize(BGS), Upper(U), ASCII(A) {
232
233 if (ByteGroupSize > NumPerLine)
234 ByteGroupSize = NumPerLine;
235 }
236};
237
238inline FormattedBytes
239format_bytes(ArrayRef<uint8_t> Bytes, Optional<uint64_t> FirstByteOffset = None,
240 uint32_t NumPerLine = 16, uint8_t ByteGroupSize = 4,
241 uint32_t IndentLevel = 0, bool Upper = false) {
242 return FormattedBytes(Bytes, IndentLevel, FirstByteOffset, NumPerLine,
243 ByteGroupSize, Upper, false);
244}
245
246inline FormattedBytes
247format_bytes_with_ascii(ArrayRef<uint8_t> Bytes,
248 Optional<uint64_t> FirstByteOffset = None,
249 uint32_t NumPerLine = 16, uint8_t ByteGroupSize = 4,
250 uint32_t IndentLevel = 0, bool Upper = false) {
251 return FormattedBytes(Bytes, IndentLevel, FirstByteOffset, NumPerLine,
252 ByteGroupSize, Upper, true);
253}
254
255} // end namespace llvm
256
257#endif
←

/usr/src/gnu/usr.bin/clang/libLLVMSupport/../../../llvm/llvm/include/llvm/Support/raw_ostream.h

1//===--- raw_ostream.h - Raw output stream ----------------------*- 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// This file defines the raw_ostream class.
10//
11//===----------------------------------------------------------------------===//
12
13#ifndef LLVM_SUPPORT_RAW_OSTREAM_H
14#define LLVM_SUPPORT_RAW_OSTREAM_H
15
16#include "llvm/ADT/SmallVector.h"
17#include "llvm/ADT/StringRef.h"
18#include "llvm/Support/DataTypes.h"
19#include <cassert>
20#include <chrono>
21#include <cstddef>
22#include <cstdint>
23#include <cstring>
24#include <string>
25#if __cplusplus201402L > 201402L
26#include <string_view>
27#endif
28#include <system_error>
29#include <type_traits>
30
31namespace llvm {
32
33class formatv_object_base;
34class format_object_base;
35class FormattedString;
36class FormattedNumber;
37class FormattedBytes;
38template <class T> class LLVM_NODISCARD[[clang::warn_unused_result]] Expected;
39
40namespace sys {
41namespace fs {
42enum FileAccess : unsigned;
43enum OpenFlags : unsigned;
44enum CreationDisposition : unsigned;
45class FileLocker;
46} // end namespace fs
47} // end namespace sys
48
49/// This class implements an extremely fast bulk output stream that can *only*
50/// output to a stream. It does not support seeking, reopening, rewinding, line
51/// buffered disciplines etc. It is a simple buffer that outputs
52/// a chunk at a time.
53class raw_ostream {
54public:
55 // Class kinds to support LLVM-style RTTI.
56 enum class OStreamKind {
57 OK_OStream,
58 OK_FDStream,
59 };
60
61private:
62 OStreamKind Kind;
63
64 /// The buffer is handled in such a way that the buffer is
65 /// uninitialized, unbuffered, or out of space when OutBufCur >=
66 /// OutBufEnd. Thus a single comparison suffices to determine if we
67 /// need to take the slow path to write a single character.
68 ///
69 /// The buffer is in one of three states:
70 /// 1. Unbuffered (BufferMode == Unbuffered)
71 /// 1. Uninitialized (BufferMode != Unbuffered && OutBufStart == 0).
72 /// 2. Buffered (BufferMode != Unbuffered && OutBufStart != 0 &&
73 /// OutBufEnd - OutBufStart >= 1).
74 ///
75 /// If buffered, then the raw_ostream owns the buffer if (BufferMode ==
76 /// InternalBuffer); otherwise the buffer has been set via SetBuffer and is
77 /// managed by the subclass.
78 ///
79 /// If a subclass installs an external buffer using SetBuffer then it can wait
80 /// for a \see write_impl() call to handle the data which has been put into
81 /// this buffer.
82 char *OutBufStart, *OutBufEnd, *OutBufCur;
83 bool ColorEnabled = false;
84
85 /// Optional stream this stream is tied to. If this stream is written to, the
86 /// tied-to stream will be flushed first.
87 raw_ostream *TiedStream = nullptr;
88
89 enum class BufferKind {
90 Unbuffered = 0,
91 InternalBuffer,
92 ExternalBuffer
93 } BufferMode;
94
95public:
96 // color order matches ANSI escape sequence, don't change
97 enum class Colors {
98 BLACK = 0,
99 RED,
100 GREEN,
101 YELLOW,
102 BLUE,
103 MAGENTA,
104 CYAN,
105 WHITE,
106 SAVEDCOLOR,
107 RESET,
108 };
109
110 static constexpr Colors BLACK = Colors::BLACK;
111 static constexpr Colors RED = Colors::RED;
112 static constexpr Colors GREEN = Colors::GREEN;
113 static constexpr Colors YELLOW = Colors::YELLOW;
114 static constexpr Colors BLUE = Colors::BLUE;
115 static constexpr Colors MAGENTA = Colors::MAGENTA;
116 static constexpr Colors CYAN = Colors::CYAN;
117 static constexpr Colors WHITE = Colors::WHITE;
118 static constexpr Colors SAVEDCOLOR = Colors::SAVEDCOLOR;
119 static constexpr Colors RESET = Colors::RESET;
120
121 explicit raw_ostream(bool unbuffered = false,
122 OStreamKind K = OStreamKind::OK_OStream)
123 : Kind(K), BufferMode(unbuffered ? BufferKind::Unbuffered
124 : BufferKind::InternalBuffer) {
125 // Start out ready to flush.
126 OutBufStart = OutBufEnd = OutBufCur = nullptr;
127 }
128
129 raw_ostream(const raw_ostream &) = delete;
130 void operator=(const raw_ostream &) = delete;
131
132 virtual ~raw_ostream();
133
134 /// tell - Return the current offset with the file.
135 uint64_t tell() const { return current_pos() + GetNumBytesInBuffer(); }
136
137 OStreamKind get_kind() const { return Kind; }
138
139 //===--------------------------------------------------------------------===//
140 // Configuration Interface
141 //===--------------------------------------------------------------------===//
142
143 /// If possible, pre-allocate \p ExtraSize bytes for stream data.
144 /// i.e. it extends internal buffers to keep additional ExtraSize bytes.
145 /// So that the stream could keep at least tell() + ExtraSize bytes
146 /// without re-allocations. reserveExtraSpace() does not change
147 /// the size/data of the stream.
148 virtual void reserveExtraSpace(uint64_t ExtraSize) {}
149
150 /// Set the stream to be buffered, with an automatically determined buffer
151 /// size.
152 void SetBuffered();
153
154 /// Set the stream to be buffered, using the specified buffer size.
155 void SetBufferSize(size_t Size) {
156 flush();
157 SetBufferAndMode(new char[Size], Size, BufferKind::InternalBuffer);
158 }
159
160 size_t GetBufferSize() const {
161 // If we're supposed to be buffered but haven't actually gotten around
162 // to allocating the buffer yet, return the value that would be used.
163 if (BufferMode != BufferKind::Unbuffered && OutBufStart == nullptr)
164 return preferred_buffer_size();
165
166 // Otherwise just return the size of the allocated buffer.
167 return OutBufEnd - OutBufStart;
168 }
169
170 /// Set the stream to be unbuffered. When unbuffered, the stream will flush
171 /// after every write. This routine will also flush the buffer immediately
172 /// when the stream is being set to unbuffered.
173 void SetUnbuffered() {
174 flush();
175 SetBufferAndMode(nullptr, 0, BufferKind::Unbuffered);
29
←
Passing null pointer value via 1st parameter 'BufferStart'
→
30
←
Calling 'raw_ostream::SetBufferAndMode'
→
35
←
Returning from 'raw_ostream::SetBufferAndMode'
→
176 }
177
178 size_t GetNumBytesInBuffer() const {
179 return OutBufCur - OutBufStart;
180 }
181
182 //===--------------------------------------------------------------------===//
183 // Data Output Interface
184 //===--------------------------------------------------------------------===//
185
186 void flush() {
187 if (OutBufCur != OutBufStart)
188 flush_nonempty();
189 }
190
191 raw_ostream &operator<<(char C) {
192 if (OutBufCur >= OutBufEnd)
193 return write(C);
194 *OutBufCur++ = C;
195 return *this;
196 }
197
198 raw_ostream &operator<<(unsigned char C) {
199 if (OutBufCur >= OutBufEnd)
200 return write(C);
201 *OutBufCur++ = C;
202 return *this;
203 }
204
205 raw_ostream &operator<<(signed char C) {
206 if (OutBufCur >= OutBufEnd)
207 return write(C);
208 *OutBufCur++ = C;
209 return *this;
210 }
211
212 raw_ostream &operator<<(StringRef Str) {
213 // Inline fast path, particularly for strings with a known length.
214 size_t Size = Str.size();
215
216 // Make sure we can use the fast path.
217 if (Size > (size_t)(OutBufEnd - OutBufCur))
218 return write(Str.data(), Size);
219
220 if (Size) {
221 memcpy(OutBufCur, Str.data(), Size);
222 OutBufCur += Size;
223 }
224 return *this;
225 }
226
227 raw_ostream &operator<<(const char *Str) {
228 // Inline fast path, particularly for constant strings where a sufficiently
229 // smart compiler will simplify strlen.
230
231 return this->operator<<(StringRef(Str));
232 }
233
234 raw_ostream &operator<<(const std::string &Str) {
235 // Avoid the fast path, it would only increase code size for a marginal win.
236 return write(Str.data(), Str.length());
237 }
238
239#if __cplusplus201402L > 201402L
240 raw_ostream &operator<<(const std::string_view &Str) {
241 return write(Str.data(), Str.length());
242 }
243#endif
244
245 raw_ostream &operator<<(const SmallVectorImpl<char> &Str) {
246 return write(Str.data(), Str.size());
247 }
248
249 raw_ostream &operator<<(unsigned long N);
250 raw_ostream &operator<<(long N);
251 raw_ostream &operator<<(unsigned long long N);
252 raw_ostream &operator<<(long long N);
253 raw_ostream &operator<<(const void *P);
254
255 raw_ostream &operator<<(unsigned int N) {
256 return this->operator<<(static_cast<unsigned long>(N));
257 }
258
259 raw_ostream &operator<<(int N) {
260 return this->operator<<(static_cast<long>(N));
261 }
262
263 raw_ostream &operator<<(double N);
264
265 /// Output \p N in hexadecimal, without any prefix or padding.
266 raw_ostream &write_hex(unsigned long long N);
267
268 // Change the foreground color of text.
269 raw_ostream &operator<<(Colors C);
270
271 /// Output a formatted UUID with dash separators.
272 using uuid_t = uint8_t[16];
273 raw_ostream &write_uuid(const uuid_t UUID);
274
275 /// Output \p Str, turning '\\', '\t', '\n', '"', and anything that doesn't
276 /// satisfy llvm::isPrint into an escape sequence.
277 raw_ostream &write_escaped(StringRef Str, bool UseHexEscapes = false);
278
279 raw_ostream &write(unsigned char C);
280 raw_ostream &write(const char *Ptr, size_t Size);
281
282 // Formatted output, see the format() function in Support/Format.h.
283 raw_ostream &operator<<(const format_object_base &Fmt);
284
285 // Formatted output, see the leftJustify() function in Support/Format.h.
286 raw_ostream &operator<<(const FormattedString &);
287
288 // Formatted output, see the formatHex() function in Support/Format.h.
289 raw_ostream &operator<<(const FormattedNumber &);
290
291 // Formatted output, see the formatv() function in Support/FormatVariadic.h.
292 raw_ostream &operator<<(const formatv_object_base &);
293
294 // Formatted output, see the format_bytes() function in Support/Format.h.
295 raw_ostream &operator<<(const FormattedBytes &);
296
297 /// indent - Insert 'NumSpaces' spaces.
298 raw_ostream &indent(unsigned NumSpaces);
299
300 /// write_zeros - Insert 'NumZeros' nulls.
301 raw_ostream &write_zeros(unsigned NumZeros);
302
303 /// Changes the foreground color of text that will be output from this point
304 /// forward.
305 /// @param Color ANSI color to use, the special SAVEDCOLOR can be used to
306 /// change only the bold attribute, and keep colors untouched
307 /// @param Bold bold/brighter text, default false
308 /// @param BG if true change the background, default: change foreground
309 /// @returns itself so it can be used within << invocations
310 virtual raw_ostream &changeColor(enum Colors Color, bool Bold = false,
311 bool BG = false);
312
313 /// Resets the colors to terminal defaults. Call this when you are done
314 /// outputting colored text, or before program exit.
315 virtual raw_ostream &resetColor();
316
317 /// Reverses the foreground and background colors.
318 virtual raw_ostream &reverseColor();
319
320 /// This function determines if this stream is connected to a "tty" or
321 /// "console" window. That is, the output would be displayed to the user
322 /// rather than being put on a pipe or stored in a file.
323 virtual bool is_displayed() const { return false; }
324
325 /// This function determines if this stream is displayed and supports colors.
326 /// The result is unaffected by calls to enable_color().
327 virtual bool has_colors() const { return is_displayed(); }
328
329 // Enable or disable colors. Once enable_colors(false) is called,
330 // changeColor() has no effect until enable_colors(true) is called.
331 virtual void enable_colors(bool enable) { ColorEnabled = enable; }
332
333 /// Tie this stream to the specified stream. Replaces any existing tied-to
334 /// stream. Specifying a nullptr unties the stream.
335 void tie(raw_ostream *TieTo) { TiedStream = TieTo; }
336
337 //===--------------------------------------------------------------------===//
338 // Subclass Interface
339 //===--------------------------------------------------------------------===//
340
341private:
342 /// The is the piece of the class that is implemented by subclasses. This
343 /// writes the \p Size bytes starting at
344 /// \p Ptr to the underlying stream.
345 ///
346 /// This function is guaranteed to only be called at a point at which it is
347 /// safe for the subclass to install a new buffer via SetBuffer.
348 ///
349 /// \param Ptr The start of the data to be written. For buffered streams this
350 /// is guaranteed to be the start of the buffer.
351 ///
352 /// \param Size The number of bytes to be written.
353 ///
354 /// \invariant { Size > 0 }
355 virtual void write_impl(const char *Ptr, size_t Size) = 0;
356
357 /// Return the current position within the stream, not counting the bytes
358 /// currently in the buffer.
359 virtual uint64_t current_pos() const = 0;
360
361protected:
362 /// Use the provided buffer as the raw_ostream buffer. This is intended for
363 /// use only by subclasses which can arrange for the output to go directly
364 /// into the desired output buffer, instead of being copied on each flush.
365 void SetBuffer(char *BufferStart, size_t Size) {
366 SetBufferAndMode(BufferStart, Size, BufferKind::ExternalBuffer);
367 }
368
369 /// Return an efficient buffer size for the underlying output mechanism.
370 virtual size_t preferred_buffer_size() const;
371
372 /// Return the beginning of the current stream buffer, or 0 if the stream is
373 /// unbuffered.
374 const char *getBufferStart() const { return OutBufStart; }
375
376 //===--------------------------------------------------------------------===//
377 // Private Interface
378 //===--------------------------------------------------------------------===//
379private:
380 /// Install the given buffer and mode.
381 void SetBufferAndMode(char *BufferStart, size_t Size, BufferKind Mode);
382
383 /// Flush the current buffer, which is known to be non-empty. This outputs the
384 /// currently buffered data and resets the buffer to empty.
385 void flush_nonempty();
386
387 /// Copy data into the buffer. Size must not be greater than the number of
388 /// unused bytes in the buffer.
389 void copy_to_buffer(const char *Ptr, size_t Size);
390
391 /// Compute whether colors should be used and do the necessary work such as
392 /// flushing. The result is affected by calls to enable_color().
393 bool prepare_colors();
394
395 /// Flush the tied-to stream (if present) and then write the required data.
396 void flush_tied_then_write(const char *Ptr, size_t Size);
397
398 virtual void anchor();
399};
400
401/// Call the appropriate insertion operator, given an rvalue reference to a
402/// raw_ostream object and return a stream of the same type as the argument.
403template <typename OStream, typename T>
404std::enable_if_t<!std::is_reference<OStream>::value &&
405 std::is_base_of<raw_ostream, OStream>::value,
406 OStream &&>
407operator<<(OStream &&OS, const T &Value) {
408 OS << Value;
409 return std::move(OS);
410}
411
412/// An abstract base class for streams implementations that also support a
413/// pwrite operation. This is useful for code that can mostly stream out data,
414/// but needs to patch in a header that needs to know the output size.
415class raw_pwrite_stream : public raw_ostream {
416 virtual void pwrite_impl(const char *Ptr, size_t Size, uint64_t Offset) = 0;
417 void anchor() override;
418
419public:
420 explicit raw_pwrite_stream(bool Unbuffered = false,
421 OStreamKind K = OStreamKind::OK_OStream)
422 : raw_ostream(Unbuffered, K) {}
423 void pwrite(const char *Ptr, size_t Size, uint64_t Offset) {
424#ifndef NDEBUG1
425 uint64_t Pos = tell();
426 // /dev/null always reports a pos of 0, so we cannot perform this check
427 // in that case.
428 if (Pos)
429 assert(Size + Offset <= Pos && "We don't support extending the stream")((void)0);
430#endif
431 pwrite_impl(Ptr, Size, Offset);
432 }
433};
434
435//===----------------------------------------------------------------------===//
436// File Output Streams
437//===----------------------------------------------------------------------===//
438
439/// A raw_ostream that writes to a file descriptor.
440///
441class raw_fd_ostream : public raw_pwrite_stream {
442 int FD;
443 bool ShouldClose;
444 bool SupportsSeeking = false;
445 mutable Optional<bool> HasColors;
446
447#ifdef _WIN32
448 /// True if this fd refers to a Windows console device. Mintty and other
449 /// terminal emulators are TTYs, but they are not consoles.
450 bool IsWindowsConsole = false;
451#endif
452
453 std::error_code EC;
454
455 uint64_t pos = 0;
456
457 /// See raw_ostream::write_impl.
458 void write_impl(const char *Ptr, size_t Size) override;
459
460 void pwrite_impl(const char *Ptr, size_t Size, uint64_t Offset) override;
461
462 /// Return the current position within the stream, not counting the bytes
463 /// currently in the buffer.
464 uint64_t current_pos() const override { return pos; }
465
466 /// Determine an efficient buffer size.
467 size_t preferred_buffer_size() const override;
468
469 void anchor() override;
470
471protected:
472 /// Set the flag indicating that an output error has been encountered.
473 void error_detected(std::error_code EC) { this->EC = EC; }
474
475 /// Return the file descriptor.
476 int get_fd() const { return FD; }
477
478 // Update the file position by increasing \p Delta.
479 void inc_pos(uint64_t Delta) { pos += Delta; }
480
481public:
482 /// Open the specified file for writing. If an error occurs, information
483 /// about the error is put into EC, and the stream should be immediately
484 /// destroyed;
485 /// \p Flags allows optional flags to control how the file will be opened.
486 ///
487 /// As a special case, if Filename is "-", then the stream will use
488 /// STDOUT_FILENO instead of opening a file. This will not close the stdout
489 /// descriptor.
490 raw_fd_ostream(StringRef Filename, std::error_code &EC);
491 raw_fd_ostream(StringRef Filename, std::error_code &EC,
492 sys::fs::CreationDisposition Disp);
493 raw_fd_ostream(StringRef Filename, std::error_code &EC,
494 sys::fs::FileAccess Access);
495 raw_fd_ostream(StringRef Filename, std::error_code &EC,
496 sys::fs::OpenFlags Flags);
497 raw_fd_ostream(StringRef Filename, std::error_code &EC,
498 sys::fs::CreationDisposition Disp, sys::fs::FileAccess Access,
499 sys::fs::OpenFlags Flags);
500
501 /// FD is the file descriptor that this writes to. If ShouldClose is true,
502 /// this closes the file when the stream is destroyed. If FD is for stdout or
503 /// stderr, it will not be closed.
504 raw_fd_ostream(int fd, bool shouldClose, bool unbuffered = false,
505 OStreamKind K = OStreamKind::OK_OStream);
506
507 ~raw_fd_ostream() override;
508
509 /// Manually flush the stream and close the file. Note that this does not call
510 /// fsync.
511 void close();
512
513 bool supportsSeeking() const { return SupportsSeeking; }
514
515 /// Flushes the stream and repositions the underlying file descriptor position
516 /// to the offset specified from the beginning of the file.
517 uint64_t seek(uint64_t off);
518
519 bool is_displayed() const override;
520
521 bool has_colors() const override;
522
523 std::error_code error() const { return EC; }
524
525 /// Return the value of the flag in this raw_fd_ostream indicating whether an
526 /// output error has been encountered.
527 /// This doesn't implicitly flush any pending output. Also, it doesn't
528 /// guarantee to detect all errors unless the stream has been closed.
529 bool has_error() const { return bool(EC); }
530
531 /// Set the flag read by has_error() to false. If the error flag is set at the
532 /// time when this raw_ostream's destructor is called, report_fatal_error is
533 /// called to report the error. Use clear_error() after handling the error to
534 /// avoid this behavior.
535 ///
536 /// "Errors should never pass silently.
537 /// Unless explicitly silenced."
538 /// - from The Zen of Python, by Tim Peters
539 ///
540 void clear_error() { EC = std::error_code(); }
541
542 /// Locks the underlying file.
543 ///
544 /// @returns RAII object that releases the lock upon leaving the scope, if the
545 /// locking was successful. Otherwise returns corresponding
546 /// error code.
547 ///
548 /// The function blocks the current thread until the lock become available or
549 /// error occurs.
550 ///
551 /// Possible use of this function may be as follows:
552 ///
553 /// @code{.cpp}
554 /// if (auto L = stream.lock()) {
555 /// // ... do action that require file to be locked.
556 /// } else {
557 /// handleAllErrors(std::move(L.takeError()), [&](ErrorInfoBase &EIB) {
558 /// // ... handle lock error.
559 /// });
560 /// }
561 /// @endcode
562 LLVM_NODISCARD[[clang::warn_unused_result]] Expected<sys::fs::FileLocker> lock();
563
564 /// Tries to lock the underlying file within the specified period.
565 ///
566 /// @returns RAII object that releases the lock upon leaving the scope, if the
567 /// locking was successful. Otherwise returns corresponding
568 /// error code.
569 ///
570 /// It is used as @ref lock.
571 LLVM_NODISCARD[[clang::warn_unused_result]]
572 Expected<sys::fs::FileLocker> tryLockFor(std::chrono::milliseconds Timeout);
573};
574
575/// This returns a reference to a raw_fd_ostream for standard output. Use it
576/// like: outs() << "foo" << "bar";
577raw_fd_ostream &outs();
578
579/// This returns a reference to a raw_ostream for standard error.
580/// Use it like: errs() << "foo" << "bar";
581/// By default, the stream is tied to stdout to ensure stdout is flushed before
582/// stderr is written, to ensure the error messages are written in their
583/// expected place.
584raw_fd_ostream &errs();
585
586/// This returns a reference to a raw_ostream which simply discards output.
587raw_ostream &nulls();
588
589//===----------------------------------------------------------------------===//
590// File Streams
591//===----------------------------------------------------------------------===//
592
593/// A raw_ostream of a file for reading/writing/seeking.
594///
595class raw_fd_stream : public raw_fd_ostream {
596public:
597 /// Open the specified file for reading/writing/seeking. If an error occurs,
598 /// information about the error is put into EC, and the stream should be
599 /// immediately destroyed.
600 raw_fd_stream(StringRef Filename, std::error_code &EC);
601
602 /// This reads the \p Size bytes into a buffer pointed by \p Ptr.
603 ///
604 /// \param Ptr The start of the buffer to hold data to be read.
605 ///
606 /// \param Size The number of bytes to be read.
607 ///
608 /// On success, the number of bytes read is returned, and the file position is
609 /// advanced by this number. On error, -1 is returned, use error() to get the
610 /// error code.
611 ssize_t read(char *Ptr, size_t Size);
612
613 /// Check if \p OS is a pointer of type raw_fd_stream*.
614 static bool classof(const raw_ostream *OS);
615};
616
617//===----------------------------------------------------------------------===//
618// Output Stream Adaptors
619//===----------------------------------------------------------------------===//
620
621/// A raw_ostream that writes to an std::string. This is a simple adaptor
622/// class. This class does not encounter output errors.
623class raw_string_ostream : public raw_ostream {
624 std::string &OS;
625
626 /// See raw_ostream::write_impl.
627 void write_impl(const char *Ptr, size_t Size) override;
628
629 /// Return the current position within the stream, not counting the bytes
630 /// currently in the buffer.
631 uint64_t current_pos() const override { return OS.size(); }
632
633public:
634 explicit raw_string_ostream(std::string &O) : OS(O) {
635 SetUnbuffered();
636 }
637 ~raw_string_ostream() override;
638
639 /// Flushes the stream contents to the target string and returns the string's
640 /// reference.
641 std::string& str() {
642 flush();
643 return OS;
644 }
645
646 void reserveExtraSpace(uint64_t ExtraSize) override {
647 OS.reserve(tell() + ExtraSize);
648 }
649};
650
651/// A raw_ostream that writes to an SmallVector or SmallString. This is a
652/// simple adaptor class. This class does not encounter output errors.
653/// raw_svector_ostream operates without a buffer, delegating all memory
654/// management to the SmallString. Thus the SmallString is always up-to-date,
655/// may be used directly and there is no need to call flush().
656class raw_svector_ostream : public raw_pwrite_stream {
657 SmallVectorImpl<char> &OS;
658
659 /// See raw_ostream::write_impl.
660 void write_impl(const char *Ptr, size_t Size) override;
661
662 void pwrite_impl(const char *Ptr, size_t Size, uint64_t Offset) override;
663
664 /// Return the current position within the stream.
665 uint64_t current_pos() const override;
666
667public:
668 /// Construct a new raw_svector_ostream.
669 ///
670 /// \param O The vector to write to; this should generally have at least 128
671 /// bytes free to avoid any extraneous memory overhead.
672 explicit raw_svector_ostream(SmallVectorImpl<char> &O) : OS(O) {
673 SetUnbuffered();
674 }
675
676 ~raw_svector_ostream() override = default;
677
678 void flush() = delete;
679
680 /// Return a StringRef for the vector contents.
681 StringRef str() const { return StringRef(OS.data(), OS.size()); }
682
683 void reserveExtraSpace(uint64_t ExtraSize) override {
684 OS.reserve(tell() + ExtraSize);
685 }
686};
687
688/// A raw_ostream that discards all output.
689class raw_null_ostream : public raw_pwrite_stream {
690 /// See raw_ostream::write_impl.
691 void write_impl(const char *Ptr, size_t size) override;
692 void pwrite_impl(const char *Ptr, size_t Size, uint64_t Offset) override;
693
694 /// Return the current position within the stream, not counting the bytes
695 /// currently in the buffer.
696 uint64_t current_pos() const override;
697
698public:
699 explicit raw_null_ostream() = default;
700 ~raw_null_ostream() override;
701};
702
703class buffer_ostream : public raw_svector_ostream {
704 raw_ostream &OS;
705 SmallVector<char, 0> Buffer;
706
707 virtual void anchor() override;
708
709public:
710 buffer_ostream(raw_ostream &OS) : raw_svector_ostream(Buffer), OS(OS) {}
711 ~buffer_ostream() override { OS << str(); }
712};
713
714class buffer_unique_ostream : public raw_svector_ostream {
715 std::unique_ptr<raw_ostream> OS;
716 SmallVector<char, 0> Buffer;
717
718 virtual void anchor() override;
719
720public:
721 buffer_unique_ostream(std::unique_ptr<raw_ostream> OS)
722 : raw_svector_ostream(Buffer), OS(std::move(OS)) {}
723 ~buffer_unique_ostream() override { *OS << str(); }
724};
725
726class Error;
727
728/// This helper creates an output stream and then passes it to \p Write.
729/// The stream created is based on the specified \p OutputFileName:
730/// llvm::outs for "-", raw_null_ostream for "/dev/null", and raw_fd_ostream
731/// for other names. For raw_fd_ostream instances, the stream writes to
732/// a temporary file. The final output file is atomically replaced with the
733/// temporary file after the \p Write function is finished.
734Error writeToOutput(StringRef OutputFileName,
735 std::function<Error(raw_ostream &)> Write);
736
737} // end namespace llvm
738
739#endif // LLVM_SUPPORT_RAW_OSTREAM_H