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