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