contrib/llvm/lib/Support/raw_ostream.cpp

   1 //===--- raw_ostream.cpp - Implement the raw_ostream classes --------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This implements support for bulk buffered stream output.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "llvm/Support/raw_ostream.h"
  15 #include "llvm/ADT/STLExtras.h"
  16 #include "llvm/ADT/SmallVector.h"
  17 #include "llvm/ADT/StringExtras.h"
  18 #include "llvm/Config/config.h"
  19 #include "llvm/Support/Compiler.h"
  20 #include "llvm/Support/ErrorHandling.h"
  21 #include "llvm/Support/FileSystem.h"
  22 #include "llvm/Support/Format.h"
  23 #include "llvm/Support/FormatVariadic.h"
  24 #include "llvm/Support/MathExtras.h"
  25 #include "llvm/Support/NativeFormatting.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
  63 #include "Windows/WindowsSupport.h"
  64 #endif
  65
  66 using namespace llvm;
  67
  68 raw_ostream::~raw_ostream() {
  69   // raw_ostream's subclasses should take care to flush the buffer
  70   // in their destructors.
  71   assert(OutBufCur == OutBufStart &&
  72          "raw_ostream destructor called with non-empty buffer!");
  73
  74   if (BufferMode == InternalBuffer)
  75     delete [] OutBufStart;
  76 }
  77
  78 size_t raw_ostream::preferred_buffer_size() const {
  79   // BUFSIZ is intended to be a reasonable default.
  80   return BUFSIZ;
  81 }
  82
  83 void raw_ostream::SetBuffered() {
  84   // Ask the subclass to determine an appropriate buffer size.
  85   if (size_t Size = preferred_buffer_size())
  86     SetBufferSize(Size);
  87   else
  88     // It may return 0, meaning this stream should be unbuffered.
  89     SetUnbuffered();
  90 }
  91
  92 void raw_ostream::SetBufferAndMode(char *BufferStart, size_t Size,
  93                                    BufferKind Mode) {
  94   assert(((Mode == Unbuffered && !BufferStart && Size == 0) ||
  95           (Mode != Unbuffered && BufferStart && Size != 0)) &&
  96          "stream must be unbuffered or have at least one byte");
  97   // Make sure the current buffer is free of content (we can't flush here; the
  98   // child buffer management logic will be in write_impl).
  99   assert(GetNumBytesInBuffer() == 0 && "Current buffer is non-empty!");
 100
 101   if (BufferMode == InternalBuffer)
 102     delete [] OutBufStart;
 103   OutBufStart = BufferStart;
 104   OutBufEnd = OutBufStart+Size;
 105   OutBufCur = OutBufStart;
 106   BufferMode = Mode;
 107
 108   assert(OutBufStart <= OutBufEnd && "Invalid size!");
 109 }
 110
 111 raw_ostream &raw_ostream::operator<<(unsigned long N) {
 112   write_integer(*this, static_cast<uint64_t>(N), 0, IntegerStyle::Integer);
 113   return *this;
 114 }
 115
 116 raw_ostream &raw_ostream::operator<<(long N) {
 117   write_integer(*this, static_cast<int64_t>(N), 0, IntegerStyle::Integer);
 118   return *this;
 119 }
 120
 121 raw_ostream &raw_ostream::operator<<(unsigned long long N) {
 122   write_integer(*this, static_cast<uint64_t>(N), 0, IntegerStyle::Integer);
 123   return *this;
 124 }
 125
 126 raw_ostream &raw_ostream::operator<<(long long N) {
 127   write_integer(*this, static_cast<int64_t>(N), 0, IntegerStyle::Integer);
 128   return *this;
 129 }
 130
 131 raw_ostream &raw_ostream::write_hex(unsigned long long N) {
 132   llvm::write_hex(*this, N, HexPrintStyle::Lower);
 133   return *this;
 134 }
 135
 136 raw_ostream &raw_ostream::write_uuid(const uuid_t UUID) {
 137   for (int Idx = 0; Idx < 16; ++Idx) {
 138     *this << format("%02" PRIX32, UUID[Idx]);
 139     if (Idx == 3 || Idx == 5 || Idx == 7 || Idx == 9)
 140       *this << "-";
 141   }
 142   return *this;
 143 }
 144
 145
 146 raw_ostream &raw_ostream::write_escaped(StringRef Str,
 147                                         bool UseHexEscapes) {
 148   for (unsigned char c : Str) {
 149     switch (c) {
 150     case '\\':
 151       *this << '\\' << '\\';
 152       break;
 153     case '\t':
 154       *this << '\\' << 't';
 155       break;
 156     case '\n':
 157       *this << '\\' << 'n';
 158       break;
 159     case '"':
 160       *this << '\\' << '"';
 161       break;
 162     default:
 163       if (isPrint(c)) {
 164         *this << c;
 165         break;
 166       }
 167
 168       // Write out the escaped representation.
 169       if (UseHexEscapes) {
 170         *this << '\\' << 'x';
 171         *this << hexdigit((c >> 4 & 0xF));
 172         *this << hexdigit((c >> 0) & 0xF);
 173       } else {
 174         // Always use a full 3-character octal escape.
 175         *this << '\\';
 176         *this << char('0' + ((c >> 6) & 7));
 177         *this << char('0' + ((c >> 3) & 7));
 178         *this << char('0' + ((c >> 0) & 7));
 179       }
 180     }
 181   }
 182
 183   return *this;
 184 }
 185
 186 raw_ostream &raw_ostream::operator<<(const void *P) {
 187   llvm::write_hex(*this, (uintptr_t)P, HexPrintStyle::PrefixLower);
 188   return *this;
 189 }
 190
 191 raw_ostream &raw_ostream::operator<<(double N) {
 192   llvm::write_double(*this, N, FloatStyle::Exponent);
 193   return *this;
 194 }
 195
 196 void raw_ostream::flush_nonempty() {
 197   assert(OutBufCur > OutBufStart && "Invalid call to flush_nonempty.");
 198   size_t Length = OutBufCur - OutBufStart;
 199   OutBufCur = OutBufStart;
 200   write_impl(OutBufStart, Length);
 201 }
 202
 203 raw_ostream &raw_ostream::write(unsigned char C) {
 204   // Group exceptional cases into a single branch.
 205   if (LLVM_UNLIKELY(OutBufCur >= OutBufEnd)) {
 206     if (LLVM_UNLIKELY(!OutBufStart)) {
 207       if (BufferMode == Unbuffered) {
 208         write_impl(reinterpret_cast<char*>(&C), 1);
 209         return *this;
 210       }
 211       // Set up a buffer and start over.
 212       SetBuffered();
 213       return write(C);
 214     }
 215
 216     flush_nonempty();
 217   }
 218
 219   *OutBufCur++ = C;
 220   return *this;
 221 }
 222
 223 raw_ostream &raw_ostream::write(const char *Ptr, size_t Size) {
 224   // Group exceptional cases into a single branch.
 225   if (LLVM_UNLIKELY(size_t(OutBufEnd - OutBufCur) < Size)) {
 226     if (LLVM_UNLIKELY(!OutBufStart)) {
 227       if (BufferMode == Unbuffered) {
 228         write_impl(Ptr, Size);
 229         return *this;
 230       }
 231       // Set up a buffer and start over.
 232       SetBuffered();
 233       return write(Ptr, Size);
 234     }
 235
 236     size_t NumBytes = OutBufEnd - OutBufCur;
 237
 238     // If the buffer is empty at this point we have a string that is larger
 239     // than the buffer. Directly write the chunk that is a multiple of the
 240     // preferred buffer size and put the remainder in the buffer.
 241     if (LLVM_UNLIKELY(OutBufCur == OutBufStart)) {
 242       assert(NumBytes != 0 && "undefined behavior");
 243       size_t BytesToWrite = Size - (Size % NumBytes);
 244       write_impl(Ptr, BytesToWrite);
 245       size_t BytesRemaining = Size - BytesToWrite;
 246       if (BytesRemaining > size_t(OutBufEnd - OutBufCur)) {
 247         // Too much left over to copy into our buffer.
 248         return write(Ptr + BytesToWrite, BytesRemaining);
 249       }
 250       copy_to_buffer(Ptr + BytesToWrite, BytesRemaining);
 251       return *this;
 252     }
 253
 254     // We don't have enough space in the buffer to fit the string in. Insert as
 255     // much as possible, flush and start over with the remainder.
 256     copy_to_buffer(Ptr, NumBytes);
 257     flush_nonempty();
 258     return write(Ptr + NumBytes, Size - NumBytes);
 259   }
 260
 261   copy_to_buffer(Ptr, Size);
 262
 263   return *this;
 264 }
 265
 266 void raw_ostream::copy_to_buffer(const char *Ptr, size_t Size) {
 267   assert(Size <= size_t(OutBufEnd - OutBufCur) && "Buffer overrun!");
 268
 269   // Handle short strings specially, memcpy isn't very good at very short
 270   // strings.
 271   switch (Size) {
 272   case 4: OutBufCur[3] = Ptr[3]; LLVM_FALLTHROUGH;
 273   case 3: OutBufCur[2] = Ptr[2]; LLVM_FALLTHROUGH;
 274   case 2: OutBufCur[1] = Ptr[1]; LLVM_FALLTHROUGH;
 275   case 1: OutBufCur[0] = Ptr[0]; LLVM_FALLTHROUGH;
 276   case 0: break;
 277   default:
 278     memcpy(OutBufCur, Ptr, Size);
 279     break;
 280   }
 281
 282   OutBufCur += Size;
 283 }
 284
 285 // Formatted output.
 286 raw_ostream &raw_ostream::operator<<(const format_object_base &Fmt) {
 287   // If we have more than a few bytes left in our output buffer, try
 288   // formatting directly onto its end.
 289   size_t NextBufferSize = 127;
 290   size_t BufferBytesLeft = OutBufEnd - OutBufCur;
 291   if (BufferBytesLeft > 3) {
 292     size_t BytesUsed = Fmt.print(OutBufCur, BufferBytesLeft);
 293
 294     // Common case is that we have plenty of space.
 295     if (BytesUsed <= BufferBytesLeft) {
 296       OutBufCur += BytesUsed;
 297       return *this;
 298     }
 299
 300     // Otherwise, we overflowed and the return value tells us the size to try
 301     // again with.
 302     NextBufferSize = BytesUsed;
 303   }
 304
 305   // If we got here, we didn't have enough space in the output buffer for the
 306   // string.  Try printing into a SmallVector that is resized to have enough
 307   // space.  Iterate until we win.
 308   SmallVector<char, 128> V;
 309
 310   while (true) {
 311     V.resize(NextBufferSize);
 312
 313     // Try formatting into the SmallVector.
 314     size_t BytesUsed = Fmt.print(V.data(), NextBufferSize);
 315
 316     // If BytesUsed fit into the vector, we win.
 317     if (BytesUsed <= NextBufferSize)
 318       return write(V.data(), BytesUsed);
 319
 320     // Otherwise, try again with a new size.
 321     assert(BytesUsed > NextBufferSize && "Didn't grow buffer!?");
 322     NextBufferSize = BytesUsed;
 323   }
 324 }
 325
 326 raw_ostream &raw_ostream::operator<<(const formatv_object_base &Obj) {
 327   SmallString<128> S;
 328   Obj.format(*this);
 329   return *this;
 330 }
 331
 332 raw_ostream &raw_ostream::operator<<(const FormattedString &FS) {
 333   if (FS.Str.size() >= FS.Width || FS.Justify == FormattedString::JustifyNone) {
 334     this->operator<<(FS.Str);
 335     return *this;
 336   }
 337   const size_t Difference = FS.Width - FS.Str.size();
 338   switch (FS.Justify) {
 339   case FormattedString::JustifyLeft:
 340     this->operator<<(FS.Str);
 341     this->indent(Difference);
 342     break;
 343   case FormattedString::JustifyRight:
 344     this->indent(Difference);
 345     this->operator<<(FS.Str);
 346     break;
 347   case FormattedString::JustifyCenter: {
 348     int PadAmount = Difference / 2;
 349     this->indent(PadAmount);
 350     this->operator<<(FS.Str);
 351     this->indent(Difference - PadAmount);
 352     break;
 353   }
 354   default:
 355     llvm_unreachable("Bad Justification");
 356   }
 357   return *this;
 358 }
 359
 360 raw_ostream &raw_ostream::operator<<(const FormattedNumber &FN) {
 361   if (FN.Hex) {
 362     HexPrintStyle Style;
 363     if (FN.Upper && FN.HexPrefix)
 364       Style = HexPrintStyle::PrefixUpper;
 365     else if (FN.Upper && !FN.HexPrefix)
 366       Style = HexPrintStyle::Upper;
 367     else if (!FN.Upper && FN.HexPrefix)
 368       Style = HexPrintStyle::PrefixLower;
 369     else
 370       Style = HexPrintStyle::Lower;
 371     llvm::write_hex(*this, FN.HexValue, Style, FN.Width);
 372   } else {
 373     llvm::SmallString<16> Buffer;
 374     llvm::raw_svector_ostream Stream(Buffer);
 375     llvm::write_integer(Stream, FN.DecValue, 0, IntegerStyle::Integer);
 376     if (Buffer.size() < FN.Width)
 377       indent(FN.Width - Buffer.size());
 378     (*this) << Buffer;
 379   }
 380   return *this;
 381 }
 382
 383 raw_ostream &raw_ostream::operator<<(const FormattedBytes &FB) {
 384   if (FB.Bytes.empty())
 385     return *this;
 386
 387   size_t LineIndex = 0;
 388   auto Bytes = FB.Bytes;
 389   const size_t Size = Bytes.size();
 390   HexPrintStyle HPS = FB.Upper ? HexPrintStyle::Upper : HexPrintStyle::Lower;
 391   uint64_t OffsetWidth = 0;
 392   if (FB.FirstByteOffset.hasValue()) {
 393     // Figure out how many nibbles are needed to print the largest offset
 394     // represented by this data set, so that we can align the offset field
 395     // to the right width.
 396     size_t Lines = Size / FB.NumPerLine;
 397     uint64_t MaxOffset = *FB.FirstByteOffset + Lines * FB.NumPerLine;
 398     unsigned Power = 0;
 399     if (MaxOffset > 0)
 400       Power = llvm::Log2_64_Ceil(MaxOffset);
 401     OffsetWidth = std::max<uint64_t>(4, llvm::alignTo(Power, 4) / 4);
 402   }
 403
 404   // The width of a block of data including all spaces for group separators.
 405   unsigned NumByteGroups =
 406       alignTo(FB.NumPerLine, FB.ByteGroupSize) / FB.ByteGroupSize;
 407   unsigned BlockCharWidth = FB.NumPerLine * 2 + NumByteGroups - 1;
 408
 409   while (!Bytes.empty()) {
 410     indent(FB.IndentLevel);
 411
 412     if (FB.FirstByteOffset.hasValue()) {
 413       uint64_t Offset = FB.FirstByteOffset.getValue();
 414       llvm::write_hex(*this, Offset + LineIndex, HPS, OffsetWidth);
 415       *this << ": ";
 416     }
 417
 418     auto Line = Bytes.take_front(FB.NumPerLine);
 419
 420     size_t CharsPrinted = 0;
 421     // Print the hex bytes for this line in groups
 422     for (size_t I = 0; I < Line.size(); ++I, CharsPrinted += 2) {
 423       if (I && (I % FB.ByteGroupSize) == 0) {
 424         ++CharsPrinted;
 425         *this << " ";
 426       }
 427       llvm::write_hex(*this, Line[I], HPS, 2);
 428     }
 429
 430     if (FB.ASCII) {
 431       // Print any spaces needed for any bytes that we didn't print on this
 432       // line so that the ASCII bytes are correctly aligned.
 433       assert(BlockCharWidth >= CharsPrinted);
 434       indent(BlockCharWidth - CharsPrinted + 2);
 435       *this << "|";
 436
 437       // Print the ASCII char values for each byte on this line
 438       for (uint8_t Byte : Line) {
 439         if (isPrint(Byte))
 440           *this << static_cast<char>(Byte);
 441         else
 442           *this << '.';
 443       }
 444       *this << '|';
 445     }
 446
 447     Bytes = Bytes.drop_front(Line.size());
 448     LineIndex += Line.size();
 449     if (LineIndex < Size)
 450       *this << '\n';
 451   }
 452   return *this;
 453 }
 454
 455 template <char C>
 456 static raw_ostream &write_padding(raw_ostream &OS, unsigned NumChars) {
 457   static const char Chars[] = {C, C, C, C, C, C, C, C, C, C, C, C, C, C, C, C,
 458                                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
 463   // Usually the indentation is small, handle it with a fastpath.
 464   if (NumChars < array_lengthof(Chars))
 465     return OS.write(Chars, NumChars);
 466
 467   while (NumChars) {
 468     unsigned NumToWrite = std::min(NumChars,
 469                                    (unsigned)array_lengthof(Chars)-1);
 470     OS.write(Chars, NumToWrite);
 471     NumChars -= NumToWrite;
 472   }
 473   return OS;
 474 }
 475
 476 /// indent - Insert 'NumSpaces' spaces.
 477 raw_ostream &raw_ostream::indent(unsigned NumSpaces) {
 478   return write_padding<' '>(*this, NumSpaces);
 479 }
 480
 481 /// write_zeros - Insert 'NumZeros' nulls.
 482 raw_ostream &raw_ostream::write_zeros(unsigned NumZeros) {
 483   return write_padding<'\0'>(*this, NumZeros);
 484 }
 485
 486 void raw_ostream::anchor() {}
 487
 488 //===----------------------------------------------------------------------===//
 489 //  Formatted Output
 490 //===----------------------------------------------------------------------===//
 491
 492 // Out of line virtual method.
 493 void format_object_base::home() {
 494 }
 495
 496 //===----------------------------------------------------------------------===//
 497 //  raw_fd_ostream
 498 //===----------------------------------------------------------------------===//
 499
 500 static int getFD(StringRef Filename, std::error_code &EC,
 501                  sys::fs::CreationDisposition Disp, sys::fs::FileAccess Access,
 502                  sys::fs::OpenFlags Flags) {
 503   assert((Access & sys::fs::FA_Write) &&
 504          "Cannot make a raw_ostream from a read-only descriptor!");
 505
 506   // Handle "-" as stdout. Note that when we do this, we consider ourself
 507   // the owner of stdout and may set the "binary" flag globally based on Flags.
 508   if (Filename == "-") {
 509     EC = std::error_code();
 510     // If user requested binary then put stdout into binary mode if
 511     // possible.
 512     if (!(Flags & sys::fs::OF_Text))
 513       sys::ChangeStdoutToBinary();
 514     return STDOUT_FILENO;
 515   }
 516
 517   int FD;
 518   if (Access & sys::fs::FA_Read)
 519     EC = sys::fs::openFileForReadWrite(Filename, FD, Disp, Flags);
 520   else
 521     EC = sys::fs::openFileForWrite(Filename, FD, Disp, Flags);
 522   if (EC)
 523     return -1;
 524
 525   return FD;
 526 }
 527
 528 raw_fd_ostream::raw_fd_ostream(StringRef Filename, std::error_code &EC)
 529     : raw_fd_ostream(Filename, EC, sys::fs::CD_CreateAlways, sys::fs::FA_Write,
 530                      sys::fs::OF_None) {}
 531
 532 raw_fd_ostream::raw_fd_ostream(StringRef Filename, std::error_code &EC,
 533                                sys::fs::CreationDisposition Disp)
 534     : raw_fd_ostream(Filename, EC, Disp, sys::fs::FA_Write, sys::fs::OF_None) {}
 535
 536 raw_fd_ostream::raw_fd_ostream(StringRef Filename, std::error_code &EC,
 537                                sys::fs::FileAccess Access)
 538     : raw_fd_ostream(Filename, EC, sys::fs::CD_CreateAlways, Access,
 539                      sys::fs::OF_None) {}
 540
 541 raw_fd_ostream::raw_fd_ostream(StringRef Filename, std::error_code &EC,
 542                                sys::fs::OpenFlags Flags)
 543     : raw_fd_ostream(Filename, EC, sys::fs::CD_CreateAlways, sys::fs::FA_Write,
 544                      Flags) {}
 545
 546 raw_fd_ostream::raw_fd_ostream(StringRef Filename, std::error_code &EC,
 547                                sys::fs::CreationDisposition Disp,
 548                                sys::fs::FileAccess Access,
 549                                sys::fs::OpenFlags Flags)
 550     : raw_fd_ostream(getFD(Filename, EC, Disp, Access, Flags), true) {}
 551
 552 /// FD is the file descriptor that this writes to.  If ShouldClose is true, this
 553 /// closes the file when the stream is destroyed.
 554 raw_fd_ostream::raw_fd_ostream(int fd, bool shouldClose, bool unbuffered)
 555     : raw_pwrite_stream(unbuffered), FD(fd), ShouldClose(shouldClose) {
 556   if (FD < 0 ) {
 557     ShouldClose = false;
 558     return;
 559   }
 560
 561   // Do not attempt to close stdout or stderr. We used to try to maintain the
 562   // property that tools that support writing file to stdout should not also
 563   // write informational output to stdout, but in practice we were never able to
 564   // maintain this invariant. Many features have been added to LLVM and clang
 565   // (-fdump-record-layouts, optimization remarks, etc) that print to stdout, so
 566   // users must simply be aware that mixed output and remarks is a possibility.
 567   if (FD <= STDERR_FILENO)
 568     ShouldClose = false;
 569
 570   // Get the starting position.
 571   off_t loc = ::lseek(FD, 0, SEEK_CUR);
 572 #ifdef _WIN32
 573   // MSVCRT's _lseek(SEEK_CUR) doesn't return -1 for pipes.
 574   sys::fs::file_status Status;
 575   std::error_code EC = status(FD, Status);
 576   SupportsSeeking = !EC && Status.type() == sys::fs::file_type::regular_file;
 577 #else
 578   SupportsSeeking = loc != (off_t)-1;
 579 #endif
 580   if (!SupportsSeeking)
 581     pos = 0;
 582   else
 583     pos = static_cast<uint64_t>(loc);
 584 }
 585
 586 raw_fd_ostream::~raw_fd_ostream() {
 587   if (FD >= 0) {
 588     flush();
 589     if (ShouldClose) {
 590       if (auto EC = sys::Process::SafelyCloseFileDescriptor(FD))
 591         error_detected(EC);
 592     }
 593   }
 594
 595 #ifdef __MINGW32__
 596   // On mingw, global dtors should not call exit().
 597   // report_fatal_error() invokes exit(). We know report_fatal_error()
 598   // might not write messages to stderr when any errors were detected
 599   // on FD == 2.
 600   if (FD == 2) return;
 601 #endif
 602
 603   // If there are any pending errors, report them now. Clients wishing
 604   // to avoid report_fatal_error calls should check for errors with
 605   // has_error() and clear the error flag with clear_error() before
 606   // destructing raw_ostream objects which may have errors.
 607   if (has_error())
 608     report_fatal_error("IO failure on output stream: " + error().message(),
 609                        /*GenCrashDiag=*/false);
 610 }
 611
 612 void raw_fd_ostream::write_impl(const char *Ptr, size_t Size) {
 613   assert(FD >= 0 && "File already closed.");
 614   pos += Size;
 615
 616   // The maximum write size is limited to SSIZE_MAX because a write
 617   // greater than SSIZE_MAX is implementation-defined in POSIX.
 618   // Since SSIZE_MAX is not portable, we use SIZE_MAX >> 1 instead.
 619   size_t MaxWriteSize = SIZE_MAX >> 1;
 620
 621 #if defined(__linux__)
 622   // It is observed that Linux returns EINVAL for a very large write (>2G).
 623   // Make it a reasonably small value.
 624   MaxWriteSize = 1024 * 1024 * 1024;
 625 #elif defined(_WIN32)
 626   // Writing a large size of output to Windows console returns ENOMEM. It seems
 627   // that, prior to Windows 8, WriteFile() is redirecting to WriteConsole(), and
 628   // the latter has a size limit (66000 bytes or less, depending on heap usage).
 629   if (::_isatty(FD) && !RunningWindows8OrGreater())
 630     MaxWriteSize = 32767;
 631 #endif
 632
 633   do {
 634     size_t ChunkSize = std::min(Size, MaxWriteSize);
 635     ssize_t ret = ::write(FD, Ptr, ChunkSize);
 636
 637     if (ret < 0) {
 638       // If it's a recoverable error, swallow it and retry the write.
 639       //
 640       // Ideally we wouldn't ever see EAGAIN or EWOULDBLOCK here, since
 641       // raw_ostream isn't designed to do non-blocking I/O. However, some
 642       // programs, such as old versions of bjam, have mistakenly used
 643       // O_NONBLOCK. For compatibility, emulate blocking semantics by
 644       // spinning until the write succeeds. If you don't want spinning,
 645       // don't use O_NONBLOCK file descriptors with raw_ostream.
 646       if (errno == EINTR || errno == EAGAIN
 647 #ifdef EWOULDBLOCK
 648           || errno == EWOULDBLOCK
 649 #endif
 650           )
 651         continue;
 652
 653       // Otherwise it's a non-recoverable error. Note it and quit.
 654       error_detected(std::error_code(errno, std::generic_category()));
 655       break;
 656     }
 657
 658     // The write may have written some or all of the data. Update the
 659     // size and buffer pointer to reflect the remainder that needs
 660     // to be written. If there are no bytes left, we're done.
 661     Ptr += ret;
 662     Size -= ret;
 663   } while (Size > 0);
 664 }
 665
 666 void raw_fd_ostream::close() {
 667   assert(ShouldClose);
 668   ShouldClose = false;
 669   flush();
 670   if (auto EC = sys::Process::SafelyCloseFileDescriptor(FD))
 671     error_detected(EC);
 672   FD = -1;
 673 }
 674
 675 uint64_t raw_fd_ostream::seek(uint64_t off) {
 676   assert(SupportsSeeking && "Stream does not support seeking!");
 677   flush();
 678 #ifdef _WIN32
 679   pos = ::_lseeki64(FD, off, SEEK_SET);
 680 #elif defined(HAVE_LSEEK64)
 681   pos = ::lseek64(FD, off, SEEK_SET);
 682 #else
 683   pos = ::lseek(FD, off, SEEK_SET);
 684 #endif
 685   if (pos == (uint64_t)-1)
 686     error_detected(std::error_code(errno, std::generic_category()));
 687   return pos;
 688 }
 689
 690 void raw_fd_ostream::pwrite_impl(const char *Ptr, size_t Size,
 691                                  uint64_t Offset) {
 692   uint64_t Pos = tell();
 693   seek(Offset);
 694   write(Ptr, Size);
 695   seek(Pos);
 696 }
 697
 698 size_t raw_fd_ostream::preferred_buffer_size() const {
 699 #if !defined(_MSC_VER) && !defined(__MINGW32__) && !defined(__minix)
 700   // Windows and Minix have no st_blksize.
 701   assert(FD >= 0 && "File not yet open!");
 702   struct stat statbuf;
 703   if (fstat(FD, &statbuf) != 0)
 704     return 0;
 705
 706   // If this is a terminal, don't use buffering. Line buffering
 707   // would be a more traditional thing to do, but it's not worth
 708   // the complexity.
 709   if (S_ISCHR(statbuf.st_mode) && isatty(FD))
 710     return 0;
 711   // Return the preferred block size.
 712   return statbuf.st_blksize;
 713 #else
 714   return raw_ostream::preferred_buffer_size();
 715 #endif
 716 }
 717
 718 raw_ostream &raw_fd_ostream::changeColor(enum Colors colors, bool bold,
 719                                          bool bg) {
 720   if (sys::Process::ColorNeedsFlush())
 721     flush();
 722   const char *colorcode =
 723     (colors == SAVEDCOLOR) ? sys::Process::OutputBold(bg)
 724     : sys::Process::OutputColor(colors, bold, bg);
 725   if (colorcode) {
 726     size_t len = strlen(colorcode);
 727     write(colorcode, len);
 728     // don't account colors towards output characters
 729     pos -= len;
 730   }
 731   return *this;
 732 }
 733
 734 raw_ostream &raw_fd_ostream::resetColor() {
 735   if (sys::Process::ColorNeedsFlush())
 736     flush();
 737   const char *colorcode = sys::Process::ResetColor();
 738   if (colorcode) {
 739     size_t len = strlen(colorcode);
 740     write(colorcode, len);
 741     // don't account colors towards output characters
 742     pos -= len;
 743   }
 744   return *this;
 745 }
 746
 747 raw_ostream &raw_fd_ostream::reverseColor() {
 748   if (sys::Process::ColorNeedsFlush())
 749     flush();
 750   const char *colorcode = sys::Process::OutputReverse();
 751   if (colorcode) {
 752     size_t len = strlen(colorcode);
 753     write(colorcode, len);
 754     // don't account colors towards output characters
 755     pos -= len;
 756   }
 757   return *this;
 758 }
 759
 760 bool raw_fd_ostream::is_displayed() const {
 761   return sys::Process::FileDescriptorIsDisplayed(FD);
 762 }
 763
 764 bool raw_fd_ostream::has_colors() const {
 765   return sys::Process::FileDescriptorHasColors(FD);
 766 }
 767
 768 void raw_fd_ostream::anchor() {}
 769
 770 //===----------------------------------------------------------------------===//
 771 //  outs(), errs(), nulls()
 772 //===----------------------------------------------------------------------===//
 773
 774 /// outs() - This returns a reference to a raw_ostream for standard output.
 775 /// Use it like: outs() << "foo" << "bar";
 776 raw_ostream &llvm::outs() {
 777   // Set buffer settings to model stdout behavior.
 778   std::error_code EC;
 779   static raw_fd_ostream S("-", EC, sys::fs::F_None);
 780   assert(!EC);
 781   return S;
 782 }
 783
 784 /// errs() - This returns a reference to a raw_ostream for standard error.
 785 /// Use it like: errs() << "foo" << "bar";
 786 raw_ostream &llvm::errs() {
 787   // Set standard error to be unbuffered by default.
 788   static raw_fd_ostream S(STDERR_FILENO, false, true);
 789   return S;
 790 }
 791
 792 /// nulls() - This returns a reference to a raw_ostream which discards output.
 793 raw_ostream &llvm::nulls() {
 794   static raw_null_ostream S;
 795   return S;
 796 }
 797
 798 //===----------------------------------------------------------------------===//
 799 //  raw_string_ostream
 800 //===----------------------------------------------------------------------===//
 801
 802 raw_string_ostream::~raw_string_ostream() {
 803   flush();
 804 }
 805
 806 void raw_string_ostream::write_impl(const char *Ptr, size_t Size) {
 807   OS.append(Ptr, Size);
 808 }
 809
 810 //===----------------------------------------------------------------------===//
 811 //  raw_svector_ostream
 812 //===----------------------------------------------------------------------===//
 813
 814 uint64_t raw_svector_ostream::current_pos() const { return OS.size(); }
 815
 816 void raw_svector_ostream::write_impl(const char *Ptr, size_t Size) {
 817   OS.append(Ptr, Ptr + Size);
 818 }
 819
 820 void raw_svector_ostream::pwrite_impl(const char *Ptr, size_t Size,
 821                                       uint64_t Offset) {
 822   memcpy(OS.data() + Offset, Ptr, Size);
 823 }
 824
 825 //===----------------------------------------------------------------------===//
 826 //  raw_null_ostream
 827 //===----------------------------------------------------------------------===//
 828
 829 raw_null_ostream::~raw_null_ostream() {
 830 #ifndef NDEBUG
 831   // ~raw_ostream asserts that the buffer is empty. This isn't necessary
 832   // with raw_null_ostream, but it's better to have raw_null_ostream follow
 833   // the rules than to change the rules just for raw_null_ostream.
 834   flush();
 835 #endif
 836 }
 837
 838 void raw_null_ostream::write_impl(const char *Ptr, size_t Size) {
 839 }
 840
 841 uint64_t raw_null_ostream::current_pos() const {
 842   return 0;
 843 }
 844
 845 void raw_null_ostream::pwrite_impl(const char *Ptr, size_t Size,
 846                                    uint64_t Offset) {}
 847
 848 void raw_pwrite_stream::anchor() {}