LLVM  8.0.0svn
raw_ostream.cpp
Go to the documentation of this file.
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 
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"
22 #include "llvm/Support/Format.h"
26 #include "llvm/Support/Process.h"
27 #include "llvm/Support/Program.h"
28 #include <algorithm>
29 #include <cctype>
30 #include <cerrno>
31 #include <cstdio>
32 #include <iterator>
33 #include <sys/stat.h>
34 #include <system_error>
35 
36 // <fcntl.h> may provide O_BINARY.
37 #if defined(HAVE_FCNTL_H)
38 # include <fcntl.h>
39 #endif
40 
41 #if defined(HAVE_UNISTD_H)
42 # include <unistd.h>
43 #endif
44 
45 #if defined(__CYGWIN__)
46 #include <io.h>
47 #endif
48 
49 #if defined(_MSC_VER)
50 #include <io.h>
51 #ifndef STDIN_FILENO
52 # define STDIN_FILENO 0
53 #endif
54 #ifndef STDOUT_FILENO
55 # define STDOUT_FILENO 1
56 #endif
57 #ifndef STDERR_FILENO
58 # define STDERR_FILENO 2
59 #endif
60 #endif
61 
62 #ifdef _WIN32
64 #include "Windows/WindowsSupport.h"
65 #endif
66 
67 using namespace llvm;
68 
70  // raw_ostream's subclasses should take care to flush the buffer
71  // in their destructors.
72  assert(OutBufCur == OutBufStart &&
73  "raw_ostream destructor called with non-empty buffer!");
74 
75  if (BufferMode == InternalBuffer)
76  delete [] OutBufStart;
77 }
78 
80  // BUFSIZ is intended to be a reasonable default.
81  return BUFSIZ;
82 }
83 
85  // Ask the subclass to determine an appropriate buffer size.
86  if (size_t Size = preferred_buffer_size())
88  else
89  // It may return 0, meaning this stream should be unbuffered.
90  SetUnbuffered();
91 }
92 
93 void raw_ostream::SetBufferAndMode(char *BufferStart, size_t Size,
94  BufferKind Mode) {
95  assert(((Mode == Unbuffered && !BufferStart && Size == 0) ||
96  (Mode != Unbuffered && BufferStart && Size != 0)) &&
97  "stream must be unbuffered or have at least one byte");
98  // Make sure the current buffer is free of content (we can't flush here; the
99  // child buffer management logic will be in write_impl).
100  assert(GetNumBytesInBuffer() == 0 && "Current buffer is non-empty!");
101 
102  if (BufferMode == InternalBuffer)
103  delete [] OutBufStart;
104  OutBufStart = BufferStart;
105  OutBufEnd = OutBufStart+Size;
106  OutBufCur = OutBufStart;
107  BufferMode = Mode;
108 
109  assert(OutBufStart <= OutBufEnd && "Invalid size!");
110 }
111 
113  write_integer(*this, static_cast<uint64_t>(N), 0, IntegerStyle::Integer);
114  return *this;
115 }
116 
118  write_integer(*this, static_cast<int64_t>(N), 0, IntegerStyle::Integer);
119  return *this;
120 }
121 
122 raw_ostream &raw_ostream::operator<<(unsigned long long N) {
123  write_integer(*this, static_cast<uint64_t>(N), 0, IntegerStyle::Integer);
124  return *this;
125 }
126 
128  write_integer(*this, static_cast<int64_t>(N), 0, IntegerStyle::Integer);
129  return *this;
130 }
131 
132 raw_ostream &raw_ostream::write_hex(unsigned long long N) {
134  return *this;
135 }
136 
138  for (int Idx = 0; Idx < 16; ++Idx) {
139  *this << format("%02" PRIX32, UUID[Idx]);
140  if (Idx == 3 || Idx == 5 || Idx == 7 || Idx == 9)
141  *this << "-";
142  }
143  return *this;
144 }
145 
146 
148  bool UseHexEscapes) {
149  for (unsigned char c : Str) {
150  switch (c) {
151  case '\\':
152  *this << '\\' << '\\';
153  break;
154  case '\t':
155  *this << '\\' << 't';
156  break;
157  case '\n':
158  *this << '\\' << 'n';
159  break;
160  case '"':
161  *this << '\\' << '"';
162  break;
163  default:
164  if (isPrint(c)) {
165  *this << c;
166  break;
167  }
168 
169  // Write out the escaped representation.
170  if (UseHexEscapes) {
171  *this << '\\' << 'x';
172  *this << hexdigit((c >> 4 & 0xF));
173  *this << hexdigit((c >> 0) & 0xF);
174  } else {
175  // Always use a full 3-character octal escape.
176  *this << '\\';
177  *this << char('0' + ((c >> 6) & 7));
178  *this << char('0' + ((c >> 3) & 7));
179  *this << char('0' + ((c >> 0) & 7));
180  }
181  }
182  }
183 
184  return *this;
185 }
186 
188  llvm::write_hex(*this, (uintptr_t)P, HexPrintStyle::PrefixLower);
189  return *this;
190 }
191 
194  return *this;
195 }
196 
197 void raw_ostream::flush_nonempty() {
198  assert(OutBufCur > OutBufStart && "Invalid call to flush_nonempty.");
199  size_t Length = OutBufCur - OutBufStart;
200  OutBufCur = OutBufStart;
201  write_impl(OutBufStart, Length);
202 }
203 
205  // Group exceptional cases into a single branch.
206  if (LLVM_UNLIKELY(OutBufCur >= OutBufEnd)) {
207  if (LLVM_UNLIKELY(!OutBufStart)) {
208  if (BufferMode == Unbuffered) {
209  write_impl(reinterpret_cast<char*>(&C), 1);
210  return *this;
211  }
212  // Set up a buffer and start over.
213  SetBuffered();
214  return write(C);
215  }
216 
217  flush_nonempty();
218  }
219 
220  *OutBufCur++ = C;
221  return *this;
222 }
223 
224 raw_ostream &raw_ostream::write(const char *Ptr, size_t Size) {
225  // Group exceptional cases into a single branch.
226  if (LLVM_UNLIKELY(size_t(OutBufEnd - OutBufCur) < Size)) {
227  if (LLVM_UNLIKELY(!OutBufStart)) {
228  if (BufferMode == Unbuffered) {
229  write_impl(Ptr, Size);
230  return *this;
231  }
232  // Set up a buffer and start over.
233  SetBuffered();
234  return write(Ptr, Size);
235  }
236 
237  size_t NumBytes = OutBufEnd - OutBufCur;
238 
239  // If the buffer is empty at this point we have a string that is larger
240  // than the buffer. Directly write the chunk that is a multiple of the
241  // preferred buffer size and put the remainder in the buffer.
242  if (LLVM_UNLIKELY(OutBufCur == OutBufStart)) {
243  assert(NumBytes != 0 && "undefined behavior");
244  size_t BytesToWrite = Size - (Size % NumBytes);
245  write_impl(Ptr, BytesToWrite);
246  size_t BytesRemaining = Size - BytesToWrite;
247  if (BytesRemaining > size_t(OutBufEnd - OutBufCur)) {
248  // Too much left over to copy into our buffer.
249  return write(Ptr + BytesToWrite, BytesRemaining);
250  }
251  copy_to_buffer(Ptr + BytesToWrite, BytesRemaining);
252  return *this;
253  }
254 
255  // We don't have enough space in the buffer to fit the string in. Insert as
256  // much as possible, flush and start over with the remainder.
257  copy_to_buffer(Ptr, NumBytes);
258  flush_nonempty();
259  return write(Ptr + NumBytes, Size - NumBytes);
260  }
261 
262  copy_to_buffer(Ptr, Size);
263 
264  return *this;
265 }
266 
267 void raw_ostream::copy_to_buffer(const char *Ptr, size_t Size) {
268  assert(Size <= size_t(OutBufEnd - OutBufCur) && "Buffer overrun!");
269 
270  // Handle short strings specially, memcpy isn't very good at very short
271  // strings.
272  switch (Size) {
273  case 4: OutBufCur[3] = Ptr[3]; LLVM_FALLTHROUGH;
274  case 3: OutBufCur[2] = Ptr[2]; LLVM_FALLTHROUGH;
275  case 2: OutBufCur[1] = Ptr[1]; LLVM_FALLTHROUGH;
276  case 1: OutBufCur[0] = Ptr[0]; LLVM_FALLTHROUGH;
277  case 0: break;
278  default:
279  memcpy(OutBufCur, Ptr, Size);
280  break;
281  }
282 
283  OutBufCur += Size;
284 }
285 
286 // Formatted output.
288  // If we have more than a few bytes left in our output buffer, try
289  // formatting directly onto its end.
290  size_t NextBufferSize = 127;
291  size_t BufferBytesLeft = OutBufEnd - OutBufCur;
292  if (BufferBytesLeft > 3) {
293  size_t BytesUsed = Fmt.print(OutBufCur, BufferBytesLeft);
294 
295  // Common case is that we have plenty of space.
296  if (BytesUsed <= BufferBytesLeft) {
297  OutBufCur += BytesUsed;
298  return *this;
299  }
300 
301  // Otherwise, we overflowed and the return value tells us the size to try
302  // again with.
303  NextBufferSize = BytesUsed;
304  }
305 
306  // If we got here, we didn't have enough space in the output buffer for the
307  // string. Try printing into a SmallVector that is resized to have enough
308  // space. Iterate until we win.
310 
311  while (true) {
312  V.resize(NextBufferSize);
313 
314  // Try formatting into the SmallVector.
315  size_t BytesUsed = Fmt.print(V.data(), NextBufferSize);
316 
317  // If BytesUsed fit into the vector, we win.
318  if (BytesUsed <= NextBufferSize)
319  return write(V.data(), BytesUsed);
320 
321  // Otherwise, try again with a new size.
322  assert(BytesUsed > NextBufferSize && "Didn't grow buffer!?");
323  NextBufferSize = BytesUsed;
324  }
325 }
326 
329  Obj.format(*this);
330  return *this;
331 }
332 
334  if (FS.Str.size() >= FS.Width || FS.Justify == FormattedString::JustifyNone) {
335  this->operator<<(FS.Str);
336  return *this;
337  }
338  const size_t Difference = FS.Width - FS.Str.size();
339  switch (FS.Justify) {
341  this->operator<<(FS.Str);
342  this->indent(Difference);
343  break;
345  this->indent(Difference);
346  this->operator<<(FS.Str);
347  break;
349  int PadAmount = Difference / 2;
350  this->indent(PadAmount);
351  this->operator<<(FS.Str);
352  this->indent(Difference - PadAmount);
353  break;
354  }
355  default:
356  llvm_unreachable("Bad Justification");
357  }
358  return *this;
359 }
360 
362  if (FN.Hex) {
364  if (FN.Upper && FN.HexPrefix)
366  else if (FN.Upper && !FN.HexPrefix)
367  Style = HexPrintStyle::Upper;
368  else if (!FN.Upper && FN.HexPrefix)
370  else
371  Style = HexPrintStyle::Lower;
372  llvm::write_hex(*this, FN.HexValue, Style, FN.Width);
373  } else {
374  llvm::SmallString<16> Buffer;
375  llvm::raw_svector_ostream Stream(Buffer);
376  llvm::write_integer(Stream, FN.DecValue, 0, IntegerStyle::Integer);
377  if (Buffer.size() < FN.Width)
378  indent(FN.Width - Buffer.size());
379  (*this) << Buffer;
380  }
381  return *this;
382 }
383 
385  if (FB.Bytes.empty())
386  return *this;
387 
388  size_t LineIndex = 0;
389  auto Bytes = FB.Bytes;
390  const size_t Size = Bytes.size();
392  uint64_t OffsetWidth = 0;
393  if (FB.FirstByteOffset.hasValue()) {
394  // Figure out how many nibbles are needed to print the largest offset
395  // represented by this data set, so that we can align the offset field
396  // to the right width.
397  size_t Lines = Size / FB.NumPerLine;
398  uint64_t MaxOffset = *FB.FirstByteOffset + Lines * FB.NumPerLine;
399  unsigned Power = 0;
400  if (MaxOffset > 0)
401  Power = llvm::Log2_64_Ceil(MaxOffset);
402  OffsetWidth = std::max<uint64_t>(4, llvm::alignTo(Power, 4) / 4);
403  }
404 
405  // The width of a block of data including all spaces for group separators.
406  unsigned NumByteGroups =
407  alignTo(FB.NumPerLine, FB.ByteGroupSize) / FB.ByteGroupSize;
408  unsigned BlockCharWidth = FB.NumPerLine * 2 + NumByteGroups - 1;
409 
410  while (!Bytes.empty()) {
411  indent(FB.IndentLevel);
412 
413  if (FB.FirstByteOffset.hasValue()) {
414  uint64_t Offset = FB.FirstByteOffset.getValue();
415  llvm::write_hex(*this, Offset + LineIndex, HPS, OffsetWidth);
416  *this << ": ";
417  }
418 
419  auto Line = Bytes.take_front(FB.NumPerLine);
420 
421  size_t CharsPrinted = 0;
422  // Print the hex bytes for this line in groups
423  for (size_t I = 0; I < Line.size(); ++I, CharsPrinted += 2) {
424  if (I && (I % FB.ByteGroupSize) == 0) {
425  ++CharsPrinted;
426  *this << " ";
427  }
428  llvm::write_hex(*this, Line[I], HPS, 2);
429  }
430 
431  if (FB.ASCII) {
432  // Print any spaces needed for any bytes that we didn't print on this
433  // line so that the ASCII bytes are correctly aligned.
434  assert(BlockCharWidth >= CharsPrinted);
435  indent(BlockCharWidth - CharsPrinted + 2);
436  *this << "|";
437 
438  // Print the ASCII char values for each byte on this line
439  for (uint8_t Byte : Line) {
440  if (isPrint(Byte))
441  *this << static_cast<char>(Byte);
442  else
443  *this << '.';
444  }
445  *this << '|';
446  }
447 
448  Bytes = Bytes.drop_front(Line.size());
449  LineIndex += Line.size();
450  if (LineIndex < Size)
451  *this << '\n';
452  }
453  return *this;
454 }
455 
456 template <char C>
457 static raw_ostream &write_padding(raw_ostream &OS, unsigned NumChars) {
458  static const char Chars[] = {C, C, C, C, C, C, C, C, C, C, C, C, C, C, C, C,
459  C, C, C, C, C, C, C, C, C, C, C, C, C, C, C, C,
460  C, C, C, C, C, C, C, C, C, C, C, C, C, C, C, C,
461  C, C, C, C, C, C, C, C, C, C, C, C, C, C, C, C,
462  C, C, C, C, C, C, C, C, C, C, C, C, C, C, C, C};
463 
464  // Usually the indentation is small, handle it with a fastpath.
465  if (NumChars < array_lengthof(Chars))
466  return OS.write(Chars, NumChars);
467 
468  while (NumChars) {
469  unsigned NumToWrite = std::min(NumChars,
470  (unsigned)array_lengthof(Chars)-1);
471  OS.write(Chars, NumToWrite);
472  NumChars -= NumToWrite;
473  }
474  return OS;
475 }
476 
477 /// indent - Insert 'NumSpaces' spaces.
478 raw_ostream &raw_ostream::indent(unsigned NumSpaces) {
479  return write_padding<' '>(*this, NumSpaces);
480 }
481 
482 /// write_zeros - Insert 'NumZeros' nulls.
484  return write_padding<'\0'>(*this, NumZeros);
485 }
486 
487 void raw_ostream::anchor() {}
488 
489 //===----------------------------------------------------------------------===//
490 // Formatted Output
491 //===----------------------------------------------------------------------===//
492 
493 // Out of line virtual method.
495 }
496 
497 //===----------------------------------------------------------------------===//
498 // raw_fd_ostream
499 //===----------------------------------------------------------------------===//
500 
501 static int getFD(StringRef Filename, std::error_code &EC,
503  sys::fs::OpenFlags Flags) {
504  assert((Access & sys::fs::FA_Write) &&
505  "Cannot make a raw_ostream from a read-only descriptor!");
506 
507  // Handle "-" as stdout. Note that when we do this, we consider ourself
508  // the owner of stdout and may set the "binary" flag globally based on Flags.
509  if (Filename == "-") {
510  EC = std::error_code();
511  // If user requested binary then put stdout into binary mode if
512  // possible.
513  if (!(Flags & sys::fs::OF_Text))
515  return STDOUT_FILENO;
516  }
517 
518  int FD;
519  if (Access & sys::fs::FA_Read)
520  EC = sys::fs::openFileForReadWrite(Filename, FD, Disp, Flags);
521  else
522  EC = sys::fs::openFileForWrite(Filename, FD, Disp, Flags);
523  if (EC)
524  return -1;
525 
526  return FD;
527 }
528 
529 raw_fd_ostream::raw_fd_ostream(StringRef Filename, std::error_code &EC)
530  : raw_fd_ostream(Filename, EC, sys::fs::CD_CreateAlways, sys::fs::FA_Write,
531  sys::fs::OF_None) {}
532 
533 raw_fd_ostream::raw_fd_ostream(StringRef Filename, std::error_code &EC,
535  : raw_fd_ostream(Filename, EC, Disp, sys::fs::FA_Write, sys::fs::OF_None) {}
536 
537 raw_fd_ostream::raw_fd_ostream(StringRef Filename, std::error_code &EC,
538  sys::fs::FileAccess Access)
539  : raw_fd_ostream(Filename, EC, sys::fs::CD_CreateAlways, Access,
540  sys::fs::OF_None) {}
541 
542 raw_fd_ostream::raw_fd_ostream(StringRef Filename, std::error_code &EC,
543  sys::fs::OpenFlags Flags)
544  : raw_fd_ostream(Filename, EC, sys::fs::CD_CreateAlways, sys::fs::FA_Write,
545  Flags) {}
546 
547 raw_fd_ostream::raw_fd_ostream(StringRef Filename, std::error_code &EC,
549  sys::fs::FileAccess Access,
550  sys::fs::OpenFlags Flags)
551  : raw_fd_ostream(getFD(Filename, EC, Disp, Access, Flags), true) {}
552 
553 /// FD is the file descriptor that this writes to. If ShouldClose is true, this
554 /// closes the file when the stream is destroyed.
555 raw_fd_ostream::raw_fd_ostream(int fd, bool shouldClose, bool unbuffered)
556  : raw_pwrite_stream(unbuffered), FD(fd), ShouldClose(shouldClose) {
557  if (FD < 0 ) {
558  ShouldClose = false;
559  return;
560  }
561 
562  // Do not attempt to close stdout or stderr. We used to try to maintain the
563  // property that tools that support writing file to stdout should not also
564  // write informational output to stdout, but in practice we were never able to
565  // maintain this invariant. Many features have been added to LLVM and clang
566  // (-fdump-record-layouts, optimization remarks, etc) that print to stdout, so
567  // users must simply be aware that mixed output and remarks is a possibility.
568  if (FD <= STDERR_FILENO)
569  ShouldClose = false;
570 
571 #ifdef _WIN32
572  // Check if this is a console device. This is not equivalent to isatty.
573  IsWindowsConsole =
574  ::GetFileType((HANDLE)::_get_osfhandle(fd)) == FILE_TYPE_CHAR;
575 #endif
576 
577  // Get the starting position.
578  off_t loc = ::lseek(FD, 0, SEEK_CUR);
579 #ifdef _WIN32
580  // MSVCRT's _lseek(SEEK_CUR) doesn't return -1 for pipes.
582  std::error_code EC = status(FD, Status);
583  SupportsSeeking = !EC && Status.type() == sys::fs::file_type::regular_file;
584 #else
585  SupportsSeeking = loc != (off_t)-1;
586 #endif
587  if (!SupportsSeeking)
588  pos = 0;
589  else
590  pos = static_cast<uint64_t>(loc);
591 }
592 
594  if (FD >= 0) {
595  flush();
596  if (ShouldClose) {
597  if (auto EC = sys::Process::SafelyCloseFileDescriptor(FD))
598  error_detected(EC);
599  }
600  }
601 
602 #ifdef __MINGW32__
603  // On mingw, global dtors should not call exit().
604  // report_fatal_error() invokes exit(). We know report_fatal_error()
605  // might not write messages to stderr when any errors were detected
606  // on FD == 2.
607  if (FD == 2) return;
608 #endif
609 
610  // If there are any pending errors, report them now. Clients wishing
611  // to avoid report_fatal_error calls should check for errors with
612  // has_error() and clear the error flag with clear_error() before
613  // destructing raw_ostream objects which may have errors.
614  if (has_error())
615  report_fatal_error("IO failure on output stream: " + error().message(),
616  /*GenCrashDiag=*/false);
617 }
618 
619 #if defined(_WIN32)
620 // The most reliable way to print unicode in a Windows console is with
621 // WriteConsoleW. To use that, first transcode from UTF-8 to UTF-16. This
622 // assumes that LLVM programs always print valid UTF-8 to the console. The data
623 // might not be UTF-8 for two major reasons:
624 // 1. The program is printing binary (-filetype=obj -o -), in which case it
625 // would have been gibberish anyway.
626 // 2. The program is printing text in a semi-ascii compatible codepage like
627 // shift-jis or cp1252.
628 //
629 // Most LLVM programs don't produce non-ascii text unless they are quoting
630 // user source input. A well-behaved LLVM program should either validate that
631 // the input is UTF-8 or transcode from the local codepage to UTF-8 before
632 // quoting it. If they don't, this may mess up the encoding, but this is still
633 // probably the best compromise we can make.
634 static bool write_console_impl(int FD, StringRef Data) {
635  SmallVector<wchar_t, 256> WideText;
636 
637  // Fall back to ::write if it wasn't valid UTF-8.
638  if (auto EC = sys::windows::UTF8ToUTF16(Data, WideText))
639  return false;
640 
641  // On Windows 7 and earlier, WriteConsoleW has a low maximum amount of data
642  // that can be written to the console at a time.
643  size_t MaxWriteSize = WideText.size();
645  MaxWriteSize = 32767;
646 
647  size_t WCharsWritten = 0;
648  do {
649  size_t WCharsToWrite =
650  std::min(MaxWriteSize, WideText.size() - WCharsWritten);
651  DWORD ActuallyWritten;
652  bool Success =
653  ::WriteConsoleW((HANDLE)::_get_osfhandle(FD), &WideText[WCharsWritten],
654  WCharsToWrite, &ActuallyWritten,
655  /*Reserved=*/nullptr);
656 
657  // The most likely reason for WriteConsoleW to fail is that FD no longer
658  // points to a console. Fall back to ::write. If this isn't the first loop
659  // iteration, something is truly wrong.
660  if (!Success)
661  return false;
662 
663  WCharsWritten += ActuallyWritten;
664  } while (WCharsWritten != WideText.size());
665  return true;
666 }
667 #endif
668 
669 void raw_fd_ostream::write_impl(const char *Ptr, size_t Size) {
670  assert(FD >= 0 && "File already closed.");
671  pos += Size;
672 
673 #if defined(_WIN32)
674  // If this is a Windows console device, try re-encoding from UTF-8 to UTF-16
675  // and using WriteConsoleW. If that fails, fall back to plain write().
676  if (IsWindowsConsole)
677  if (write_console_impl(FD, StringRef(Ptr, Size)))
678  return;
679 #endif
680 
681  // The maximum write size is limited to INT32_MAX. A write
682  // greater than SSIZE_MAX is implementation-defined in POSIX,
683  // and Windows _write requires 32 bit input.
684  size_t MaxWriteSize = INT32_MAX;
685 
686 #if defined(__linux__)
687  // It is observed that Linux returns EINVAL for a very large write (>2G).
688  // Make it a reasonably small value.
689  MaxWriteSize = 1024 * 1024 * 1024;
690 #endif
691 
692  do {
693  size_t ChunkSize = std::min(Size, MaxWriteSize);
694  ssize_t ret = ::write(FD, Ptr, ChunkSize);
695 
696  if (ret < 0) {
697  // If it's a recoverable error, swallow it and retry the write.
698  //
699  // Ideally we wouldn't ever see EAGAIN or EWOULDBLOCK here, since
700  // raw_ostream isn't designed to do non-blocking I/O. However, some
701  // programs, such as old versions of bjam, have mistakenly used
702  // O_NONBLOCK. For compatibility, emulate blocking semantics by
703  // spinning until the write succeeds. If you don't want spinning,
704  // don't use O_NONBLOCK file descriptors with raw_ostream.
705  if (errno == EINTR || errno == EAGAIN
706 #ifdef EWOULDBLOCK
707  || errno == EWOULDBLOCK
708 #endif
709  )
710  continue;
711 
712  // Otherwise it's a non-recoverable error. Note it and quit.
713  error_detected(std::error_code(errno, std::generic_category()));
714  break;
715  }
716 
717  // The write may have written some or all of the data. Update the
718  // size and buffer pointer to reflect the remainder that needs
719  // to be written. If there are no bytes left, we're done.
720  Ptr += ret;
721  Size -= ret;
722  } while (Size > 0);
723 }
724 
726  assert(ShouldClose);
727  ShouldClose = false;
728  flush();
729  if (auto EC = sys::Process::SafelyCloseFileDescriptor(FD))
730  error_detected(EC);
731  FD = -1;
732 }
733 
734 uint64_t raw_fd_ostream::seek(uint64_t off) {
735  assert(SupportsSeeking && "Stream does not support seeking!");
736  flush();
737 #ifdef _WIN32
738  pos = ::_lseeki64(FD, off, SEEK_SET);
739 #elif defined(HAVE_LSEEK64)
740  pos = ::lseek64(FD, off, SEEK_SET);
741 #else
742  pos = ::lseek(FD, off, SEEK_SET);
743 #endif
744  if (pos == (uint64_t)-1)
745  error_detected(std::error_code(errno, std::generic_category()));
746  return pos;
747 }
748 
749 void raw_fd_ostream::pwrite_impl(const char *Ptr, size_t Size,
750  uint64_t Offset) {
751  uint64_t Pos = tell();
752  seek(Offset);
753  write(Ptr, Size);
754  seek(Pos);
755 }
756 
757 size_t raw_fd_ostream::preferred_buffer_size() const {
758 #if defined(_WIN32)
759  // Disable buffering for console devices. Console output is re-encoded from
760  // UTF-8 to UTF-16 on Windows, and buffering it would require us to split the
761  // buffer on a valid UTF-8 codepoint boundary. Terminal buffering is disabled
762  // below on most other OSs, so do the same thing on Windows and avoid that
763  // complexity.
764  if (IsWindowsConsole)
765  return 0;
767 #elif !defined(__minix)
768  // Minix has no st_blksize.
769  assert(FD >= 0 && "File not yet open!");
770  struct stat statbuf;
771  if (fstat(FD, &statbuf) != 0)
772  return 0;
773 
774  // If this is a terminal, don't use buffering. Line buffering
775  // would be a more traditional thing to do, but it's not worth
776  // the complexity.
777  if (S_ISCHR(statbuf.st_mode) && isatty(FD))
778  return 0;
779  // Return the preferred block size.
780  return statbuf.st_blksize;
781 #else
783 #endif
784 }
785 
787  bool bg) {
789  flush();
790  const char *colorcode =
791  (colors == SAVEDCOLOR) ? sys::Process::OutputBold(bg)
792  : sys::Process::OutputColor(colors, bold, bg);
793  if (colorcode) {
794  size_t len = strlen(colorcode);
795  write(colorcode, len);
796  // don't account colors towards output characters
797  pos -= len;
798  }
799  return *this;
800 }
801 
804  flush();
805  const char *colorcode = sys::Process::ResetColor();
806  if (colorcode) {
807  size_t len = strlen(colorcode);
808  write(colorcode, len);
809  // don't account colors towards output characters
810  pos -= len;
811  }
812  return *this;
813 }
814 
817  flush();
818  const char *colorcode = sys::Process::OutputReverse();
819  if (colorcode) {
820  size_t len = strlen(colorcode);
821  write(colorcode, len);
822  // don't account colors towards output characters
823  pos -= len;
824  }
825  return *this;
826 }
827 
830 }
831 
834 }
835 
836 void raw_fd_ostream::anchor() {}
837 
838 //===----------------------------------------------------------------------===//
839 // outs(), errs(), nulls()
840 //===----------------------------------------------------------------------===//
841 
842 /// outs() - This returns a reference to a raw_ostream for standard output.
843 /// Use it like: outs() << "foo" << "bar";
845  // Set buffer settings to model stdout behavior.
846  std::error_code EC;
847  static raw_fd_ostream S("-", EC, sys::fs::F_None);
848  assert(!EC);
849  return S;
850 }
851 
852 /// errs() - This returns a reference to a raw_ostream for standard error.
853 /// Use it like: errs() << "foo" << "bar";
855  // Set standard error to be unbuffered by default.
856  static raw_fd_ostream S(STDERR_FILENO, false, true);
857  return S;
858 }
859 
860 /// nulls() - This returns a reference to a raw_ostream which discards output.
862  static raw_null_ostream S;
863  return S;
864 }
865 
866 //===----------------------------------------------------------------------===//
867 // raw_string_ostream
868 //===----------------------------------------------------------------------===//
869 
871  flush();
872 }
873 
874 void raw_string_ostream::write_impl(const char *Ptr, size_t Size) {
875  OS.append(Ptr, Size);
876 }
877 
878 //===----------------------------------------------------------------------===//
879 // raw_svector_ostream
880 //===----------------------------------------------------------------------===//
881 
882 uint64_t raw_svector_ostream::current_pos() const { return OS.size(); }
883 
884 void raw_svector_ostream::write_impl(const char *Ptr, size_t Size) {
885  OS.append(Ptr, Ptr + Size);
886 }
887 
888 void raw_svector_ostream::pwrite_impl(const char *Ptr, size_t Size,
889  uint64_t Offset) {
890  memcpy(OS.data() + Offset, Ptr, Size);
891 }
892 
893 //===----------------------------------------------------------------------===//
894 // raw_null_ostream
895 //===----------------------------------------------------------------------===//
896 
898 #ifndef NDEBUG
899  // ~raw_ostream asserts that the buffer is empty. This isn't necessary
900  // with raw_null_ostream, but it's better to have raw_null_ostream follow
901  // the rules than to change the rules just for raw_null_ostream.
902  flush();
903 #endif
904 }
905 
906 void raw_null_ostream::write_impl(const char *Ptr, size_t Size) {
907 }
908 
909 uint64_t raw_null_ostream::current_pos() const {
910  return 0;
911 }
912 
913 void raw_null_ostream::pwrite_impl(const char *Ptr, size_t Size,
914  uint64_t Offset) {}
915 
916 void raw_pwrite_stream::anchor() {}
uint64_t CallInst * C
bool has_colors() const override
This function determines if this stream is displayed and supports colors.
bool is_displayed() const override
This function determines if this stream is connected to a "tty" or "console" window.
std::error_code openFileForReadWrite(const Twine &Name, int &ResultFD, CreationDisposition Disp, OpenFlags Flags, unsigned Mode=0666)
Opens the file with the given name in a write-only or read-write mode, returning its open file descri...
Definition: FileSystem.h:995
raw_ostream & errs()
This returns a reference to a raw_ostream for standard error.
uint8_t[16] uuid_t
Output a formatted UUID with dash separators.
Definition: raw_ostream.h:219
bool isPrint(char C)
Checks whether character C is printable.
Definition: StringExtras.h:106
SI Whole Quad Mode
LLVM_ATTRIBUTE_NORETURN void report_fatal_error(Error Err, bool gen_crash_diag=true)
Report a serious error, calling any installed error handler.
Definition: Error.cpp:139
This class represents lattice values for constants.
Definition: AllocatorList.h:24
static const char * ResetColor()
Resets the terminals colors, or returns an escape sequence to do so.
#define LLVM_FALLTHROUGH
Definition: Compiler.h:86
static const char * OutputColor(char c, bool bold, bool bg)
This function returns the colorcode escape sequences.
std::error_code ChangeStdoutToBinary()
A raw_ostream that discards all output.
Definition: raw_ostream.h:539
virtual ~raw_ostream()
Definition: raw_ostream.cpp:69
uint64_t seek(uint64_t off)
Flushes the stream and repositions the underlying file descriptor position to the offset specified fr...
raw_ostream & write_zeros(unsigned NumZeros)
write_zeros - Insert &#39;NumZeros&#39; nulls.
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE size_t size() const
size - Get the string size.
Definition: StringRef.h:138
format_object< Ts... > format(const char *Fmt, const Ts &... Vals)
These are helper functions used to produce formatted output.
Definition: Format.h:124
raw_ostream & indent(unsigned NumSpaces)
indent - Insert &#39;NumSpaces&#39; spaces.
static bool FileDescriptorHasColors(int fd)
This function determines if the given file descriptor is displayd and supports colors.
A raw_ostream that writes to an SmallVector or SmallString.
Definition: raw_ostream.h:510
raw_fd_ostream(StringRef Filename, std::error_code &EC)
Open the specified file for writing.
static bool FileDescriptorIsDisplayed(int fd)
This function determines if the given file descriptor is connected to a "tty" or "console" window...
uint64_t alignTo(uint64_t Value, uint64_t Align, uint64_t Skew=0)
Returns the next integer (mod 2**64) that is greater than or equal to Value and is a multiple of Alig...
Definition: MathExtras.h:685
block Block Frequency true
Represents the result of a call to sys::fs::status().
Definition: FileSystem.h:247
std::error_code error() const
Definition: raw_ostream.h:446
#define LLVM_UNLIKELY(EXPR)
Definition: Compiler.h:192
raw_ostream & write_uuid(const uuid_t UUID)
void write_double(raw_ostream &S, double D, FloatStyle Style, Optional< size_t > Precision=None)
This is a helper class for left_justify, right_justify, and center_justify.
Definition: Format.h:129
static bool ColorNeedsFlush()
Whether changing colors requires the output to be flushed.
static const char * OutputReverse()
This function returns the escape sequence to reverse forground and background colors.
const T & getValue() const LLVM_LVALUE_FUNCTION
Definition: Optional.h:161
raw_ostream & write_hex(unsigned long long N)
Output N in hexadecimal, without any prefix or padding.
~raw_fd_ostream() override
This is a helper class used for handling formatted output.
Definition: Format.h:38
The file should be opened in text mode on platforms that make this distinction.
Definition: FileSystem.h:753
raw_ostream & operator<<(char C)
Definition: raw_ostream.h:147
static raw_ostream & write_padding(raw_ostream &OS, unsigned NumChars)
raw_ostream & outs()
This returns a reference to a raw_ostream for standard output.
#define P(N)
raw_ostream & resetColor() override
Resets the colors to terminal defaults.
virtual size_t preferred_buffer_size() const
Return an efficient buffer size for the underlying output mechanism.
Definition: raw_ostream.cpp:79
std::error_code status(const Twine &path, file_status &result, bool follow=true)
Get file status as if by POSIX stat().
void format(raw_ostream &S) const
void SetUnbuffered()
Set the stream to be unbuffered.
Definition: raw_ostream.h:129
std::error_code openFileForWrite(const Twine &Name, int &ResultFD, CreationDisposition Disp=CD_CreateAlways, OpenFlags Flags=OF_None, unsigned Mode=0666)
Opens the file with the given name in a write-only or read-write mode, returning its open file descri...
Definition: FileSystem.h:954
bool RunningWindows8OrGreater()
Determines if the program is running on Windows 8 or newer.
void SetBufferSize(size_t Size)
Set the stream to be buffered, using the specified buffer size.
Definition: raw_ostream.h:111
size_t size() const
Definition: SmallVector.h:53
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
~raw_null_ostream() override
bool has_error() const
Return the value of the flag in this raw_fd_ostream indicating whether an output error has been encou...
Definition: raw_ostream.h:452
raw_ostream & write(unsigned char C)
static int getFD(StringRef Filename, std::error_code &EC, sys::fs::CreationDisposition Disp, sys::fs::FileAccess Access, sys::fs::OpenFlags Flags)
raw_ostream & write_escaped(StringRef Str, bool UseHexEscapes=false)
Output Str, turning &#39;\&#39;, &#39;&#39;, &#39; &#39;, &#39;"&#39;, and anything that doesn&#39;t satisfy llvm::isPrint into an escape...
This is a helper class used for format_hex() and format_decimal().
Definition: Format.h:164
This is a &#39;vector&#39; (really, a variable-sized array), optimized for the case when the array is small...
Definition: SmallVector.h:847
constexpr size_t array_lengthof(T(&)[N])
Find the length of an array.
Definition: STLExtras.h:1038
unsigned Log2_64_Ceil(uint64_t Value)
Return the ceil log base 2 of the specified value, 64 if the value is zero.
Definition: MathExtras.h:558
size_t GetNumBytesInBuffer() const
Definition: raw_ostream.h:134
void SetBuffered()
Set the stream to be buffered, with an automatically determined buffer size.
Definition: raw_ostream.cpp:84
#define Success
bool hasValue() const
Definition: Optional.h:165
Provides a library for accessing information about this process and other processes on the operating ...
void write_hex(raw_ostream &S, uint64_t N, HexPrintStyle Style, Optional< size_t > Width=None)
A raw_ostream that writes to a file descriptor.
Definition: raw_ostream.h:366
pointer data()
Return a pointer to the vector&#39;s buffer, even if empty().
Definition: SmallVector.h:149
#define I(x, y, z)
Definition: MD5.cpp:58
#define N
uint32_t Size
Definition: Profile.cpp:47
void close()
Manually flush the stream and close the file.
An abstract base class for streams implementations that also support a pwrite operation.
Definition: raw_ostream.h:341
static const char * OutputBold(bool bg)
Same as OutputColor, but only enables the bold attribute.
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
unsigned print(char *Buffer, unsigned BufferSize) const
Format the object into the specified buffer.
Definition: Format.h:54
CD_CreateAlways - When opening a file:
Definition: FileSystem.h:724
raw_ostream & nulls()
This returns a reference to a raw_ostream which simply discards output.
raw_ostream & changeColor(enum Colors colors, bool bold=false, bool bg=false) override
Changes the foreground color of text that will be output from this point forward. ...
static std::error_code SafelyCloseFileDescriptor(int FD)
uint64_t tell() const
tell - Return the current offset with the file.
Definition: raw_ostream.h:100
This class implements an extremely fast bulk output stream that can only output to a stream...
Definition: raw_ostream.h:46
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:49
void write_integer(raw_ostream &S, unsigned int N, size_t MinDigits, IntegerStyle Style)
raw_ostream & reverseColor() override
Reverses the foreground and background colors.
bool empty() const
empty - Check if the array is empty.
Definition: ArrayRef.h:144
void resize(size_type N)
Definition: SmallVector.h:351