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/MathExtras.h" 24 #include "llvm/Support/Process.h" 25 #include "llvm/Support/Program.h" 26 #include <cctype> 27 #include <cerrno> 28 #include <sys/stat.h> 29 #include <system_error> 30 31 // <fcntl.h> may provide O_BINARY. 32 #if defined(HAVE_FCNTL_H) 33 # include <fcntl.h> 34 #endif 35 36 #if defined(HAVE_UNISTD_H) 37 # include <unistd.h> 38 #endif 39 #if defined(HAVE_SYS_UIO_H) && defined(HAVE_WRITEV) 40 # include <sys/uio.h> 41 #endif 42 43 #if defined(__CYGWIN__) 44 #include <io.h> 45 #endif 46 47 #if defined(_MSC_VER) 48 #include <io.h> 49 #ifndef STDIN_FILENO 50 # define STDIN_FILENO 0 51 #endif 52 #ifndef STDOUT_FILENO 53 # define STDOUT_FILENO 1 54 #endif 55 #ifndef STDERR_FILENO 56 # define STDERR_FILENO 2 57 #endif 58 #endif 59 60 using namespace llvm; 61 62 raw_ostream::~raw_ostream() { 63 // raw_ostream's subclasses should take care to flush the buffer 64 // in their destructors. 65 assert(OutBufCur == OutBufStart && 66 "raw_ostream destructor called with non-empty buffer!"); 67 68 if (BufferMode == InternalBuffer) 69 delete [] OutBufStart; 70 } 71 72 // An out of line virtual method to provide a home for the class vtable. 73 void raw_ostream::handle() {} 74 75 size_t raw_ostream::preferred_buffer_size() const { 76 // BUFSIZ is intended to be a reasonable default. 77 return BUFSIZ; 78 } 79 80 void raw_ostream::SetBuffered() { 81 // Ask the subclass to determine an appropriate buffer size. 82 if (size_t Size = preferred_buffer_size()) 83 SetBufferSize(Size); 84 else 85 // It may return 0, meaning this stream should be unbuffered. 86 SetUnbuffered(); 87 } 88 89 void raw_ostream::SetBufferAndMode(char *BufferStart, size_t Size, 90 BufferKind Mode) { 91 assert(((Mode == Unbuffered && !BufferStart && Size == 0) || 92 (Mode != Unbuffered && BufferStart && Size != 0)) && 93 "stream must be unbuffered or have at least one byte"); 94 // Make sure the current buffer is free of content (we can't flush here; the 95 // child buffer management logic will be in write_impl). 96 assert(GetNumBytesInBuffer() == 0 && "Current buffer is non-empty!"); 97 98 if (BufferMode == InternalBuffer) 99 delete [] OutBufStart; 100 OutBufStart = BufferStart; 101 OutBufEnd = OutBufStart+Size; 102 OutBufCur = OutBufStart; 103 BufferMode = Mode; 104 105 assert(OutBufStart <= OutBufEnd && "Invalid size!"); 106 } 107 108 raw_ostream &raw_ostream::operator<<(unsigned long N) { 109 // Zero is a special case. 110 if (N == 0) 111 return *this << '0'; 112 113 char NumberBuffer[20]; 114 char *EndPtr = NumberBuffer+sizeof(NumberBuffer); 115 char *CurPtr = EndPtr; 116 117 while (N) { 118 *--CurPtr = '0' + char(N % 10); 119 N /= 10; 120 } 121 return write(CurPtr, EndPtr-CurPtr); 122 } 123 124 raw_ostream &raw_ostream::operator<<(long N) { 125 if (N < 0) { 126 *this << '-'; 127 // Avoid undefined behavior on LONG_MIN with a cast. 128 N = -(unsigned long)N; 129 } 130 131 return this->operator<<(static_cast<unsigned long>(N)); 132 } 133 134 raw_ostream &raw_ostream::operator<<(unsigned long long N) { 135 // Output using 32-bit div/mod when possible. 136 if (N == static_cast<unsigned long>(N)) 137 return this->operator<<(static_cast<unsigned long>(N)); 138 139 char NumberBuffer[20]; 140 char *EndPtr = NumberBuffer+sizeof(NumberBuffer); 141 char *CurPtr = EndPtr; 142 143 while (N) { 144 *--CurPtr = '0' + char(N % 10); 145 N /= 10; 146 } 147 return write(CurPtr, EndPtr-CurPtr); 148 } 149 150 raw_ostream &raw_ostream::operator<<(long long N) { 151 if (N < 0) { 152 *this << '-'; 153 // Avoid undefined behavior on INT64_MIN with a cast. 154 N = -(unsigned long long)N; 155 } 156 157 return this->operator<<(static_cast<unsigned long long>(N)); 158 } 159 160 raw_ostream &raw_ostream::write_hex(unsigned long long N) { 161 // Zero is a special case. 162 if (N == 0) 163 return *this << '0'; 164 165 char NumberBuffer[20]; 166 char *EndPtr = NumberBuffer+sizeof(NumberBuffer); 167 char *CurPtr = EndPtr; 168 169 while (N) { 170 uintptr_t x = N % 16; 171 *--CurPtr = (x < 10 ? '0' + x : 'a' + x - 10); 172 N /= 16; 173 } 174 175 return write(CurPtr, EndPtr-CurPtr); 176 } 177 178 raw_ostream &raw_ostream::write_escaped(StringRef Str, 179 bool UseHexEscapes) { 180 for (unsigned i = 0, e = Str.size(); i != e; ++i) { 181 unsigned char c = Str[i]; 182 183 switch (c) { 184 case '\\': 185 *this << '\\' << '\\'; 186 break; 187 case '\t': 188 *this << '\\' << 't'; 189 break; 190 case '\n': 191 *this << '\\' << 'n'; 192 break; 193 case '"': 194 *this << '\\' << '"'; 195 break; 196 default: 197 if (std::isprint(c)) { 198 *this << c; 199 break; 200 } 201 202 // Write out the escaped representation. 203 if (UseHexEscapes) { 204 *this << '\\' << 'x'; 205 *this << hexdigit((c >> 4 & 0xF)); 206 *this << hexdigit((c >> 0) & 0xF); 207 } else { 208 // Always use a full 3-character octal escape. 209 *this << '\\'; 210 *this << char('0' + ((c >> 6) & 7)); 211 *this << char('0' + ((c >> 3) & 7)); 212 *this << char('0' + ((c >> 0) & 7)); 213 } 214 } 215 } 216 217 return *this; 218 } 219 220 raw_ostream &raw_ostream::operator<<(const void *P) { 221 *this << '0' << 'x'; 222 223 return write_hex((uintptr_t) P); 224 } 225 226 raw_ostream &raw_ostream::operator<<(double N) { 227 #ifdef _WIN32 228 // On MSVCRT and compatible, output of %e is incompatible to Posix 229 // by default. Number of exponent digits should be at least 2. "%+03d" 230 // FIXME: Implement our formatter to here or Support/Format.h! 231 #if __cplusplus >= 201103L && defined(__MINGW32__) 232 // FIXME: It should be generic to C++11. 233 if (N == 0.0 && std::signbit(N)) 234 return *this << "-0.000000e+00"; 235 #else 236 int fpcl = _fpclass(N); 237 238 // negative zero 239 if (fpcl == _FPCLASS_NZ) 240 return *this << "-0.000000e+00"; 241 #endif 242 243 char buf[16]; 244 unsigned len; 245 len = format("%e", N).snprint(buf, sizeof(buf)); 246 if (len <= sizeof(buf) - 2) { 247 if (len >= 5 && buf[len - 5] == 'e' && buf[len - 3] == '0') { 248 int cs = buf[len - 4]; 249 if (cs == '+' || cs == '-') { 250 int c1 = buf[len - 2]; 251 int c0 = buf[len - 1]; 252 if (isdigit(static_cast<unsigned char>(c1)) && 253 isdigit(static_cast<unsigned char>(c0))) { 254 // Trim leading '0': "...e+012" -> "...e+12\0" 255 buf[len - 3] = c1; 256 buf[len - 2] = c0; 257 buf[--len] = 0; 258 } 259 } 260 } 261 return this->operator<<(buf); 262 } 263 #endif 264 return this->operator<<(format("%e", N)); 265 } 266 267 268 269 void raw_ostream::flush_nonempty() { 270 assert(OutBufCur > OutBufStart && "Invalid call to flush_nonempty."); 271 size_t Length = OutBufCur - OutBufStart; 272 OutBufCur = OutBufStart; 273 write_impl(OutBufStart, Length); 274 } 275 276 raw_ostream &raw_ostream::write(unsigned char C) { 277 // Group exceptional cases into a single branch. 278 if (LLVM_UNLIKELY(OutBufCur >= OutBufEnd)) { 279 if (LLVM_UNLIKELY(!OutBufStart)) { 280 if (BufferMode == Unbuffered) { 281 write_impl(reinterpret_cast<char*>(&C), 1); 282 return *this; 283 } 284 // Set up a buffer and start over. 285 SetBuffered(); 286 return write(C); 287 } 288 289 flush_nonempty(); 290 } 291 292 *OutBufCur++ = C; 293 return *this; 294 } 295 296 raw_ostream &raw_ostream::write(const char *Ptr, size_t Size) { 297 // Group exceptional cases into a single branch. 298 if (LLVM_UNLIKELY(size_t(OutBufEnd - OutBufCur) < Size)) { 299 if (LLVM_UNLIKELY(!OutBufStart)) { 300 if (BufferMode == Unbuffered) { 301 write_impl(Ptr, Size); 302 return *this; 303 } 304 // Set up a buffer and start over. 305 SetBuffered(); 306 return write(Ptr, Size); 307 } 308 309 size_t NumBytes = OutBufEnd - OutBufCur; 310 311 // If the buffer is empty at this point we have a string that is larger 312 // than the buffer. Directly write the chunk that is a multiple of the 313 // preferred buffer size and put the remainder in the buffer. 314 if (LLVM_UNLIKELY(OutBufCur == OutBufStart)) { 315 assert(NumBytes != 0 && "undefined behavior"); 316 size_t BytesToWrite = Size - (Size % NumBytes); 317 write_impl(Ptr, BytesToWrite); 318 size_t BytesRemaining = Size - BytesToWrite; 319 if (BytesRemaining > size_t(OutBufEnd - OutBufCur)) { 320 // Too much left over to copy into our buffer. 321 return write(Ptr + BytesToWrite, BytesRemaining); 322 } 323 copy_to_buffer(Ptr + BytesToWrite, BytesRemaining); 324 return *this; 325 } 326 327 // We don't have enough space in the buffer to fit the string in. Insert as 328 // much as possible, flush and start over with the remainder. 329 copy_to_buffer(Ptr, NumBytes); 330 flush_nonempty(); 331 return write(Ptr + NumBytes, Size - NumBytes); 332 } 333 334 copy_to_buffer(Ptr, Size); 335 336 return *this; 337 } 338 339 void raw_ostream::copy_to_buffer(const char *Ptr, size_t Size) { 340 assert(Size <= size_t(OutBufEnd - OutBufCur) && "Buffer overrun!"); 341 342 // Handle short strings specially, memcpy isn't very good at very short 343 // strings. 344 switch (Size) { 345 case 4: OutBufCur[3] = Ptr[3]; // FALL THROUGH 346 case 3: OutBufCur[2] = Ptr[2]; // FALL THROUGH 347 case 2: OutBufCur[1] = Ptr[1]; // FALL THROUGH 348 case 1: OutBufCur[0] = Ptr[0]; // FALL THROUGH 349 case 0: break; 350 default: 351 memcpy(OutBufCur, Ptr, Size); 352 break; 353 } 354 355 OutBufCur += Size; 356 } 357 358 // Formatted output. 359 raw_ostream &raw_ostream::operator<<(const format_object_base &Fmt) { 360 // If we have more than a few bytes left in our output buffer, try 361 // formatting directly onto its end. 362 size_t NextBufferSize = 127; 363 size_t BufferBytesLeft = OutBufEnd - OutBufCur; 364 if (BufferBytesLeft > 3) { 365 size_t BytesUsed = Fmt.print(OutBufCur, BufferBytesLeft); 366 367 // Common case is that we have plenty of space. 368 if (BytesUsed <= BufferBytesLeft) { 369 OutBufCur += BytesUsed; 370 return *this; 371 } 372 373 // Otherwise, we overflowed and the return value tells us the size to try 374 // again with. 375 NextBufferSize = BytesUsed; 376 } 377 378 // If we got here, we didn't have enough space in the output buffer for the 379 // string. Try printing into a SmallVector that is resized to have enough 380 // space. Iterate until we win. 381 SmallVector<char, 128> V; 382 383 while (1) { 384 V.resize(NextBufferSize); 385 386 // Try formatting into the SmallVector. 387 size_t BytesUsed = Fmt.print(V.data(), NextBufferSize); 388 389 // If BytesUsed fit into the vector, we win. 390 if (BytesUsed <= NextBufferSize) 391 return write(V.data(), BytesUsed); 392 393 // Otherwise, try again with a new size. 394 assert(BytesUsed > NextBufferSize && "Didn't grow buffer!?"); 395 NextBufferSize = BytesUsed; 396 } 397 } 398 399 raw_ostream &raw_ostream::operator<<(const FormattedString &FS) { 400 unsigned Len = FS.Str.size(); 401 int PadAmount = FS.Width - Len; 402 if (FS.RightJustify && (PadAmount > 0)) 403 this->indent(PadAmount); 404 this->operator<<(FS.Str); 405 if (!FS.RightJustify && (PadAmount > 0)) 406 this->indent(PadAmount); 407 return *this; 408 } 409 410 raw_ostream &raw_ostream::operator<<(const FormattedNumber &FN) { 411 if (FN.Hex) { 412 unsigned Nibbles = (64 - countLeadingZeros(FN.HexValue)+3)/4; 413 unsigned PrefixChars = FN.HexPrefix ? 2 : 0; 414 unsigned Width = std::max(FN.Width, Nibbles + PrefixChars); 415 416 char NumberBuffer[20] = "0x0000000000000000"; 417 if (!FN.HexPrefix) 418 NumberBuffer[1] = '0'; 419 char *EndPtr = NumberBuffer+Width; 420 char *CurPtr = EndPtr; 421 const char A = FN.Upper ? 'A' : 'a'; 422 unsigned long long N = FN.HexValue; 423 while (N) { 424 uintptr_t x = N % 16; 425 *--CurPtr = (x < 10 ? '0' + x : A + x - 10); 426 N /= 16; 427 } 428 429 return write(NumberBuffer, Width); 430 } else { 431 // Zero is a special case. 432 if (FN.DecValue == 0) { 433 this->indent(FN.Width-1); 434 return *this << '0'; 435 } 436 char NumberBuffer[32]; 437 char *EndPtr = NumberBuffer+sizeof(NumberBuffer); 438 char *CurPtr = EndPtr; 439 bool Neg = (FN.DecValue < 0); 440 uint64_t N = Neg ? -static_cast<uint64_t>(FN.DecValue) : FN.DecValue; 441 while (N) { 442 *--CurPtr = '0' + char(N % 10); 443 N /= 10; 444 } 445 int Len = EndPtr - CurPtr; 446 int Pad = FN.Width - Len; 447 if (Neg) 448 --Pad; 449 if (Pad > 0) 450 this->indent(Pad); 451 if (Neg) 452 *this << '-'; 453 return write(CurPtr, Len); 454 } 455 } 456 457 458 /// indent - Insert 'NumSpaces' spaces. 459 raw_ostream &raw_ostream::indent(unsigned NumSpaces) { 460 static const char Spaces[] = " " 461 " " 462 " "; 463 464 // Usually the indentation is small, handle it with a fastpath. 465 if (NumSpaces < array_lengthof(Spaces)) 466 return write(Spaces, NumSpaces); 467 468 while (NumSpaces) { 469 unsigned NumToWrite = std::min(NumSpaces, 470 (unsigned)array_lengthof(Spaces)-1); 471 write(Spaces, NumToWrite); 472 NumSpaces -= NumToWrite; 473 } 474 return *this; 475 } 476 477 478 //===----------------------------------------------------------------------===// 479 // Formatted Output 480 //===----------------------------------------------------------------------===// 481 482 // Out of line virtual method. 483 void format_object_base::home() { 484 } 485 486 //===----------------------------------------------------------------------===// 487 // raw_fd_ostream 488 //===----------------------------------------------------------------------===// 489 490 static int getFD(StringRef Filename, std::error_code &EC, 491 sys::fs::OpenFlags Flags) { 492 // Handle "-" as stdout. Note that when we do this, we consider ourself 493 // the owner of stdout. This means that we can do things like close the 494 // file descriptor when we're done and set the "binary" flag globally. 495 if (Filename == "-") { 496 EC = std::error_code(); 497 // If user requested binary then put stdout into binary mode if 498 // possible. 499 if (!(Flags & sys::fs::F_Text)) 500 sys::ChangeStdoutToBinary(); 501 return STDOUT_FILENO; 502 } 503 504 int FD; 505 EC = sys::fs::openFileForWrite(Filename, FD, Flags); 506 if (EC) 507 return -1; 508 509 return FD; 510 } 511 512 raw_fd_ostream::raw_fd_ostream(StringRef Filename, std::error_code &EC, 513 sys::fs::OpenFlags Flags) 514 : raw_fd_ostream(getFD(Filename, EC, Flags), true) {} 515 516 /// FD is the file descriptor that this writes to. If ShouldClose is true, this 517 /// closes the file when the stream is destroyed. 518 raw_fd_ostream::raw_fd_ostream(int fd, bool shouldClose, bool unbuffered) 519 : raw_pwrite_stream(unbuffered), FD(fd), ShouldClose(shouldClose), 520 Error(false) { 521 if (FD < 0 ) { 522 ShouldClose = false; 523 return; 524 } 525 526 // Get the starting position. 527 off_t loc = ::lseek(FD, 0, SEEK_CUR); 528 #ifdef LLVM_ON_WIN32 529 // MSVCRT's _lseek(SEEK_CUR) doesn't return -1 for pipes. 530 sys::fs::file_status Status; 531 std::error_code EC = status(FD, Status); 532 SupportsSeeking = !EC && Status.type() == sys::fs::file_type::regular_file; 533 #else 534 SupportsSeeking = loc != (off_t)-1; 535 #endif 536 if (!SupportsSeeking) 537 pos = 0; 538 else 539 pos = static_cast<uint64_t>(loc); 540 } 541 542 raw_fd_ostream::~raw_fd_ostream() { 543 if (FD >= 0) { 544 flush(); 545 if (ShouldClose && sys::Process::SafelyCloseFileDescriptor(FD)) 546 error_detected(); 547 } 548 549 #ifdef __MINGW32__ 550 // On mingw, global dtors should not call exit(). 551 // report_fatal_error() invokes exit(). We know report_fatal_error() 552 // might not write messages to stderr when any errors were detected 553 // on FD == 2. 554 if (FD == 2) return; 555 #endif 556 557 // If there are any pending errors, report them now. Clients wishing 558 // to avoid report_fatal_error calls should check for errors with 559 // has_error() and clear the error flag with clear_error() before 560 // destructing raw_ostream objects which may have errors. 561 if (has_error()) 562 report_fatal_error("IO failure on output stream.", /*GenCrashDiag=*/false); 563 } 564 565 566 void raw_fd_ostream::write_impl(const char *Ptr, size_t Size) { 567 assert(FD >= 0 && "File already closed."); 568 pos += Size; 569 570 do { 571 ssize_t ret = ::write(FD, Ptr, Size); 572 573 if (ret < 0) { 574 // If it's a recoverable error, swallow it and retry the write. 575 // 576 // Ideally we wouldn't ever see EAGAIN or EWOULDBLOCK here, since 577 // raw_ostream isn't designed to do non-blocking I/O. However, some 578 // programs, such as old versions of bjam, have mistakenly used 579 // O_NONBLOCK. For compatibility, emulate blocking semantics by 580 // spinning until the write succeeds. If you don't want spinning, 581 // don't use O_NONBLOCK file descriptors with raw_ostream. 582 if (errno == EINTR || errno == EAGAIN 583 #ifdef EWOULDBLOCK 584 || errno == EWOULDBLOCK 585 #endif 586 ) 587 continue; 588 589 // Otherwise it's a non-recoverable error. Note it and quit. 590 error_detected(); 591 break; 592 } 593 594 // The write may have written some or all of the data. Update the 595 // size and buffer pointer to reflect the remainder that needs 596 // to be written. If there are no bytes left, we're done. 597 Ptr += ret; 598 Size -= ret; 599 } while (Size > 0); 600 } 601 602 void raw_fd_ostream::close() { 603 assert(ShouldClose); 604 ShouldClose = false; 605 flush(); 606 if (sys::Process::SafelyCloseFileDescriptor(FD)) 607 error_detected(); 608 FD = -1; 609 } 610 611 uint64_t raw_fd_ostream::seek(uint64_t off) { 612 flush(); 613 pos = ::lseek(FD, off, SEEK_SET); 614 if (pos == (uint64_t)-1) 615 error_detected(); 616 return pos; 617 } 618 619 void raw_fd_ostream::pwrite_impl(const char *Ptr, size_t Size, 620 uint64_t Offset) { 621 uint64_t Pos = tell(); 622 seek(Offset); 623 write(Ptr, Size); 624 seek(Pos); 625 } 626 627 size_t raw_fd_ostream::preferred_buffer_size() const { 628 #if !defined(_MSC_VER) && !defined(__MINGW32__) && !defined(__minix) 629 // Windows and Minix have no st_blksize. 630 assert(FD >= 0 && "File not yet open!"); 631 struct stat statbuf; 632 if (fstat(FD, &statbuf) != 0) 633 return 0; 634 635 // If this is a terminal, don't use buffering. Line buffering 636 // would be a more traditional thing to do, but it's not worth 637 // the complexity. 638 if (S_ISCHR(statbuf.st_mode) && isatty(FD)) 639 return 0; 640 // Return the preferred block size. 641 return statbuf.st_blksize; 642 #else 643 return raw_ostream::preferred_buffer_size(); 644 #endif 645 } 646 647 raw_ostream &raw_fd_ostream::changeColor(enum Colors colors, bool bold, 648 bool bg) { 649 if (sys::Process::ColorNeedsFlush()) 650 flush(); 651 const char *colorcode = 652 (colors == SAVEDCOLOR) ? sys::Process::OutputBold(bg) 653 : sys::Process::OutputColor(colors, bold, bg); 654 if (colorcode) { 655 size_t len = strlen(colorcode); 656 write(colorcode, len); 657 // don't account colors towards output characters 658 pos -= len; 659 } 660 return *this; 661 } 662 663 raw_ostream &raw_fd_ostream::resetColor() { 664 if (sys::Process::ColorNeedsFlush()) 665 flush(); 666 const char *colorcode = sys::Process::ResetColor(); 667 if (colorcode) { 668 size_t len = strlen(colorcode); 669 write(colorcode, len); 670 // don't account colors towards output characters 671 pos -= len; 672 } 673 return *this; 674 } 675 676 raw_ostream &raw_fd_ostream::reverseColor() { 677 if (sys::Process::ColorNeedsFlush()) 678 flush(); 679 const char *colorcode = sys::Process::OutputReverse(); 680 if (colorcode) { 681 size_t len = strlen(colorcode); 682 write(colorcode, len); 683 // don't account colors towards output characters 684 pos -= len; 685 } 686 return *this; 687 } 688 689 bool raw_fd_ostream::is_displayed() const { 690 return sys::Process::FileDescriptorIsDisplayed(FD); 691 } 692 693 bool raw_fd_ostream::has_colors() const { 694 return sys::Process::FileDescriptorHasColors(FD); 695 } 696 697 //===----------------------------------------------------------------------===// 698 // outs(), errs(), nulls() 699 //===----------------------------------------------------------------------===// 700 701 /// outs() - This returns a reference to a raw_ostream for standard output. 702 /// Use it like: outs() << "foo" << "bar"; 703 raw_ostream &llvm::outs() { 704 // Set buffer settings to model stdout behavior. 705 // Delete the file descriptor when the program exits, forcing error 706 // detection. If you don't want this behavior, don't use outs(). 707 std::error_code EC; 708 static raw_fd_ostream S("-", EC, sys::fs::F_None); 709 assert(!EC); 710 return S; 711 } 712 713 /// errs() - This returns a reference to a raw_ostream for standard error. 714 /// Use it like: errs() << "foo" << "bar"; 715 raw_ostream &llvm::errs() { 716 // Set standard error to be unbuffered by default. 717 static raw_fd_ostream S(STDERR_FILENO, false, true); 718 return S; 719 } 720 721 /// nulls() - This returns a reference to a raw_ostream which discards output. 722 raw_ostream &llvm::nulls() { 723 static raw_null_ostream S; 724 return S; 725 } 726 727 728 //===----------------------------------------------------------------------===// 729 // raw_string_ostream 730 //===----------------------------------------------------------------------===// 731 732 raw_string_ostream::~raw_string_ostream() { 733 flush(); 734 } 735 736 void raw_string_ostream::write_impl(const char *Ptr, size_t Size) { 737 OS.append(Ptr, Size); 738 } 739 740 //===----------------------------------------------------------------------===// 741 // raw_svector_ostream 742 //===----------------------------------------------------------------------===// 743 744 uint64_t raw_svector_ostream::current_pos() const { return OS.size(); } 745 746 void raw_svector_ostream::write_impl(const char *Ptr, size_t Size) { 747 OS.append(Ptr, Ptr + Size); 748 } 749 750 void raw_svector_ostream::pwrite_impl(const char *Ptr, size_t Size, 751 uint64_t Offset) { 752 memcpy(OS.data() + Offset, Ptr, Size); 753 } 754 755 //===----------------------------------------------------------------------===// 756 // raw_null_ostream 757 //===----------------------------------------------------------------------===// 758 759 raw_null_ostream::~raw_null_ostream() { 760 #ifndef NDEBUG 761 // ~raw_ostream asserts that the buffer is empty. This isn't necessary 762 // with raw_null_ostream, but it's better to have raw_null_ostream follow 763 // the rules than to change the rules just for raw_null_ostream. 764 flush(); 765 #endif 766 } 767 768 void raw_null_ostream::write_impl(const char *Ptr, size_t Size) { 769 } 770 771 uint64_t raw_null_ostream::current_pos() const { 772 return 0; 773 } 774 775 void raw_null_ostream::pwrite_impl(const char *Ptr, size_t Size, 776 uint64_t Offset) {} 777