llvm/lib/Support/raw_ostream.cpp

   1 //===--- raw_ostream.cpp - Implement the raw_ostream classes --------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8 //
   9 // This implements support for bulk buffered stream output.
  10 //
  11 //===----------------------------------------------------------------------===//
  12
  13 #include "llvm/Support/raw_ostream.h"
  14 #include "llvm/ADT/STLExtras.h"
  15 #include "llvm/ADT/StringExtras.h"
  16 #include "llvm/Config/config.h"
  17 #include "llvm/Support/Compiler.h"
  18 #include "llvm/Support/ErrorHandling.h"
  19 #include "llvm/Support/FileSystem.h"
  20 #include "llvm/Support/Format.h"
  21 #include "llvm/Support/FormatVariadic.h"
  22 #include "llvm/Support/MathExtras.h"
  23 #include "llvm/Support/NativeFormatting.h"
  24 #include "llvm/Support/Process.h"
  25 #include "llvm/Support/Program.h"
  26 #include <algorithm>
  27 #include <cctype>
  28 #include <cerrno>
  29 #include <cstdio>
  30 #include <iterator>
  31 #include <sys/stat.h>
  32
  33 // <fcntl.h> may provide O_BINARY.
  34 #if defined(HAVE_FCNTL_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
  60 #include "llvm/Support/ConvertUTF.h"
  61 #include "llvm/Support/Windows/WindowsSupport.h"
  62 #endif
  63
  64 using namespace llvm;
  65
  66 constexpr raw_ostream::Colors raw_ostream::BLACK;
  67 constexpr raw_ostream::Colors raw_ostream::RED;
  68 constexpr raw_ostream::Colors raw_ostream::GREEN;
  69 constexpr raw_ostream::Colors raw_ostream::YELLOW;
  70 constexpr raw_ostream::Colors raw_ostream::BLUE;
  71 constexpr raw_ostream::Colors raw_ostream::MAGENTA;
  72 constexpr raw_ostream::Colors raw_ostream::CYAN;
  73 constexpr raw_ostream::Colors raw_ostream::WHITE;
  74 constexpr raw_ostream::Colors raw_ostream::SAVEDCOLOR;
  75 constexpr raw_ostream::Colors raw_ostream::RESET;
  76
  77 raw_ostream::~raw_ostream() {
  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
  87 size_t raw_ostream::preferred_buffer_size() const {
  88   // BUFSIZ is intended to be a reasonable default.
  89   return BUFSIZ;
  90 }
  91
  92 void raw_ostream::SetBuffered() {
  93   // Ask the subclass to determine an appropriate buffer size.
  94   if (size_t Size = preferred_buffer_size())
  95     SetBufferSize(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
 120 raw_ostream &raw_ostream::operator<<(unsigned long N) {
 121   write_integer(*this, static_cast<uint64_t>(N), 0, IntegerStyle::Integer);
 122   return *this;
 123 }
 124
 125 raw_ostream &raw_ostream::operator<<(long N) {
 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
 135 raw_ostream &raw_ostream::operator<<(long long N) {
 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) {
 141   llvm::write_hex(*this, N, HexPrintStyle::Lower);
 142   return *this;
 143 }
 144
 145 raw_ostream &raw_ostream::operator<<(Colors C) {
 146   if (C == Colors::RESET)
 147     resetColor();
 148   else
 149     changeColor(C);
 150   return *this;
 151 }
 152
 153 raw_ostream &raw_ostream::write_uuid(const uuid_t UUID) {
 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
 163 raw_ostream &raw_ostream::write_escaped(StringRef Str,
 164                                         bool UseHexEscapes) {
 165   for (unsigned char c : Str) {
 166     switch (c) {
 167     case '\\':
 168       *this << '\\' << '\\';
 169       break;
 170     case '\t':
 171       *this << '\\' << 't';
 172       break;
 173     case '\n':
 174       *this << '\\' << 'n';
 175       break;
 176     case '"':
 177       *this << '\\' << '"';
 178       break;
 179     default:
 180       if (isPrint(c)) {
 181         *this << c;
 182         break;
 183       }
 184
 185       // Write out the escaped representation.
 186       if (UseHexEscapes) {
 187         *this << '\\' << 'x';
 188         *this << hexdigit((c >> 4 & 0xF));
 189         *this << hexdigit((c >> 0) & 0xF);
 190       } else {
 191         // Always use a full 3-character octal escape.
 192         *this << '\\';
 193         *this << char('0' + ((c >> 6) & 7));
 194         *this << char('0' + ((c >> 3) & 7));
 195         *this << char('0' + ((c >> 0) & 7));
 196       }
 197     }
 198   }
 199
 200   return *this;
 201 }
 202
 203 raw_ostream &raw_ostream::operator<<(const void *P) {
 204   llvm::write_hex(*this, (uintptr_t)P, HexPrintStyle::PrefixLower);
 205   return *this;
 206 }
 207
 208 raw_ostream &raw_ostream::operator<<(double N) {
 209   llvm::write_double(*this, N, FloatStyle::Exponent);
 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
 220 raw_ostream &raw_ostream::write(unsigned char C) {
 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.
 309 raw_ostream &raw_ostream::operator<<(const format_object_base &Fmt) {
 310   // If we have more than a few bytes left in our output buffer, try
 311   // formatting directly onto its end.
 312   size_t NextBufferSize = 127;
 313   size_t BufferBytesLeft = OutBufEnd - OutBufCur;
 314   if (BufferBytesLeft > 3) {
 315     size_t BytesUsed = Fmt.print(OutBufCur, BufferBytesLeft);
 316
 317     // Common case is that we have plenty of space.
 318     if (BytesUsed <= BufferBytesLeft) {
 319       OutBufCur += BytesUsed;
 320       return *this;
 321     }
 322
 323     // Otherwise, we overflowed and the return value tells us the size to try
 324     // again with.
 325     NextBufferSize = BytesUsed;
 326   }
 327
 328   // If we got here, we didn't have enough space in the output buffer for the
 329   // string.  Try printing into a SmallVector that is resized to have enough
 330   // space.  Iterate until we win.
 331   SmallVector<char, 128> V;
 332
 333   while (true) {
 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
 349 raw_ostream &raw_ostream::operator<<(const formatv_object_base &Obj) {
 350   Obj.format(*this);
 351   return *this;
 352 }
 353
 354 raw_ostream &raw_ostream::operator<<(const FormattedString &FS) {
 355   unsigned LeftIndent = 0;
 356   unsigned RightIndent = 0;
 357   const ssize_t Difference = FS.Width - FS.Str.size();
 358   if (Difference > 0) {
 359     switch (FS.Justify) {
 360     case FormattedString::JustifyNone:
 361       break;
 362     case FormattedString::JustifyLeft:
 363       RightIndent = Difference;
 364       break;
 365     case FormattedString::JustifyRight:
 366       LeftIndent = Difference;
 367       break;
 368     case FormattedString::JustifyCenter:
 369       LeftIndent = Difference / 2;
 370       RightIndent = Difference - LeftIndent;
 371       break;
 372     }
 373   }
 374   indent(LeftIndent);
 375   (*this) << FS.Str;
 376   indent(RightIndent);
 377   return *this;
 378 }
 379
 380 raw_ostream &raw_ostream::operator<<(const FormattedNumber &FN) {
 381   if (FN.Hex) {
 382     HexPrintStyle Style;
 383     if (FN.Upper && FN.HexPrefix)
 384       Style = HexPrintStyle::PrefixUpper;
 385     else if (FN.Upper && !FN.HexPrefix)
 386       Style = HexPrintStyle::Upper;
 387     else if (!FN.Upper && FN.HexPrefix)
 388       Style = HexPrintStyle::PrefixLower;
 389     else
 390       Style = HexPrintStyle::Lower;
 391     llvm::write_hex(*this, FN.HexValue, Style, FN.Width);
 392   } else {
 393     llvm::SmallString<16> Buffer;
 394     llvm::raw_svector_ostream Stream(Buffer);
 395     llvm::write_integer(Stream, FN.DecValue, 0, IntegerStyle::Integer);
 396     if (Buffer.size() < FN.Width)
 397       indent(FN.Width - Buffer.size());
 398     (*this) << Buffer;
 399   }
 400   return *this;
 401 }
 402
 403 raw_ostream &raw_ostream::operator<<(const FormattedBytes &FB) {
 404   if (FB.Bytes.empty())
 405     return *this;
 406
 407   size_t LineIndex = 0;
 408   auto Bytes = FB.Bytes;
 409   const size_t Size = Bytes.size();
 410   HexPrintStyle HPS = FB.Upper ? HexPrintStyle::Upper : HexPrintStyle::Lower;
 411   uint64_t OffsetWidth = 0;
 412   if (FB.FirstByteOffset.hasValue()) {
 413     // Figure out how many nibbles are needed to print the largest offset
 414     // represented by this data set, so that we can align the offset field
 415     // to the right width.
 416     size_t Lines = Size / FB.NumPerLine;
 417     uint64_t MaxOffset = *FB.FirstByteOffset + Lines * FB.NumPerLine;
 418     unsigned Power = 0;
 419     if (MaxOffset > 0)
 420       Power = llvm::Log2_64_Ceil(MaxOffset);
 421     OffsetWidth = std::max<uint64_t>(4, llvm::alignTo(Power, 4) / 4);
 422   }
 423
 424   // The width of a block of data including all spaces for group separators.
 425   unsigned NumByteGroups =
 426       alignTo(FB.NumPerLine, FB.ByteGroupSize) / FB.ByteGroupSize;
 427   unsigned BlockCharWidth = FB.NumPerLine * 2 + NumByteGroups - 1;
 428
 429   while (!Bytes.empty()) {
 430     indent(FB.IndentLevel);
 431
 432     if (FB.FirstByteOffset.hasValue()) {
 433       uint64_t Offset = FB.FirstByteOffset.getValue();
 434       llvm::write_hex(*this, Offset + LineIndex, HPS, OffsetWidth);
 435       *this << ": ";
 436     }
 437
 438     auto Line = Bytes.take_front(FB.NumPerLine);
 439
 440     size_t CharsPrinted = 0;
 441     // Print the hex bytes for this line in groups
 442     for (size_t I = 0; I < Line.size(); ++I, CharsPrinted += 2) {
 443       if (I && (I % FB.ByteGroupSize) == 0) {
 444         ++CharsPrinted;
 445         *this << " ";
 446       }
 447       llvm::write_hex(*this, Line[I], HPS, 2);
 448     }
 449
 450     if (FB.ASCII) {
 451       // Print any spaces needed for any bytes that we didn't print on this
 452       // line so that the ASCII bytes are correctly aligned.
 453       assert(BlockCharWidth >= CharsPrinted);
 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.
 502 raw_ostream &raw_ostream::write_zeros(unsigned NumZeros) {
 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.
 513   if (sys::Process::ColorNeedsFlush() && !is_displayed())
 514     return false;
 515
 516   if (sys::Process::ColorNeedsFlush())
 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)
 528           ? sys::Process::OutputBold(bg)
 529           : sys::Process::OutputColor(static_cast<char>(colors), bold, bg);
 530   if (colorcode)
 531     write(colorcode, strlen(colorcode));
 532   return *this;
 533 }
 534
 535 raw_ostream &raw_ostream::resetColor() {
 536   if (!prepare_colors())
 537     return *this;
 538
 539   if (const char *colorcode = sys::Process::ResetColor())
 540     write(colorcode, strlen(colorcode));
 541   return *this;
 542 }
 543
 544 raw_ostream &raw_ostream::reverseColor() {
 545   if (!prepare_colors())
 546     return *this;
 547
 548   if (const char *colorcode = sys::Process::OutputReverse())
 549     write(colorcode, strlen(colorcode));
 550   return *this;
 551 }
 552
 553 void raw_ostream::anchor() {}
 554
 555 //===----------------------------------------------------------------------===//
 556 //  Formatted Output
 557 //===----------------------------------------------------------------------===//
 558
 559 // Out of line virtual method.
 560 void format_object_base::home() {
 561 }
 562
 563 //===----------------------------------------------------------------------===//
 564 //  raw_fd_ostream
 565 //===----------------------------------------------------------------------===//
 566
 567 static int getFD(StringRef Filename, std::error_code &EC,
 568                  sys::fs::CreationDisposition Disp, sys::fs::FileAccess Access,
 569                  sys::fs::OpenFlags Flags) {
 570   assert((Access & sys::fs::FA_Write) &&
 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,
 598                                sys::fs::CreationDisposition Disp)
 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,
 612                                sys::fs::CreationDisposition Disp,
 613                                sys::fs::FileAccess Access,
 614                                sys::fs::OpenFlags Flags)
 615     : raw_fd_ostream(getFD(Filename, EC, Disp, Access, Flags), true) {}
 616
 617 /// FD is the file descriptor that this writes to.  If ShouldClose is true, this
 618 /// closes the file when the stream is destroyed.
 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.
 648   sys::fs::file_status Status;
 649   std::error_code EC = status(FD, Status);
 650   SupportsSeeking = !EC && Status.type() == sys::fs::file_type::regular_file;
 651 #else
 652   SupportsSeeking = loc != (off_t)-1;
 653 #endif
 654   if (!SupportsSeeking)
 655     pos = 0;
 656   else
 657     pos = static_cast<uint64_t>(loc);
 658 }
 659
 660 raw_fd_ostream::~raw_fd_ostream() {
 661   if (FD >= 0) {
 662     flush();
 663     if (ShouldClose) {
 664       if (auto EC = sys::Process::SafelyCloseFileDescriptor(FD))
 665         error_detected(EC);
 666     }
 667   }
 668
 669 #ifdef __MINGW32__
 670   // On mingw, global dtors should not call exit().
 671   // report_fatal_error() invokes exit(). We know report_fatal_error()
 672   // might not write messages to stderr when any errors were detected
 673   // on FD == 2.
 674   if (FD == 2) return;
 675 #endif
 676
 677   // If there are any pending errors, report them now. Clients wishing
 678   // to avoid report_fatal_error calls should check for errors with
 679   // has_error() and clear the error flag with clear_error() before
 680   // destructing raw_ostream objects which may have errors.
 681   if (has_error())
 682     report_fatal_error("IO failure on output stream: " + error().message(),
 683                        /*gen_crash_diag=*/false);
 684 }
 685
 686 #if defined(_WIN32)
 687 // The most reliable way to print unicode in a Windows console is with
 688 // WriteConsoleW. To use that, first transcode from UTF-8 to UTF-16. This
 689 // assumes that LLVM programs always print valid UTF-8 to the console. The data
 690 // might not be UTF-8 for two major reasons:
 691 // 1. The program is printing binary (-filetype=obj -o -), in which case it
 692 // would have been gibberish anyway.
 693 // 2. The program is printing text in a semi-ascii compatible codepage like
 694 // shift-jis or cp1252.
 695 //
 696 // Most LLVM programs don't produce non-ascii text unless they are quoting
 697 // user source input. A well-behaved LLVM program should either validate that
 698 // the input is UTF-8 or transcode from the local codepage to UTF-8 before
 699 // quoting it. If they don't, this may mess up the encoding, but this is still
 700 // probably the best compromise we can make.
 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();
 711   if (!RunningWindows8OrGreater())
 712     MaxWriteSize = 32767;
 713
 714   size_t WCharsWritten = 0;
 715   do {
 716     size_t WCharsToWrite =
 717         std::min(MaxWriteSize, WideText.size() - WCharsWritten);
 718     DWORD ActuallyWritten;
 719     bool Success =
 720         ::WriteConsoleW((HANDLE)::_get_osfhandle(FD), &WideText[WCharsWritten],
 721                         WCharsToWrite, &ActuallyWritten,
 722                         /*Reserved=*/nullptr);
 723
 724     // The most likely reason for WriteConsoleW to fail is that FD no longer
 725     // points to a console. Fall back to ::write. If this isn't the first loop
 726     // iteration, something is truly wrong.
 727     if (!Success)
 728       return false;
 729
 730     WCharsWritten += ActuallyWritten;
 731   } while (WCharsWritten != WideText.size());
 732   return true;
 733 }
 734 #endif
 735
 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
 792 void raw_fd_ostream::close() {
 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;
 833   return raw_ostream::preferred_buffer_size();
 834 #elif !defined(__minix)
 835   // Minix has no st_blksize.
 836   assert(FD >= 0 && "File not yet open!");
 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
 849   return raw_ostream::preferred_buffer_size();
 850 #endif
 851 }
 852
 853 bool raw_fd_ostream::is_displayed() const {
 854   return sys::Process::FileDescriptorIsDisplayed(FD);
 855 }
 856
 857 bool raw_fd_ostream::has_colors() const {
 858   if (!HasColors)
 859     HasColors = sys::Process::FileDescriptorHasColors(FD);
 860   return *HasColors;
 861 }
 862
 863 Expected<sys::fs::FileLocker> raw_fd_ostream::lock() {
 864   std::error_code EC = sys::fs::lockFile(FD);
 865   if (!EC)
 866     return sys::fs::FileLocker(FD);
 867   return errorCodeToError(EC);
 868 }
 869
 870 Expected<sys::fs::FileLocker>
 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
 884 raw_fd_ostream &llvm::outs() {
 885   // Set buffer settings to model stdout behavior.
 886   std::error_code EC;
 887   static raw_fd_ostream S("-", EC, sys::fs::OF_None);
 888   assert(!EC);
 889   return S;
 890 }
 891
 892 raw_fd_ostream &llvm::errs() {
 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.
 899 raw_ostream &llvm::nulls() {
 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
 931 bool raw_fd_stream::classof(const raw_ostream *OS) {
 932   return OS->get_kind() == OStreamKind::OK_FDStream;
 933 }
 934
 935 //===----------------------------------------------------------------------===//
 936 //  raw_string_ostream
 937 //===----------------------------------------------------------------------===//
 938
 939 raw_string_ostream::~raw_string_ostream() {
 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
 966 raw_null_ostream::~raw_null_ostream() {
 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
 991 Error llvm::writeToOutput(StringRef OutputFileName,
 992                           std::function<Error(raw_ostream &)> Write) {
 993   if (OutputFileName == "-")
 994     return Write(outs());
 995
 996   if (OutputFileName == "/dev/null") {
 997     raw_null_ostream Out;
 998     return Write(Out);
 999   }
1000
1001   unsigned Mode = sys::fs::all_read | sys::fs::all_write | sys::fs::all_exe;
1002   Expected<sys::fs::TempFile> Temp =
1003       sys::fs::TempFile::create(OutputFileName + ".temp-stream-%%%%%%", Mode);
1004   if (!Temp)
1005     return createFileError(OutputFileName, Temp.takeError());
1006
1007   raw_fd_ostream Out(Temp->FD, false);
1008
1009   if (Error E = Write(Out)) {
1010     if (Error DiscardError = Temp->discard())
1011       return joinErrors(std::move(E), std::move(DiscardError));
1012     return E;
1013   }
1014   Out.flush();
1015
1016   return Temp->keep(OutputFileName);
1017 }