LLVM  13.0.0git
raw_ostream.cpp
Go to the documentation of this file.
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 
14 #include "llvm/ADT/STLExtras.h"
15 #include "llvm/ADT/StringExtras.h"
16 #include "llvm/Config/config.h"
17 #include "llvm/Support/Compiler.h"
20 #include "llvm/Support/Format.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_H)
35 # include <fcntl.h>
36 #endif
37 
38 #if defined(HAVE_UNISTD_H)
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_FILENO
49 # define STDIN_FILENO 0
50 #endif
51 #ifndef STDOUT_FILENO
52 # define STDOUT_FILENO 1
53 #endif
54 #ifndef STDERR_FILENO
55 # define STDERR_FILENO 2
56 #endif
57 #endif
58 
59 #ifdef _WIN32
62 #endif
63 
64 using namespace llvm;
65 
76 
78  // raw_ostream's subclasses should take care to flush the buffer
79  // in their destructors.
80  assert(OutBufCur == OutBufStart &&
81  "raw_ostream destructor called with non-empty buffer!");
82 
83  if (BufferMode == BufferKind::InternalBuffer)
84  delete [] OutBufStart;
85 }
86 
88  // BUFSIZ is intended to be a reasonable default.
89  return BUFSIZ;
90 }
91 
93  // Ask the subclass to determine an appropriate buffer size.
94  if (size_t Size = preferred_buffer_size())
96  else
97  // It may return 0, meaning this stream should be unbuffered.
98  SetUnbuffered();
99 }
100 
101 void raw_ostream::SetBufferAndMode(char *BufferStart, size_t Size,
102  BufferKind Mode) {
103  assert(((Mode == BufferKind::Unbuffered && !BufferStart && Size == 0) ||
104  (Mode != BufferKind::Unbuffered && BufferStart && Size != 0)) &&
105  "stream must be unbuffered or have at least one byte");
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!");
109 
110  if (BufferMode == BufferKind::InternalBuffer)
111  delete [] OutBufStart;
112  OutBufStart = BufferStart;
113  OutBufEnd = OutBufStart+Size;
114  OutBufCur = OutBufStart;
115  BufferMode = Mode;
116 
117  assert(OutBufStart <= OutBufEnd && "Invalid size!");
118 }
119 
121  write_integer(*this, static_cast<uint64_t>(N), 0, IntegerStyle::Integer);
122  return *this;
123 }
124 
126  write_integer(*this, static_cast<int64_t>(N), 0, IntegerStyle::Integer);
127  return *this;
128 }
129 
130 raw_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 
136  write_integer(*this, static_cast<int64_t>(N), 0, IntegerStyle::Integer);
137  return *this;
138 }
139 
140 raw_ostream &raw_ostream::write_hex(unsigned long long N) {
142  return *this;
143 }
144 
146  if (C == Colors::RESET)
147  resetColor();
148  else
149  changeColor(C);
150  return *this;
151 }
152 
154  for (int Idx = 0; Idx < 16; ++Idx) {
155  *this << format("%02" PRIX32, UUID[Idx]);
156  if (Idx == 3 || Idx == 5 || Idx == 7 || Idx == 9)
157  *this << "-";
158  }
159  return *this;
160 }
161 
162 
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 
204  llvm::write_hex(*this, (uintptr_t)P, HexPrintStyle::PrefixLower);
205  return *this;
206 }
207 
210  return *this;
211 }
212 
213 void raw_ostream::flush_nonempty() {
214  assert(OutBufCur > OutBufStart && "Invalid call to flush_nonempty.");
215  size_t Length = OutBufCur - OutBufStart;
216  OutBufCur = OutBufStart;
217  flush_tied_then_write(OutBufStart, Length);
218 }
219 
221  // Group exceptional cases into a single branch.
222  if (LLVM_UNLIKELY(OutBufCur >= OutBufEnd)) {
223  if (LLVM_UNLIKELY(!OutBufStart)) {
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 
240 raw_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)) {
243  if (LLVM_UNLIKELY(!OutBufStart)) {
244  if (BufferMode == BufferKind::Unbuffered) {
245  flush_tied_then_write(Ptr, Size);
246  return *this;
247  }
248  // Set up a buffer and start over.
249  SetBuffered();
250  return write(Ptr, Size);
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)) {
259  assert(NumBytes != 0 && "undefined behavior");
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);
279 
280  return *this;
281 }
282 
283 void raw_ostream::copy_to_buffer(const char *Ptr, size_t Size) {
284  assert(Size <= size_t(OutBufEnd - OutBufCur) && "Buffer overrun!");
285 
286  // Handle short strings specially, memcpy isn't very good at very short
287  // strings.
288  switch (Size) {
289  case 4: OutBufCur[3] = Ptr[3]; LLVM_FALLTHROUGH;
290  case 3: OutBufCur[2] = Ptr[2]; LLVM_FALLTHROUGH;
291  case 2: OutBufCur[1] = Ptr[1]; LLVM_FALLTHROUGH;
292  case 1: OutBufCur[0] = Ptr[0]; LLVM_FALLTHROUGH;
293  case 0: break;
294  default:
295  memcpy(OutBufCur, Ptr, Size);
296  break;
297  }
298 
299  OutBufCur += Size;
300 }
301 
302 void 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.
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) {
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.
332 
333  while (true) {
334  V.resize(NextBufferSize);
335 
336  // Try formatting into the SmallVector.
337  size_t BytesUsed = Fmt.print(V.data(), NextBufferSize);
338 
339  // If BytesUsed fit into the vector, we win.
340  if (BytesUsed <= NextBufferSize)
341  return write(V.data(), BytesUsed);
342 
343  // Otherwise, try again with a new size.
344  assert(BytesUsed > NextBufferSize && "Didn't grow buffer!?");
345  NextBufferSize = BytesUsed;
346  }
347 }
348 
350  Obj.format(*this);
351  return *this;
352 }
353 
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) {
361  break;
363  RightIndent = Difference;
364  break;
366  LeftIndent = Difference;
367  break;
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 
381  if (FN.Hex) {
383  if (FN.Upper && FN.HexPrefix)
385  else if (FN.Upper && !FN.HexPrefix)
387  else if (!FN.Upper && FN.HexPrefix)
389  else
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 
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();
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);
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 
475 template <char C>
476 static 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.
497 raw_ostream &raw_ostream::indent(unsigned NumSpaces) {
498  return write_padding<' '>(*this, NumSpaces);
499 }
500 
501 /// write_zeros - Insert 'NumZeros' nulls.
503  return write_padding<'\0'>(*this, NumZeros);
504 }
505 
506 bool 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.
514  return false;
515 
517  flush();
518 
519  return true;
520 }
521 
522 raw_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)
529  : sys::Process::OutputColor(static_cast<char>(colors), bold, bg);
530  if (colorcode)
531  write(colorcode, strlen(colorcode));
532  return *this;
533 }
534 
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 
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 
553 void raw_ostream::anchor() {}
554 
555 //===----------------------------------------------------------------------===//
556 // Formatted Output
557 //===----------------------------------------------------------------------===//
558 
559 // Out of line virtual method.
561 }
562 
563 //===----------------------------------------------------------------------===//
564 // raw_fd_ostream
565 //===----------------------------------------------------------------------===//
566 
567 static int getFD(StringRef Filename, std::error_code &EC,
569  sys::fs::OpenFlags Flags) {
570  assert((Access & sys::fs::FA_Write) &&
571  "Cannot make a raw_ostream from a read-only descriptor!");
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_FILENO;
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 
593 raw_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 
597 raw_fd_ostream::raw_fd_ostream(StringRef Filename, std::error_code &EC,
599  : raw_fd_ostream(Filename, EC, Disp, sys::fs::FA_Write, sys::fs::OF_None) {}
600 
601 raw_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 
606 raw_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 
611 raw_fd_ostream::raw_fd_ostream(StringRef Filename, std::error_code &EC,
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.
619 raw_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_FILENO)
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_CUR);
646 #ifdef _WIN32
647  // MSVCRT's _lseek(SEEK_CUR) doesn't return -1 for pipes.
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 
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.
701 static 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();
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 
736 void raw_fd_ostream::write_impl(const char *Ptr, size_t Size) {
737  assert(FD >= 0 && "File already closed.");
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_MAX;
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 == EINTR || errno == EAGAIN
773 #ifdef EWOULDBLOCK
774  || errno == EWOULDBLOCK
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, 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 
793  assert(ShouldClose);
794  ShouldClose = false;
795  flush();
796  if (auto EC = sys::Process::SafelyCloseFileDescriptor(FD))
797  error_detected(EC);
798  FD = -1;
799 }
800 
801 uint64_t raw_fd_ostream::seek(uint64_t off) {
802  assert(SupportsSeeking && "Stream does not support seeking!");
803  flush();
804 #ifdef _WIN32
805  pos = ::_lseeki64(FD, off, SEEK_SET);
806 #elif defined(HAVE_LSEEK64)
807  pos = ::lseek64(FD, off, SEEK_SET);
808 #else
809  pos = ::lseek(FD, off, SEEK_SET);
810 #endif
811  if (pos == (uint64_t)-1)
812  error_detected(std::error_code(errno, std::generic_category()));
813  return pos;
814 }
815 
816 void 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 
824 size_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;
834 #elif !defined(__minix)
835  // Minix has no st_blksize.
836  assert(FD >= 0 && "File not yet open!");
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) && is_displayed())
845  return 0;
846  // Return the preferred block size.
847  return statbuf.st_blksize;
848 #else
850 #endif
851 }
852 
855 }
856 
858  if (!HasColors)
860  return *HasColors;
861 }
862 
864  std::error_code EC = sys::fs::lockFile(FD);
865  if (!EC)
866  return sys::fs::FileLocker(FD);
867  return errorCodeToError(EC);
868 }
869 
871 raw_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 
878 void raw_fd_ostream::anchor() {}
879 
880 //===----------------------------------------------------------------------===//
881 // outs(), errs(), nulls()
882 //===----------------------------------------------------------------------===//
883 
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);
889  return S;
890 }
891 
893  // Set standard error to be unbuffered and tied to outs() by default.
894  static raw_fd_ostream S(STDERR_FILENO, false, true);
895  return S;
896 }
897 
898 /// nulls() - This returns a reference to a raw_ostream which discards output.
900  static raw_null_ostream S;
901  return S;
902 }
903 
904 //===----------------------------------------------------------------------===//
905 // File Streams
906 //===----------------------------------------------------------------------===//
907 
908 raw_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 
921 ssize_t raw_fd_stream::read(char *Ptr, size_t Size) {
922  assert(get_fd() >= 0 && "File already closed.");
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, std::generic_category()));
928  return Ret;
929 }
930 
932  return OS->get_kind() == OStreamKind::OK_FDStream;
933 }
934 
935 //===----------------------------------------------------------------------===//
936 // raw_string_ostream
937 //===----------------------------------------------------------------------===//
938 
940  flush();
941 }
942 
943 void 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 
951 uint64_t raw_svector_ostream::current_pos() const { return OS.size(); }
952 
953 void raw_svector_ostream::write_impl(const char *Ptr, size_t Size) {
954  OS.append(Ptr, Ptr + Size);
955 }
956 
957 void 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 
967 #ifndef NDEBUG
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 
975 void raw_null_ostream::write_impl(const char *Ptr, size_t Size) {
976 }
977 
978 uint64_t raw_null_ostream::current_pos() const {
979  return 0;
980 }
981 
982 void raw_null_ostream::pwrite_impl(const char *Ptr, size_t Size,
983  uint64_t Offset) {}
984 
985 void raw_pwrite_stream::anchor() {}
986 
987 void buffer_ostream::anchor() {}
988 
989 void buffer_unique_ostream::anchor() {}
990 
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 
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 }
llvm::Check::Size
@ Size
Definition: FileCheck.h:73
llvm::sys::fs::FA_Read
@ FA_Read
Definition: FileSystem.h:752
llvm::RunningWindows8OrGreater
bool RunningWindows8OrGreater()
Determines if the program is running on Windows 8 or newer.
llvm::alignTo
uint64_t alignTo(uint64_t Size, Align A)
Returns a multiple of A needed to store Size bytes.
Definition: Alignment.h:148
llvm::raw_ostream::tell
uint64_t tell() const
tell - Return the current offset with the file.
Definition: raw_ostream.h:132
llvm::raw_fd_ostream::supportsSeeking
bool supportsSeeking() const
Definition: raw_ostream.h:504
llvm::sys::fs::openFileForWrite
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:1042
llvm::sys::fs::CreationDisposition
CreationDisposition
Definition: FileSystem.h:729
MathExtras.h
llvm
Definition: AllocatorList.h:23
llvm::raw_fd_ostream::close
void close()
Manually flush the stream and close the file.
Definition: raw_ostream.cpp:792
llvm::lltok::Error
@ Error
Definition: LLToken.h:21
llvm::raw_ostream::SetBuffered
void SetBuffered()
Set the stream to be buffered, with an automatically determined buffer size.
Definition: raw_ostream.cpp:92
llvm::raw_ostream::SetUnbuffered
void SetUnbuffered()
Set the stream to be unbuffered.
Definition: raw_ostream.h:170
llvm::HexPrintStyle::Upper
@ Upper
FileSystem.h
llvm::sys::fs::OF_None
@ OF_None
Definition: FileSystem.h:757
llvm::raw_ostream::get_kind
OStreamKind get_kind() const
Definition: raw_ostream.h:134
llvm::sys::fs::FA_Write
@ FA_Write
Definition: FileSystem.h:753
llvm::sys::ChangeStdoutMode
std::error_code ChangeStdoutMode(fs::OpenFlags Flags)
llvm::raw_ostream::is_displayed
virtual bool is_displayed() const
This function determines if this stream is connected to a "tty" or "console" window.
Definition: raw_ostream.h:314
llvm::raw_ostream::write_zeros
raw_ostream & write_zeros(unsigned NumZeros)
write_zeros - Insert 'NumZeros' nulls.
Definition: raw_ostream.cpp:502
P
This currently compiles esp xmm0 movsd esp eax eax esp ret We should use not the dag combiner This is because dagcombine2 needs to be able to see through the X86ISD::Wrapper which DAGCombine can t really do The code for turning x load into a single vector load is target independent and should be moved to the dag combiner The code for turning x load into a vector load can only handle a direct load from a global or a direct load from the stack It should be generalized to handle any load from P
Definition: README-SSE.txt:411
llvm::raw_ostream::~raw_ostream
virtual ~raw_ostream()
Definition: raw_ostream.cpp:77
NativeFormatting.h
llvm::raw_ostream::OStreamKind::OK_FDStream
@ OK_FDStream
llvm::SmallVector
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1168
ErrorHandling.h
llvm::FormattedNumber
This is a helper class used for format_hex() and format_decimal().
Definition: Format.h:164
llvm::raw_ostream::write_escaped
raw_ostream & write_escaped(StringRef Str, bool UseHexEscapes=false)
Output Str, turning '\', '\t', ' ', '"', and anything that doesn't satisfy llvm::isPrint into an esca...
Definition: raw_ostream.cpp:163
llvm::raw_fd_ostream::raw_fd_ostream
raw_fd_ostream(StringRef Filename, std::error_code &EC)
Open the specified file for writing.
Definition: raw_ostream.cpp:593
llvm::raw_ostream::GREEN
static constexpr Colors GREEN
Definition: raw_ostream.h:109
WindowsSupport.h
llvm::sys::fs::file_type::regular_file
@ regular_file
llvm::formatv_object_base::format
void format(raw_ostream &S) const
Definition: FormatVariadic.h:84
ret
to esp esp setne al movzbw ax esp setg cl movzbw cx cmove cx cl jne LBB1_2 esp ret(also really horrible code on ppc). This is due to the expand code for 64-bit compares. GCC produces multiple branches
Offset
uint64_t Offset
Definition: ELFObjHandler.cpp:81
llvm::raw_ostream::OStreamKind
OStreamKind
Definition: raw_ostream.h:53
llvm::sys::fs::FileAccess
FileAccess
Definition: FileSystem.h:751
llvm::errs
raw_fd_ostream & errs()
This returns a reference to a raw_ostream for standard error.
Definition: raw_ostream.cpp:892
llvm::MipsISD::Ret
@ Ret
Definition: MipsISelLowering.h:116
llvm::raw_ostream::RED
static constexpr Colors RED
Definition: raw_ostream.h:108
llvm::raw_ostream::Colors::RESET
@ RESET
llvm::sys::locale::isPrint
bool isPrint(int c)
Definition: Locale.cpp:13
llvm::Expected
Tagged union holding either a T or a Error.
Definition: APFloat.h:42
STLExtras.h
llvm::X86AS::FS
@ FS
Definition: X86.h:183
Format.h
llvm::nulls
raw_ostream & nulls()
This returns a reference to a raw_ostream which simply discards output.
Definition: raw_ostream.cpp:899
llvm::sys::fs::all_write
@ all_write
Definition: FileSystem.h:101
llvm::Data
@ Data
Definition: SIMachineScheduler.h:56
endif
__FakeVCSRevision h endif() endif() set(generated_files "$
Definition: CMakeLists.txt:16
llvm::ArrayRef::empty
bool empty() const
empty - Check if the array is empty.
Definition: ArrayRef.h:158
llvm::raw_fd_ostream::has_colors
bool has_colors() const override
This function determines if this stream is displayed and supports colors.
Definition: raw_ostream.cpp:857
llvm::raw_ostream::MAGENTA
static constexpr Colors MAGENTA
Definition: raw_ostream.h:112
llvm::Optional::hasValue
constexpr bool hasValue() const
Definition: Optional.h:286
llvm::raw_fd_ostream::tryLockFor
LLVM_NODISCARD Expected< sys::fs::FileLocker > tryLockFor(std::chrono::milliseconds Timeout)
Tries to lock the underlying file within the specified period.
Definition: raw_ostream.cpp:871
llvm::raw_fd_stream::classof
static bool classof(const raw_ostream *OS)
Check if OS is a pointer of type raw_fd_stream*.
Definition: raw_ostream.cpp:931
llvm::raw_ostream::changeColor
virtual raw_ostream & changeColor(enum Colors Color, bool Bold=false, bool BG=false)
Changes the foreground color of text that will be output from this point forward.
Definition: raw_ostream.cpp:522
Process.h
llvm::raw_ostream::preferred_buffer_size
virtual size_t preferred_buffer_size() const
Return an efficient buffer size for the underlying output mechanism.
Definition: raw_ostream.cpp:87
llvm::outs
raw_fd_ostream & outs()
This returns a reference to a raw_fd_ostream for standard output.
Definition: raw_ostream.cpp:884
getFD
static int getFD(StringRef Filename, std::error_code &EC, sys::fs::CreationDisposition Disp, sys::fs::FileAccess Access, sys::fs::OpenFlags Flags)
Definition: raw_ostream.cpp:567
llvm::format_object_base
This is a helper class used for handling formatted output.
Definition: Format.h:38
llvm::raw_fd_ostream::has_error
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:520
llvm::FormattedString::JustifyRight
@ JustifyRight
Definition: Format.h:131
llvm::createFileError
Error createFileError(const Twine &F, Error E)
Concatenate a source file path and/or name with an Error.
Definition: Error.h:1278
E
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
llvm::SmallVectorImpl::append
void append(in_iter in_start, in_iter in_end)
Add the specified range to the end of the SmallVector.
Definition: SmallVector.h:648
llvm::raw_fd_ostream::inc_pos
void inc_pos(uint64_t Delta)
Definition: raw_ostream.h:470
llvm::raw_fd_ostream::get_fd
int get_fd() const
Return the file descriptor.
Definition: raw_ostream.h:467
llvm::writeToOutput
Error writeToOutput(StringRef OutputFileName, std::function< Error(raw_ostream &)> Write)
This helper creates an output stream and then passes it to Write.
Definition: raw_ostream.cpp:991
C
(vector float) vec_cmpeq(*A, *B) C
Definition: README_ALTIVEC.txt:86
llvm::errorCodeToError
Error errorCodeToError(std::error_code EC)
Helper for converting an std::error_code to a Error.
Definition: Error.cpp:87
write_padding
static raw_ostream & write_padding(raw_ostream &OS, unsigned NumChars)
Definition: raw_ostream.cpp:476
false
Definition: StackSlotColoring.cpp:142
llvm::raw_null_ostream::~raw_null_ostream
~raw_null_ostream() override
Definition: raw_ostream.cpp:966
llvm::raw_ostream::write
raw_ostream & write(unsigned char C)
Definition: raw_ostream.cpp:220
llvm::report_fatal_error
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:140
llvm::raw_ostream
This class implements an extremely fast bulk output stream that can only output to a stream.
Definition: raw_ostream.h:50
llvm::SmallVectorImpl::resize
void resize(size_type N)
Definition: SmallVector.h:606
llvm::raw_ostream::flush
void flush()
Definition: raw_ostream.h:183
llvm::raw_ostream::GetNumBytesInBuffer
size_t GetNumBytesInBuffer() const
Definition: raw_ostream.h:175
llvm::raw_fd_ostream::error_detected
void error_detected(std::error_code EC)
Set the flag indicating that an output error has been encountered.
Definition: raw_ostream.h:464
llvm::sys::fs::FileLocker
RAII class that facilitates file locking.
Definition: FileSystem.h:1203
llvm::raw_ostream::WHITE
static constexpr Colors WHITE
Definition: raw_ostream.h:114
c
the resulting code requires compare and branches when and if the revised code is with conditional branches instead of More there is a byte word extend before each where there should be only and the condition codes are not remembered when the same two values are compared twice More LSR enhancements i8 and i32 load store addressing modes are identical int int c
Definition: README.txt:418
FormatVariadic.h
llvm::array_lengthof
constexpr size_t array_lengthof(T(&)[N])
Find the length of an array.
Definition: STLExtras.h:1325
llvm::raw_fd_ostream::seek
uint64_t seek(uint64_t off)
Flushes the stream and repositions the underlying file descriptor position to the offset specified fr...
Definition: raw_ostream.cpp:801
llvm::sys::fs::openFileForReadWrite
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:1083
llvm::raw_ostream::enable_colors
virtual void enable_colors(bool enable)
Definition: raw_ostream.h:322
llvm::SmallString< 16 >
llvm::sys::Process::OutputBold
static const char * OutputBold(bool bg)
Same as OutputColor, but only enables the bold attribute.
llvm::format_object_base::print
unsigned print(char *Buffer, unsigned BufferSize) const
Format the object into the specified buffer.
Definition: Format.h:54
llvm::sys::Process::SafelyCloseFileDescriptor
static std::error_code SafelyCloseFileDescriptor(int FD)
llvm::FormattedString::JustifyLeft
@ JustifyLeft
Definition: Format.h:131
llvm::sys::fs::file_status
Represents the result of a call to sys::fs::status().
Definition: FileSystem.h:226
llvm::sys::Process::FileDescriptorHasColors
static bool FileDescriptorHasColors(int fd)
This function determines if the given file descriptor is displayd and supports colors.
llvm::sys::Process::ResetColor
static const char * ResetColor()
Resets the terminals colors, or returns an escape sequence to do so.
llvm::sys::fs::lockFile
std::error_code lockFile(int FD)
Lock the file.
llvm::raw_pwrite_stream
An abstract base class for streams implementations that also support a pwrite operation.
Definition: raw_ostream.h:406
move
compiles ldr LCPI1_0 ldr ldr mov lsr tst moveq r1 ldr LCPI1_1 and r0 bx lr It would be better to do something like to fold the shift into the conditional move
Definition: README.txt:546
llvm::sys::Process::OutputColor
static const char * OutputColor(char c, bool bold, bool bg)
This function returns the colorcode escape sequences.
llvm::HexPrintStyle::PrefixLower
@ PrefixLower
I
#define I(x, y, z)
Definition: MD5.cpp:59
StringExtras.h
llvm::joinErrors
Error joinErrors(Error E1, Error E2)
Concatenate errors.
Definition: Error.h:429
llvm::AMDGPU::SDWA::DWORD
@ DWORD
Definition: SIDefines.h:646
llvm::raw_fd_stream::read
ssize_t read(char *Ptr, size_t Size)
This reads the Size bytes into a buffer pointed by Ptr.
Definition: raw_ostream.cpp:921
llvm::Log2_64_Ceil
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:615
llvm::HexStyle::Style
Style
Definition: MCInstPrinter.h:32
message
message(STATUS "Targeting ${t}") add_subdirectory($
Definition: CMakeLists.txt:31
assert
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
memcpy
<%struct.s * > cast struct s *S to sbyte *< sbyte * > sbyte uint cast struct s *agg result to sbyte *< sbyte * > sbyte uint cast struct s *memtmp to sbyte *< sbyte * > sbyte uint ret void llc ends up issuing two memcpy or custom lower memcpy(of small size) to be ldmia/stmia. I think option 2 is better but the current register allocator cannot allocate a chunk of registers at a time. A feasible temporary solution is to use specific physical registers at the lowering time for small(<
llvm::IntegerStyle::Integer
@ Integer
Mode
SI Whole Quad Mode
Definition: SIWholeQuadMode.cpp:262
function
print Print MemDeps of function
Definition: MemDepPrinter.cpp:83
UUID
std::pair< llvm::MachO::Target, std::string > UUID
Definition: TextStubCommon.h:23
llvm::sys::fs::CD_CreateAlways
@ CD_CreateAlways
CD_CreateAlways - When opening a file:
Definition: FileSystem.h:733
llvm::FloatStyle::Exponent
@ Exponent
Status
Definition: SIModeRegister.cpp:28
llvm::raw_ostream::CYAN
static constexpr Colors CYAN
Definition: raw_ostream.h:113
llvm::raw_null_ostream
A raw_ostream that discards all output.
Definition: raw_ostream.h:680
llvm::write_hex
void write_hex(raw_ostream &S, uint64_t N, HexPrintStyle Style, Optional< size_t > Width=None)
Definition: NativeFormatting.cpp:132
llvm::raw_ostream::reverseColor
virtual raw_ostream & reverseColor()
Reverses the foreground and background colors.
Definition: raw_ostream.cpp:544
llvm::raw_fd_ostream::error
std::error_code error() const
Definition: raw_ostream.h:514
llvm::min
Expected< ExpressionValue > min(const ExpressionValue &Lhs, const ExpressionValue &Rhs)
Definition: FileCheck.cpp:357
llvm::StringRef
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:57
llvm::raw_fd_ostream::is_displayed
bool is_displayed() const override
This function determines if this stream is connected to a "tty" or "console" window.
Definition: raw_ostream.cpp:853
Compiler.h
S
add sub stmia L5 ldr r0 bl L_printf $stub Instead of a and a wouldn t it be better to do three moves *Return an aggregate type is even return S
Definition: README.txt:210
llvm::format
format_object< Ts... > format(const char *Fmt, const Ts &... Vals)
These are helper functions used to produce formatted output.
Definition: Format.h:124
llvm::sys::fs::TempFile::create
static Expected< TempFile > create(const Twine &Model, unsigned Mode=all_read|all_write)
This creates a temporary file with createUniqueFile and schedules it for deletion with sys::RemoveFil...
Definition: Path.cpp:1291
LLVM_FALLTHROUGH
#define LLVM_FALLTHROUGH
LLVM_FALLTHROUGH - Mark fallthrough cases in switch statements.
Definition: Compiler.h:281
llvm::raw_fd_ostream
A raw_ostream that writes to a file descriptor.
Definition: raw_ostream.h:432
llvm::FormattedBytes
Definition: Format.h:215
llvm::raw_ostream::operator<<
raw_ostream & operator<<(char C)
Definition: raw_ostream.h:188
llvm::sys::Process::OutputReverse
static const char * OutputReverse()
This function returns the escape sequence to reverse forground and background colors.
llvm::HexPrintStyle::PrefixUpper
@ PrefixUpper
ConvertUTF.h
llvm::make_error_code
std::error_code make_error_code(BitcodeError E)
Definition: BitcodeReader.h:270
llvm::FormattedString::JustifyNone
@ JustifyNone
Definition: Format.h:131
llvm::FormattedString::JustifyCenter
@ JustifyCenter
Definition: Format.h:131
llvm::raw_ostream::RESET
static constexpr Colors RESET
Definition: raw_ostream.h:116
llvm::sys::fs::all_exe
@ all_exe
Definition: FileSystem.h:102
llvm::Error
Lightweight error class with error context and mandatory checking.
Definition: Error.h:157
Success
#define Success
Definition: AArch64Disassembler.cpp:248
llvm::HexPrintStyle
HexPrintStyle
Definition: NativeFormatting.h:22
llvm::HexPrintStyle::Lower
@ Lower
llvm::sys::fs::OpenFlags
OpenFlags
Definition: FileSystem.h:756
llvm::write_double
void write_double(raw_ostream &S, double D, FloatStyle Style, Optional< size_t > Precision=None)
Definition: NativeFormatting.cpp:162
llvm::sys::Process::FileDescriptorIsDisplayed
static bool FileDescriptorIsDisplayed(int fd)
This function determines if the given file descriptor is connected to a "tty" or "console" window.
llvm::raw_ostream::SAVEDCOLOR
static constexpr Colors SAVEDCOLOR
Definition: raw_ostream.h:115
llvm::raw_fd_ostream::~raw_fd_ostream
~raw_fd_ostream() override
Definition: raw_ostream.cpp:660
llvm::write_integer
void write_integer(raw_ostream &S, unsigned int N, size_t MinDigits, IntegerStyle Style)
Definition: NativeFormatting.cpp:102
llvm::sys::fs::all_read
@ all_read
Definition: FileSystem.h:100
llvm::raw_fd_ostream::lock
LLVM_NODISCARD Expected< sys::fs::FileLocker > lock()
Locks the underlying file.
Definition: raw_ostream.cpp:863
llvm::raw_fd_stream::raw_fd_stream
raw_fd_stream(StringRef Filename, std::error_code &EC)
Open the specified file for reading/writing/seeking.
Definition: raw_ostream.cpp:908
llvm::sys::Process::ColorNeedsFlush
static bool ColorNeedsFlush()
Whether changing colors requires the output to be flushed.
llvm::raw_ostream::SetBufferSize
void SetBufferSize(size_t Size)
Set the stream to be buffered, using the specified buffer size.
Definition: raw_ostream.h:152
llvm::Expected::takeError
Error takeError()
Take ownership of the stored error.
Definition: Error.h:557
llvm::FormattedString
This is a helper class for left_justify, right_justify, and center_justify.
Definition: Format.h:129
llvm::raw_string_ostream::~raw_string_ostream
~raw_string_ostream() override
Definition: raw_ostream.cpp:939
llvm::raw_ostream::indent
raw_ostream & indent(unsigned NumSpaces)
indent - Insert 'NumSpaces' spaces.
Definition: raw_ostream.cpp:497
llvm::sys::fs::status
std::error_code status(const Twine &path, file_status &result, bool follow=true)
Get file status as if by POSIX stat().
llvm::raw_ostream::BLACK
static constexpr Colors BLACK
Definition: raw_ostream.h:107
N
#define N
Program.h
llvm::raw_ostream::Colors
Colors
Definition: raw_ostream.h:94
llvm::raw_svector_ostream
A raw_ostream that writes to an SmallVector or SmallString.
Definition: raw_ostream.h:647
llvm::raw_ostream::resetColor
virtual raw_ostream & resetColor()
Resets the colors to terminal defaults.
Definition: raw_ostream.cpp:535
llvm::formatv_object_base
Definition: FormatVariadic.h:65
llvm::raw_ostream::BLUE
static constexpr Colors BLUE
Definition: raw_ostream.h:111
llvm::raw_ostream::uuid_t
uint8_t[16] uuid_t
Output a formatted UUID with dash separators.
Definition: raw_ostream.h:263
llvm::raw_ostream::YELLOW
static constexpr Colors YELLOW
Definition: raw_ostream.h:110
LLVM_UNLIKELY
#define LLVM_UNLIKELY(EXPR)
Definition: Compiler.h:220
raw_ostream.h
llvm::format_object_base::home
virtual void home()
Definition: raw_ostream.cpp:560
true
basic Basic Alias true
Definition: BasicAliasAnalysis.cpp:1797
llvm::raw_ostream::write_uuid
raw_ostream & write_uuid(const uuid_t UUID)
Definition: raw_ostream.cpp:153
llvm::sys::fs::tryLockFile
std::error_code tryLockFile(int FD, std::chrono::milliseconds Timeout=std::chrono::milliseconds(0))
Try to locks the file during the specified time.
llvm::Optional::getValue
constexpr const T & getValue() const LLVM_LVALUE_FUNCTION
Definition: Optional.h:280
llvm::raw_ostream::write_hex
raw_ostream & write_hex(unsigned long long N)
Output N in hexadecimal, without any prefix or padding.
Definition: raw_ostream.cpp:140