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