raw_ostream.cpp revision 10a049e6cf50eb9a1dddae49dc21513cfeddcb47
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/Support/Format.h" 16#include "llvm/System/Program.h" 17#include "llvm/System/Process.h" 18#include "llvm/ADT/StringExtras.h" 19#include "llvm/ADT/SmallVector.h" 20#include "llvm/Config/config.h" 21#include "llvm/Support/Compiler.h" 22#include "llvm/Support/ErrorHandling.h" 23#include "llvm/ADT/STLExtras.h" 24#include <cctype> 25#include <cerrno> 26#include <sys/stat.h> 27#include <sys/types.h> 28 29#if defined(HAVE_UNISTD_H) 30# include <unistd.h> 31#endif 32#if defined(HAVE_FCNTL_H) 33# include <fcntl.h> 34#endif 35 36#if defined(__CYGWIN__) 37#include <io.h> 38#endif 39 40#if defined(_MSC_VER) 41#include <io.h> 42#include <fcntl.h> 43#ifndef STDIN_FILENO 44# define STDIN_FILENO 0 45#endif 46#ifndef STDOUT_FILENO 47# define STDOUT_FILENO 1 48#endif 49#ifndef STDERR_FILENO 50# define STDERR_FILENO 2 51#endif 52#endif 53 54using namespace llvm; 55 56raw_ostream::~raw_ostream() { 57 // raw_ostream's subclasses should take care to flush the buffer 58 // in their destructors. 59 assert(OutBufCur == OutBufStart && 60 "raw_ostream destructor called with non-empty buffer!"); 61 62 if (BufferMode == InternalBuffer) 63 delete [] OutBufStart; 64} 65 66// An out of line virtual method to provide a home for the class vtable. 67void raw_ostream::handle() {} 68 69size_t raw_ostream::preferred_buffer_size() const { 70 // BUFSIZ is intended to be a reasonable default. 71 return BUFSIZ; 72} 73 74void raw_ostream::SetBuffered() { 75 // Ask the subclass to determine an appropriate buffer size. 76 if (size_t Size = preferred_buffer_size()) 77 SetBufferSize(Size); 78 else 79 // It may return 0, meaning this stream should be unbuffered. 80 SetUnbuffered(); 81} 82 83void raw_ostream::SetBufferAndMode(char *BufferStart, size_t Size, 84 BufferKind Mode) { 85 assert(((Mode == Unbuffered && BufferStart == 0 && Size == 0) || 86 (Mode != Unbuffered && BufferStart && Size)) && 87 "stream must be unbuffered or have at least one byte"); 88 // Make sure the current buffer is free of content (we can't flush here; the 89 // child buffer management logic will be in write_impl). 90 assert(GetNumBytesInBuffer() == 0 && "Current buffer is non-empty!"); 91 92 if (BufferMode == InternalBuffer) 93 delete [] OutBufStart; 94 OutBufStart = BufferStart; 95 OutBufEnd = OutBufStart+Size; 96 OutBufCur = OutBufStart; 97 BufferMode = Mode; 98 99 assert(OutBufStart <= OutBufEnd && "Invalid size!"); 100} 101 102raw_ostream &raw_ostream::operator<<(unsigned long N) { 103 // Zero is a special case. 104 if (N == 0) 105 return *this << '0'; 106 107 char NumberBuffer[20]; 108 char *EndPtr = NumberBuffer+sizeof(NumberBuffer); 109 char *CurPtr = EndPtr; 110 111 while (N) { 112 *--CurPtr = '0' + char(N % 10); 113 N /= 10; 114 } 115 return write(CurPtr, EndPtr-CurPtr); 116} 117 118raw_ostream &raw_ostream::operator<<(long N) { 119 if (N < 0) { 120 *this << '-'; 121 N = -N; 122 } 123 124 return this->operator<<(static_cast<unsigned long>(N)); 125} 126 127raw_ostream &raw_ostream::operator<<(unsigned long long N) { 128 // Output using 32-bit div/mod when possible. 129 if (N == static_cast<unsigned long>(N)) 130 return this->operator<<(static_cast<unsigned long>(N)); 131 132 char NumberBuffer[20]; 133 char *EndPtr = NumberBuffer+sizeof(NumberBuffer); 134 char *CurPtr = EndPtr; 135 136 while (N) { 137 *--CurPtr = '0' + char(N % 10); 138 N /= 10; 139 } 140 return write(CurPtr, EndPtr-CurPtr); 141} 142 143raw_ostream &raw_ostream::operator<<(long long N) { 144 if (N < 0) { 145 *this << '-'; 146 // Avoid undefined behavior on INT64_MIN with a cast. 147 N = -(unsigned long long)N; 148 } 149 150 return this->operator<<(static_cast<unsigned long long>(N)); 151} 152 153raw_ostream &raw_ostream::write_hex(unsigned long long N) { 154 // Zero is a special case. 155 if (N == 0) 156 return *this << '0'; 157 158 char NumberBuffer[20]; 159 char *EndPtr = NumberBuffer+sizeof(NumberBuffer); 160 char *CurPtr = EndPtr; 161 162 while (N) { 163 uintptr_t x = N % 16; 164 *--CurPtr = (x < 10 ? '0' + x : 'a' + x - 10); 165 N /= 16; 166 } 167 168 return write(CurPtr, EndPtr-CurPtr); 169} 170 171raw_ostream &raw_ostream::write_escaped(StringRef Str, 172 bool UseHexEscapes) { 173 for (unsigned i = 0, e = Str.size(); i != e; ++i) { 174 unsigned char c = Str[i]; 175 176 switch (c) { 177 case '\\': 178 *this << '\\' << '\\'; 179 break; 180 case '\t': 181 *this << '\\' << 't'; 182 break; 183 case '\n': 184 *this << '\\' << 'n'; 185 break; 186 case '"': 187 *this << '\\' << '"'; 188 break; 189 default: 190 if (std::isprint(c)) { 191 *this << c; 192 break; 193 } 194 195 // Write out the escaped representation. 196 if (UseHexEscapes) { 197 *this << '\\' << 'x'; 198 *this << hexdigit((c >> 4 & 0xF)); 199 *this << hexdigit((c >> 0) & 0xF); 200 } else { 201 // Always use a full 3-character octal escape. 202 *this << '\\'; 203 *this << char('0' + ((c >> 6) & 7)); 204 *this << char('0' + ((c >> 3) & 7)); 205 *this << char('0' + ((c >> 0) & 7)); 206 } 207 } 208 } 209 210 return *this; 211} 212 213raw_ostream &raw_ostream::operator<<(const void *P) { 214 *this << '0' << 'x'; 215 216 return write_hex((uintptr_t) P); 217} 218 219raw_ostream &raw_ostream::operator<<(double N) { 220 return this->operator<<(format("%e", N)); 221} 222 223 224 225void raw_ostream::flush_nonempty() { 226 assert(OutBufCur > OutBufStart && "Invalid call to flush_nonempty."); 227 size_t Length = OutBufCur - OutBufStart; 228 OutBufCur = OutBufStart; 229 write_impl(OutBufStart, Length); 230} 231 232raw_ostream &raw_ostream::write(unsigned char C) { 233 // Group exceptional cases into a single branch. 234 if (BUILTIN_EXPECT(OutBufCur >= OutBufEnd, false)) { 235 if (BUILTIN_EXPECT(!OutBufStart, false)) { 236 if (BufferMode == Unbuffered) { 237 write_impl(reinterpret_cast<char*>(&C), 1); 238 return *this; 239 } 240 // Set up a buffer and start over. 241 SetBuffered(); 242 return write(C); 243 } 244 245 flush_nonempty(); 246 } 247 248 *OutBufCur++ = C; 249 return *this; 250} 251 252raw_ostream &raw_ostream::write(const char *Ptr, size_t Size) { 253 // Group exceptional cases into a single branch. 254 if (BUILTIN_EXPECT(OutBufCur+Size > OutBufEnd, false)) { 255 if (BUILTIN_EXPECT(!OutBufStart, false)) { 256 if (BufferMode == Unbuffered) { 257 write_impl(Ptr, Size); 258 return *this; 259 } 260 // Set up a buffer and start over. 261 SetBuffered(); 262 return write(Ptr, Size); 263 } 264 265 // Write out the data in buffer-sized blocks until the remainder 266 // fits within the buffer. 267 do { 268 size_t NumBytes = OutBufEnd - OutBufCur; 269 copy_to_buffer(Ptr, NumBytes); 270 flush_nonempty(); 271 Ptr += NumBytes; 272 Size -= NumBytes; 273 } while (OutBufCur+Size > OutBufEnd); 274 } 275 276 copy_to_buffer(Ptr, Size); 277 278 return *this; 279} 280 281void raw_ostream::copy_to_buffer(const char *Ptr, size_t Size) { 282 assert(Size <= size_t(OutBufEnd - OutBufCur) && "Buffer overrun!"); 283 284 // Handle short strings specially, memcpy isn't very good at very short 285 // strings. 286 switch (Size) { 287 case 4: OutBufCur[3] = Ptr[3]; // FALL THROUGH 288 case 3: OutBufCur[2] = Ptr[2]; // FALL THROUGH 289 case 2: OutBufCur[1] = Ptr[1]; // FALL THROUGH 290 case 1: OutBufCur[0] = Ptr[0]; // FALL THROUGH 291 case 0: break; 292 default: 293 memcpy(OutBufCur, Ptr, Size); 294 break; 295 } 296 297 OutBufCur += Size; 298} 299 300// Formatted output. 301raw_ostream &raw_ostream::operator<<(const format_object_base &Fmt) { 302 // If we have more than a few bytes left in our output buffer, try 303 // formatting directly onto its end. 304 size_t NextBufferSize = 127; 305 size_t BufferBytesLeft = OutBufEnd - OutBufCur; 306 if (BufferBytesLeft > 3) { 307 size_t BytesUsed = Fmt.print(OutBufCur, BufferBytesLeft); 308 309 // Common case is that we have plenty of space. 310 if (BytesUsed <= BufferBytesLeft) { 311 OutBufCur += BytesUsed; 312 return *this; 313 } 314 315 // Otherwise, we overflowed and the return value tells us the size to try 316 // again with. 317 NextBufferSize = BytesUsed; 318 } 319 320 // If we got here, we didn't have enough space in the output buffer for the 321 // string. Try printing into a SmallVector that is resized to have enough 322 // space. Iterate until we win. 323 SmallVector<char, 128> V; 324 325 while (1) { 326 V.resize(NextBufferSize); 327 328 // Try formatting into the SmallVector. 329 size_t BytesUsed = Fmt.print(V.data(), NextBufferSize); 330 331 // If BytesUsed fit into the vector, we win. 332 if (BytesUsed <= NextBufferSize) 333 return write(V.data(), BytesUsed); 334 335 // Otherwise, try again with a new size. 336 assert(BytesUsed > NextBufferSize && "Didn't grow buffer!?"); 337 NextBufferSize = BytesUsed; 338 } 339} 340 341/// indent - Insert 'NumSpaces' spaces. 342raw_ostream &raw_ostream::indent(unsigned NumSpaces) { 343 static const char Spaces[] = " " 344 " " 345 " "; 346 347 // Usually the indentation is small, handle it with a fastpath. 348 if (NumSpaces < array_lengthof(Spaces)) 349 return write(Spaces, NumSpaces); 350 351 while (NumSpaces) { 352 unsigned NumToWrite = std::min(NumSpaces, 353 (unsigned)array_lengthof(Spaces)-1); 354 write(Spaces, NumToWrite); 355 NumSpaces -= NumToWrite; 356 } 357 return *this; 358} 359 360 361//===----------------------------------------------------------------------===// 362// Formatted Output 363//===----------------------------------------------------------------------===// 364 365// Out of line virtual method. 366void format_object_base::home() { 367} 368 369//===----------------------------------------------------------------------===// 370// raw_fd_ostream 371//===----------------------------------------------------------------------===// 372 373/// raw_fd_ostream - Open the specified file for writing. If an error 374/// occurs, information about the error is put into ErrorInfo, and the 375/// stream should be immediately destroyed; the string will be empty 376/// if no error occurred. 377raw_fd_ostream::raw_fd_ostream(const char *Filename, std::string &ErrorInfo, 378 unsigned Flags) : Error(false), pos(0) { 379 assert(Filename != 0 && "Filename is null"); 380 // Verify that we don't have both "append" and "excl". 381 assert((!(Flags & F_Excl) || !(Flags & F_Append)) && 382 "Cannot specify both 'excl' and 'append' file creation flags!"); 383 384 ErrorInfo.clear(); 385 386 // Handle "-" as stdout. Note that when we do this, we consider ourself 387 // the owner of stdout. This means that we can do things like close the 388 // file descriptor when we're done and set the "binary" flag globally. 389 if (Filename[0] == '-' && Filename[1] == 0) { 390 FD = STDOUT_FILENO; 391 // If user requested binary then put stdout into binary mode if 392 // possible. 393 if (Flags & F_Binary) 394 sys::Program::ChangeStdoutToBinary(); 395 // Close stdout when we're done, to detect any output errors. 396 ShouldClose = true; 397 return; 398 } 399 400 int OpenFlags = O_WRONLY|O_CREAT; 401#ifdef O_BINARY 402 if (Flags & F_Binary) 403 OpenFlags |= O_BINARY; 404#endif 405 406 if (Flags & F_Append) 407 OpenFlags |= O_APPEND; 408 else 409 OpenFlags |= O_TRUNC; 410 if (Flags & F_Excl) 411 OpenFlags |= O_EXCL; 412 413 while ((FD = open(Filename, OpenFlags, 0664)) < 0) { 414 if (errno != EINTR) { 415 ErrorInfo = "Error opening output file '" + std::string(Filename) + "'"; 416 ShouldClose = false; 417 return; 418 } 419 } 420 421 // Ok, we successfully opened the file, so it'll need to be closed. 422 ShouldClose = true; 423} 424 425/// raw_fd_ostream ctor - FD is the file descriptor that this writes to. If 426/// ShouldClose is true, this closes the file when the stream is destroyed. 427raw_fd_ostream::raw_fd_ostream(int fd, bool shouldClose, bool unbuffered) 428 : raw_ostream(unbuffered), FD(fd), 429 ShouldClose(shouldClose), Error(false) { 430#ifdef O_BINARY 431 // Setting STDOUT and STDERR to binary mode is necessary in Win32 432 // to avoid undesirable linefeed conversion. 433 if (fd == STDOUT_FILENO || fd == STDERR_FILENO) 434 setmode(fd, O_BINARY); 435#endif 436} 437 438raw_fd_ostream::~raw_fd_ostream() { 439 if (FD >= 0) { 440 flush(); 441 if (ShouldClose) 442 while (::close(FD) != 0) 443 if (errno != EINTR) { 444 error_detected(); 445 break; 446 } 447 } 448 449 // If there are any pending errors, report them now. Clients wishing 450 // to avoid report_fatal_error calls should check for errors with 451 // has_error() and clear the error flag with clear_error() before 452 // destructing raw_ostream objects which may have errors. 453 if (has_error()) 454 report_fatal_error("IO failure on output stream."); 455} 456 457 458void raw_fd_ostream::write_impl(const char *Ptr, size_t Size) { 459 assert(FD >= 0 && "File already closed."); 460 pos += Size; 461 462 do { 463 ssize_t ret = ::write(FD, Ptr, Size); 464 465 if (ret < 0) { 466 // If it's a recoverable error, swallow it and retry the write. 467 // 468 // Ideally we wouldn't ever see EAGAIN or EWOULDBLOCK here, since 469 // raw_ostream isn't designed to do non-blocking I/O. However, some 470 // programs, such as old versions of bjam, have mistakenly used 471 // O_NONBLOCK. For compatibility, emulate blocking semantics by 472 // spinning until the write succeeds. If you don't want spinning, 473 // don't use O_NONBLOCK file descriptors with raw_ostream. 474 if (errno == EINTR || errno == EAGAIN 475#ifdef EWOULDBLOCK 476 || errno == EWOULDBLOCK 477#endif 478 ) 479 continue; 480 481 // Otherwise it's a non-recoverable error. Note it and quit. 482 error_detected(); 483 break; 484 } 485 486 // The write may have written some or all of the data. Update the 487 // size and buffer pointer to reflect the remainder that needs 488 // to be written. If there are no bytes left, we're done. 489 Ptr += ret; 490 Size -= ret; 491 } while (Size > 0); 492} 493 494void raw_fd_ostream::close() { 495 assert(ShouldClose); 496 ShouldClose = false; 497 flush(); 498 while (::close(FD) != 0) 499 if (errno != EINTR) { 500 error_detected(); 501 break; 502 } 503 FD = -1; 504} 505 506uint64_t raw_fd_ostream::seek(uint64_t off) { 507 flush(); 508 pos = ::lseek(FD, off, SEEK_SET); 509 if (pos != off) 510 error_detected(); 511 return pos; 512} 513 514size_t raw_fd_ostream::preferred_buffer_size() const { 515#if !defined(_MSC_VER) && !defined(__MINGW32__) && !defined(__minix) 516 // Windows and Minix have no st_blksize. 517 assert(FD >= 0 && "File not yet open!"); 518 struct stat statbuf; 519 if (fstat(FD, &statbuf) != 0) 520 return 0; 521 522 // If this is a terminal, don't use buffering. Line buffering 523 // would be a more traditional thing to do, but it's not worth 524 // the complexity. 525 if (S_ISCHR(statbuf.st_mode) && isatty(FD)) 526 return 0; 527 // Return the preferred block size. 528 return statbuf.st_blksize; 529#else 530 return raw_ostream::preferred_buffer_size(); 531#endif 532} 533 534raw_ostream &raw_fd_ostream::changeColor(enum Colors colors, bool bold, 535 bool bg) { 536 if (sys::Process::ColorNeedsFlush()) 537 flush(); 538 const char *colorcode = 539 (colors == SAVEDCOLOR) ? sys::Process::OutputBold(bg) 540 : sys::Process::OutputColor(colors, bold, bg); 541 if (colorcode) { 542 size_t len = strlen(colorcode); 543 write(colorcode, len); 544 // don't account colors towards output characters 545 pos -= len; 546 } 547 return *this; 548} 549 550raw_ostream &raw_fd_ostream::resetColor() { 551 if (sys::Process::ColorNeedsFlush()) 552 flush(); 553 const char *colorcode = sys::Process::ResetColor(); 554 if (colorcode) { 555 size_t len = strlen(colorcode); 556 write(colorcode, len); 557 // don't account colors towards output characters 558 pos -= len; 559 } 560 return *this; 561} 562 563bool raw_fd_ostream::is_displayed() const { 564 return sys::Process::FileDescriptorIsDisplayed(FD); 565} 566 567//===----------------------------------------------------------------------===// 568// outs(), errs(), nulls() 569//===----------------------------------------------------------------------===// 570 571/// outs() - This returns a reference to a raw_ostream for standard output. 572/// Use it like: outs() << "foo" << "bar"; 573raw_ostream &llvm::outs() { 574 // Set buffer settings to model stdout behavior. 575 // Delete the file descriptor when the program exists, forcing error 576 // detection. If you don't want this behavior, don't use outs(). 577 static raw_fd_ostream S(STDOUT_FILENO, true); 578 return S; 579} 580 581/// errs() - This returns a reference to a raw_ostream for standard error. 582/// Use it like: errs() << "foo" << "bar"; 583raw_ostream &llvm::errs() { 584 // Set standard error to be unbuffered by default. 585 static raw_fd_ostream S(STDERR_FILENO, false, true); 586 return S; 587} 588 589/// nulls() - This returns a reference to a raw_ostream which discards output. 590raw_ostream &llvm::nulls() { 591 static raw_null_ostream S; 592 return S; 593} 594 595 596//===----------------------------------------------------------------------===// 597// raw_string_ostream 598//===----------------------------------------------------------------------===// 599 600raw_string_ostream::~raw_string_ostream() { 601 flush(); 602} 603 604void raw_string_ostream::write_impl(const char *Ptr, size_t Size) { 605 OS.append(Ptr, Size); 606} 607 608//===----------------------------------------------------------------------===// 609// raw_svector_ostream 610//===----------------------------------------------------------------------===// 611 612// The raw_svector_ostream implementation uses the SmallVector itself as the 613// buffer for the raw_ostream. We guarantee that the raw_ostream buffer is 614// always pointing past the end of the vector, but within the vector 615// capacity. This allows raw_ostream to write directly into the correct place, 616// and we only need to set the vector size when the data is flushed. 617 618raw_svector_ostream::raw_svector_ostream(SmallVectorImpl<char> &O) : OS(O) { 619 // Set up the initial external buffer. We make sure that the buffer has at 620 // least 128 bytes free; raw_ostream itself only requires 64, but we want to 621 // make sure that we don't grow the buffer unnecessarily on destruction (when 622 // the data is flushed). See the FIXME below. 623 OS.reserve(OS.size() + 128); 624 SetBuffer(OS.end(), OS.capacity() - OS.size()); 625} 626 627raw_svector_ostream::~raw_svector_ostream() { 628 // FIXME: Prevent resizing during this flush(). 629 flush(); 630} 631 632/// resync - This is called when the SmallVector we're appending to is changed 633/// outside of the raw_svector_ostream's control. It is only safe to do this 634/// if the raw_svector_ostream has previously been flushed. 635void raw_svector_ostream::resync() { 636 assert(GetNumBytesInBuffer() == 0 && "Didn't flush before mutating vector"); 637 638 if (OS.capacity() - OS.size() < 64) 639 OS.reserve(OS.capacity() * 2); 640 SetBuffer(OS.end(), OS.capacity() - OS.size()); 641} 642 643void raw_svector_ostream::write_impl(const char *Ptr, size_t Size) { 644 // If we're writing bytes from the end of the buffer into the smallvector, we 645 // don't need to copy the bytes, just commit the bytes because they are 646 // already in the right place. 647 if (Ptr == OS.end()) { 648 assert(OS.size() + Size <= OS.capacity() && "Invalid write_impl() call!"); 649 OS.set_size(OS.size() + Size); 650 } else { 651 assert(GetNumBytesInBuffer() == 0 && 652 "Should be writing from buffer if some bytes in it"); 653 // Otherwise, do copy the bytes. 654 OS.append(Ptr, Ptr+Size); 655 } 656 657 // Grow the vector if necessary. 658 if (OS.capacity() - OS.size() < 64) 659 OS.reserve(OS.capacity() * 2); 660 661 // Update the buffer position. 662 SetBuffer(OS.end(), OS.capacity() - OS.size()); 663} 664 665uint64_t raw_svector_ostream::current_pos() const { 666 return OS.size(); 667} 668 669StringRef raw_svector_ostream::str() { 670 flush(); 671 return StringRef(OS.begin(), OS.size()); 672} 673 674//===----------------------------------------------------------------------===// 675// raw_null_ostream 676//===----------------------------------------------------------------------===// 677 678raw_null_ostream::~raw_null_ostream() { 679#ifndef NDEBUG 680 // ~raw_ostream asserts that the buffer is empty. This isn't necessary 681 // with raw_null_ostream, but it's better to have raw_null_ostream follow 682 // the rules than to change the rules just for raw_null_ostream. 683 flush(); 684#endif 685} 686 687void raw_null_ostream::write_impl(const char *Ptr, size_t Size) { 688} 689 690uint64_t raw_null_ostream::current_pos() const { 691 return 0; 692} 693