blob: d6b958d18449b5232934a6a174d4ad03142c8100 [file] [log] [blame]
Chris Lattner84b94f72008-08-17 01:35:29 +00001//===--- 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"
Chandler Carruthed0881b2012-12-03 16:50:05 +000015#include "llvm/ADT/STLExtras.h"
Chris Lattner22b52c92008-08-23 19:23:10 +000016#include "llvm/ADT/SmallVector.h"
Chandler Carruthed0881b2012-12-03 16:50:05 +000017#include "llvm/ADT/StringExtras.h"
Chris Lattnerd564f292008-08-22 15:45:00 +000018#include "llvm/Config/config.h"
Daniel Dunbar437b8a52009-03-17 21:15:18 +000019#include "llvm/Support/Compiler.h"
Daniel Dunbardcb50b92009-07-15 08:11:46 +000020#include "llvm/Support/ErrorHandling.h"
Rafael Espindola6d354812013-07-16 19:44:17 +000021#include "llvm/Support/FileSystem.h"
Chandler Carruthed0881b2012-12-03 16:50:05 +000022#include "llvm/Support/Format.h"
Zachary Turner11db2642016-11-11 23:57:40 +000023#include "llvm/Support/FormatVariadic.h"
Nick Kledzike6480372014-09-25 20:30:58 +000024#include "llvm/Support/MathExtras.h"
Zachary Turner733be512016-10-11 19:24:45 +000025#include "llvm/Support/NativeFormatting.h"
Chandler Carruthed0881b2012-12-03 16:50:05 +000026#include "llvm/Support/Process.h"
27#include "llvm/Support/Program.h"
Eugene Zelenko33d7b762016-08-23 17:14:32 +000028#include <algorithm>
Benjamin Krameref14f802010-01-29 15:19:06 +000029#include <cctype>
Benjamin Kramerce84a252010-05-05 15:17:47 +000030#include <cerrno>
Eugene Zelenko33d7b762016-08-23 17:14:32 +000031#include <cstdio>
32#include <iterator>
Eugene Zelenko33d7b762016-08-23 17:14:32 +000033#include <sys/stat.h>
Zachary Turner733be512016-10-11 19:24:45 +000034#include <system_error>
Chris Lattner84b94f72008-08-17 01:35:29 +000035
NAKAMURA Takumi212c80a2013-07-17 02:21:10 +000036// <fcntl.h> may provide O_BINARY.
37#if defined(HAVE_FCNTL_H)
38# include <fcntl.h>
39#endif
40
Chris Lattnerd564f292008-08-22 15:45:00 +000041#if defined(HAVE_UNISTD_H)
42# include <unistd.h>
43#endif
Daniel Dunbar4fed8872011-02-03 03:32:32 +000044#if defined(HAVE_SYS_UIO_H) && defined(HAVE_WRITEV)
45# include <sys/uio.h>
46#endif
Argyrios Kyrtzidisb97ff822008-08-17 09:25:21 +000047
NAKAMURA Takumife84f392010-10-19 01:21:55 +000048#if defined(__CYGWIN__)
49#include <io.h>
50#endif
51
Argyrios Kyrtzidisb97ff822008-08-17 09:25:21 +000052#if defined(_MSC_VER)
Chris Lattner84b94f72008-08-17 01:35:29 +000053#include <io.h>
Owen Anderson93719642008-08-21 00:14:44 +000054#ifndef STDIN_FILENO
55# define STDIN_FILENO 0
56#endif
57#ifndef STDOUT_FILENO
58# define STDOUT_FILENO 1
59#endif
60#ifndef STDERR_FILENO
61# define STDERR_FILENO 2
62#endif
Chris Lattner84b94f72008-08-17 01:35:29 +000063#endif
64
Yunzhong Gaofb2a9c42016-01-06 00:50:06 +000065#ifdef LLVM_ON_WIN32
66#include "Windows/WindowsSupport.h"
67#endif
68
Chris Lattnerd564f292008-08-22 15:45:00 +000069using namespace llvm;
70
Dan Gohman58fcef92009-07-15 23:25:33 +000071raw_ostream::~raw_ostream() {
Dan Gohman1b763292009-07-27 20:49:44 +000072 // raw_ostream's subclasses should take care to flush the buffer
73 // in their destructors.
74 assert(OutBufCur == OutBufStart &&
75 "raw_ostream destructor called with non-empty buffer!");
76
Daniel Dunbar317a6cd2009-08-18 23:42:36 +000077 if (BufferMode == InternalBuffer)
78 delete [] OutBufStart;
Dan Gohman58fcef92009-07-15 23:25:33 +000079}
Chris Lattnerd564f292008-08-22 15:45:00 +000080
Chris Lattner84b94f72008-08-17 01:35:29 +000081// An out of line virtual method to provide a home for the class vtable.
82void raw_ostream::handle() {}
83
Chris Lattnerdd3e9aa2009-12-19 01:38:42 +000084size_t raw_ostream::preferred_buffer_size() const {
Dan Gohman84487b92009-08-13 17:27:29 +000085 // BUFSIZ is intended to be a reasonable default.
86 return BUFSIZ;
87}
88
89void raw_ostream::SetBuffered() {
90 // Ask the subclass to determine an appropriate buffer size.
Dan Gohman17710222009-08-15 02:05:19 +000091 if (size_t Size = preferred_buffer_size())
92 SetBufferSize(Size);
93 else
94 // It may return 0, meaning this stream should be unbuffered.
95 SetUnbuffered();
Dan Gohman84487b92009-08-13 17:27:29 +000096}
97
Dan Gohmanb452d4e2010-03-24 19:38:02 +000098void raw_ostream::SetBufferAndMode(char *BufferStart, size_t Size,
Nick Lewycky7bfd86d2011-08-28 03:30:02 +000099 BufferKind Mode) {
Craig Topper2617dcc2014-04-15 06:32:26 +0000100 assert(((Mode == Unbuffered && !BufferStart && Size == 0) ||
101 (Mode != Unbuffered && BufferStart && Size != 0)) &&
Daniel Dunbar316b4a02009-09-15 20:31:46 +0000102 "stream must be unbuffered or have at least one byte");
Daniel Dunbar317a6cd2009-08-18 23:42:36 +0000103 // Make sure the current buffer is free of content (we can't flush here; the
104 // child buffer management logic will be in write_impl).
105 assert(GetNumBytesInBuffer() == 0 && "Current buffer is non-empty!");
Dan Gohman54401d42009-08-13 15:58:55 +0000106
Daniel Dunbar317a6cd2009-08-18 23:42:36 +0000107 if (BufferMode == InternalBuffer)
108 delete [] OutBufStart;
109 OutBufStart = BufferStart;
Dan Gohman54401d42009-08-13 15:58:55 +0000110 OutBufEnd = OutBufStart+Size;
111 OutBufCur = OutBufStart;
Daniel Dunbar317a6cd2009-08-18 23:42:36 +0000112 BufferMode = Mode;
Daniel Dunbarb090bf42009-08-19 17:54:29 +0000113
114 assert(OutBufStart <= OutBufEnd && "Invalid size!");
Dan Gohman54401d42009-08-13 15:58:55 +0000115}
116
Owen Andersond2850532008-08-21 20:58:52 +0000117raw_ostream &raw_ostream::operator<<(unsigned long N) {
Zachary Turner11db2642016-11-11 23:57:40 +0000118 write_integer(*this, static_cast<uint64_t>(N), 0, IntegerStyle::Integer);
Zachary Turner733be512016-10-11 19:24:45 +0000119 return *this;
Owen Andersond2850532008-08-21 20:58:52 +0000120}
121
122raw_ostream &raw_ostream::operator<<(long N) {
Zachary Turner11db2642016-11-11 23:57:40 +0000123 write_integer(*this, static_cast<int64_t>(N), 0, IntegerStyle::Integer);
Zachary Turner733be512016-10-11 19:24:45 +0000124 return *this;
Owen Andersond2850532008-08-21 20:58:52 +0000125}
126
127raw_ostream &raw_ostream::operator<<(unsigned long long N) {
Zachary Turner11db2642016-11-11 23:57:40 +0000128 write_integer(*this, static_cast<uint64_t>(N), 0, IntegerStyle::Integer);
Zachary Turner733be512016-10-11 19:24:45 +0000129 return *this;
Owen Andersond2850532008-08-21 20:58:52 +0000130}
131
132raw_ostream &raw_ostream::operator<<(long long N) {
Zachary Turner11db2642016-11-11 23:57:40 +0000133 write_integer(*this, static_cast<int64_t>(N), 0, IntegerStyle::Integer);
Zachary Turner733be512016-10-11 19:24:45 +0000134 return *this;
Owen Andersond2850532008-08-21 20:58:52 +0000135}
136
Daniel Dunbar6c9629b2009-07-30 18:21:23 +0000137raw_ostream &raw_ostream::write_hex(unsigned long long N) {
Zachary Turner5b2243e2016-10-29 00:27:22 +0000138 llvm::write_hex(*this, N, HexPrintStyle::Lower);
Zachary Turner733be512016-10-11 19:24:45 +0000139 return *this;
Chris Lattner0c19df42008-08-23 22:23:09 +0000140}
141
Adrian Prantl3dcd1222017-09-13 18:22:59 +0000142raw_ostream &raw_ostream::write_uuid(const uuid_t UUID) {
143 for (int Idx = 0; Idx < 16; ++Idx) {
144 *this << format("%02" PRIX32, UUID[Idx]);
145 if (Idx == 3 || Idx == 5 || Idx == 7 || Idx == 9)
146 *this << "-";
147 }
148 return *this;
149}
150
151
Daniel Dunbar65dc8912010-11-27 07:59:50 +0000152raw_ostream &raw_ostream::write_escaped(StringRef Str,
153 bool UseHexEscapes) {
Craig Topper775fb732016-02-04 06:51:41 +0000154 for (unsigned char c : Str) {
Daniel Dunbar4108c432009-10-17 20:43:08 +0000155 switch (c) {
156 case '\\':
157 *this << '\\' << '\\';
158 break;
159 case '\t':
160 *this << '\\' << 't';
161 break;
162 case '\n':
163 *this << '\\' << 'n';
164 break;
165 case '"':
166 *this << '\\' << '"';
167 break;
168 default:
169 if (std::isprint(c)) {
170 *this << c;
171 break;
172 }
173
Daniel Dunbar65dc8912010-11-27 07:59:50 +0000174 // Write out the escaped representation.
175 if (UseHexEscapes) {
176 *this << '\\' << 'x';
177 *this << hexdigit((c >> 4 & 0xF));
178 *this << hexdigit((c >> 0) & 0xF);
179 } else {
180 // Always use a full 3-character octal escape.
181 *this << '\\';
182 *this << char('0' + ((c >> 6) & 7));
183 *this << char('0' + ((c >> 3) & 7));
184 *this << char('0' + ((c >> 0) & 7));
185 }
Daniel Dunbar4108c432009-10-17 20:43:08 +0000186 }
187 }
188
189 return *this;
190}
191
Daniel Dunbar6c9629b2009-07-30 18:21:23 +0000192raw_ostream &raw_ostream::operator<<(const void *P) {
Zachary Turner5b2243e2016-10-29 00:27:22 +0000193 llvm::write_hex(*this, (uintptr_t)P, HexPrintStyle::PrefixLower);
Zachary Turner733be512016-10-11 19:24:45 +0000194 return *this;
Daniel Dunbar6c9629b2009-07-30 18:21:23 +0000195}
196
Chris Lattner06fa1762009-08-24 03:52:50 +0000197raw_ostream &raw_ostream::operator<<(double N) {
Zachary Turner5b2243e2016-10-29 00:27:22 +0000198 llvm::write_double(*this, N, FloatStyle::Exponent);
Zachary Turner733be512016-10-11 19:24:45 +0000199 return *this;
Chris Lattner06fa1762009-08-24 03:52:50 +0000200}
201
Daniel Dunbard24535f2009-03-16 22:55:06 +0000202void raw_ostream::flush_nonempty() {
203 assert(OutBufCur > OutBufStart && "Invalid call to flush_nonempty.");
Daniel Dunbar317a6cd2009-08-18 23:42:36 +0000204 size_t Length = OutBufCur - OutBufStart;
205 OutBufCur = OutBufStart;
206 write_impl(OutBufStart, Length);
Daniel Dunbard24535f2009-03-16 22:55:06 +0000207}
208
Daniel Dunbar7a9bb9e2009-03-16 22:00:17 +0000209raw_ostream &raw_ostream::write(unsigned char C) {
Daniel Dunbar64fa3862009-03-17 01:36:56 +0000210 // Group exceptional cases into a single branch.
Benjamin Kramerbd7f8d02012-08-29 22:57:00 +0000211 if (LLVM_UNLIKELY(OutBufCur >= OutBufEnd)) {
212 if (LLVM_UNLIKELY(!OutBufStart)) {
Daniel Dunbar317a6cd2009-08-18 23:42:36 +0000213 if (BufferMode == Unbuffered) {
Dan Gohman23f90c12009-08-18 20:09:59 +0000214 write_impl(reinterpret_cast<char*>(&C), 1);
215 return *this;
216 }
Daniel Dunbar0cf16862009-08-19 00:23:39 +0000217 // Set up a buffer and start over.
218 SetBuffered();
219 return write(C);
Dan Gohman23f90c12009-08-18 20:09:59 +0000220 }
Daniel Dunbar0cf16862009-08-19 00:23:39 +0000221
222 flush_nonempty();
Daniel Dunbar2d603da2009-03-17 01:13:35 +0000223 }
224
Daniel Dunbar7a9bb9e2009-03-16 22:00:17 +0000225 *OutBufCur++ = C;
Daniel Dunbar87862182009-03-16 22:08:44 +0000226 return *this;
Daniel Dunbar7a9bb9e2009-03-16 22:00:17 +0000227}
Chris Lattner0c19df42008-08-23 22:23:09 +0000228
Dan Gohmanf199ad62009-07-16 15:24:40 +0000229raw_ostream &raw_ostream::write(const char *Ptr, size_t Size) {
Daniel Dunbar64fa3862009-03-17 01:36:56 +0000230 // Group exceptional cases into a single branch.
Benjamin Kramerbd7f8d02012-08-29 22:57:00 +0000231 if (LLVM_UNLIKELY(size_t(OutBufEnd - OutBufCur) < Size)) {
232 if (LLVM_UNLIKELY(!OutBufStart)) {
Daniel Dunbar317a6cd2009-08-18 23:42:36 +0000233 if (BufferMode == Unbuffered) {
Dan Gohman52022c22009-08-13 15:44:52 +0000234 write_impl(Ptr, Size);
235 return *this;
236 }
237 // Set up a buffer and start over.
Dan Gohman84487b92009-08-13 17:27:29 +0000238 SetBuffered();
Dan Gohman52022c22009-08-13 15:44:52 +0000239 return write(Ptr, Size);
240 }
Daniel Dunbar0cf16862009-08-19 00:23:39 +0000241
Benjamin Kramerdfb0ad32011-03-04 19:49:30 +0000242 size_t NumBytes = OutBufEnd - OutBufCur;
243
Benjamin Krameracf08422011-03-04 18:18:16 +0000244 // If the buffer is empty at this point we have a string that is larger
Benjamin Kramerdfb0ad32011-03-04 19:49:30 +0000245 // than the buffer. Directly write the chunk that is a multiple of the
246 // preferred buffer size and put the remainder in the buffer.
Benjamin Kramerbd7f8d02012-08-29 22:57:00 +0000247 if (LLVM_UNLIKELY(OutBufCur == OutBufStart)) {
Michael Ilseman5be22a12014-12-12 21:48:03 +0000248 assert(NumBytes != 0 && "undefined behavior");
Benjamin Kramerdfb0ad32011-03-04 19:49:30 +0000249 size_t BytesToWrite = Size - (Size % NumBytes);
250 write_impl(Ptr, BytesToWrite);
Matt Beaumont-Gaya182be82013-03-12 23:55:24 +0000251 size_t BytesRemaining = Size - BytesToWrite;
252 if (BytesRemaining > size_t(OutBufEnd - OutBufCur)) {
253 // Too much left over to copy into our buffer.
254 return write(Ptr + BytesToWrite, BytesRemaining);
255 }
256 copy_to_buffer(Ptr + BytesToWrite, BytesRemaining);
Benjamin Krameracf08422011-03-04 18:18:16 +0000257 return *this;
258 }
259
260 // We don't have enough space in the buffer to fit the string in. Insert as
261 // much as possible, flush and start over with the remainder.
Benjamin Krameracf08422011-03-04 18:18:16 +0000262 copy_to_buffer(Ptr, NumBytes);
263 flush_nonempty();
264 return write(Ptr + NumBytes, Size - NumBytes);
Daniel Dunbar64fa3862009-03-17 01:36:56 +0000265 }
Dan Gohman52022c22009-08-13 15:44:52 +0000266
267 copy_to_buffer(Ptr, Size);
268
269 return *this;
270}
271
272void raw_ostream::copy_to_buffer(const char *Ptr, size_t Size) {
Dan Gohmanc04a00a2009-08-13 20:32:03 +0000273 assert(Size <= size_t(OutBufEnd - OutBufCur) && "Buffer overrun!");
Dan Gohman98205552009-08-13 18:38:15 +0000274
Owen Andersond2850532008-08-21 20:58:52 +0000275 // Handle short strings specially, memcpy isn't very good at very short
276 // strings.
277 switch (Size) {
Justin Bognercd1d5aa2016-08-17 20:30:52 +0000278 case 4: OutBufCur[3] = Ptr[3]; LLVM_FALLTHROUGH;
279 case 3: OutBufCur[2] = Ptr[2]; LLVM_FALLTHROUGH;
280 case 2: OutBufCur[1] = Ptr[1]; LLVM_FALLTHROUGH;
281 case 1: OutBufCur[0] = Ptr[0]; LLVM_FALLTHROUGH;
Owen Andersond2850532008-08-21 20:58:52 +0000282 case 0: break;
283 default:
Dan Gohman52022c22009-08-13 15:44:52 +0000284 memcpy(OutBufCur, Ptr, Size);
Owen Andersond2850532008-08-21 20:58:52 +0000285 break;
286 }
Daniel Dunbar3da6a702009-03-10 16:21:55 +0000287
Dan Gohman52022c22009-08-13 15:44:52 +0000288 OutBufCur += Size;
Owen Andersond2850532008-08-21 20:58:52 +0000289}
290
Chris Lattner22b52c92008-08-23 19:23:10 +0000291// Formatted output.
292raw_ostream &raw_ostream::operator<<(const format_object_base &Fmt) {
Daniel Dunbar64fa3862009-03-17 01:36:56 +0000293 // If we have more than a few bytes left in our output buffer, try
294 // formatting directly onto its end.
Dan Gohmanf199ad62009-07-16 15:24:40 +0000295 size_t NextBufferSize = 127;
Daniel Dunbar47a309c2009-08-23 20:31:39 +0000296 size_t BufferBytesLeft = OutBufEnd - OutBufCur;
297 if (BufferBytesLeft > 3) {
Dan Gohmanf199ad62009-07-16 15:24:40 +0000298 size_t BytesUsed = Fmt.print(OutBufCur, BufferBytesLeft);
Dan Gohmanb452d4e2010-03-24 19:38:02 +0000299
Chris Lattner22b52c92008-08-23 19:23:10 +0000300 // Common case is that we have plenty of space.
Daniel Dunbar47a309c2009-08-23 20:31:39 +0000301 if (BytesUsed <= BufferBytesLeft) {
Chris Lattner22b52c92008-08-23 19:23:10 +0000302 OutBufCur += BytesUsed;
303 return *this;
304 }
Dan Gohmanb452d4e2010-03-24 19:38:02 +0000305
Chris Lattner22b52c92008-08-23 19:23:10 +0000306 // Otherwise, we overflowed and the return value tells us the size to try
307 // again with.
308 NextBufferSize = BytesUsed;
309 }
Dan Gohmanb452d4e2010-03-24 19:38:02 +0000310
Chris Lattner22b52c92008-08-23 19:23:10 +0000311 // If we got here, we didn't have enough space in the output buffer for the
312 // string. Try printing into a SmallVector that is resized to have enough
313 // space. Iterate until we win.
314 SmallVector<char, 128> V;
Dan Gohmanb452d4e2010-03-24 19:38:02 +0000315
Eugene Zelenko33d7b762016-08-23 17:14:32 +0000316 while (true) {
Chris Lattner22b52c92008-08-23 19:23:10 +0000317 V.resize(NextBufferSize);
Dan Gohmanb452d4e2010-03-24 19:38:02 +0000318
Chris Lattner22b52c92008-08-23 19:23:10 +0000319 // Try formatting into the SmallVector.
Daniel Dunbar47a309c2009-08-23 20:31:39 +0000320 size_t BytesUsed = Fmt.print(V.data(), NextBufferSize);
Dan Gohmanb452d4e2010-03-24 19:38:02 +0000321
Chris Lattner22b52c92008-08-23 19:23:10 +0000322 // If BytesUsed fit into the vector, we win.
Chris Lattner2bfc72e2008-10-26 19:20:47 +0000323 if (BytesUsed <= NextBufferSize)
Daniel Dunbar47a309c2009-08-23 20:31:39 +0000324 return write(V.data(), BytesUsed);
Dan Gohmanb452d4e2010-03-24 19:38:02 +0000325
Chris Lattner22b52c92008-08-23 19:23:10 +0000326 // Otherwise, try again with a new size.
327 assert(BytesUsed > NextBufferSize && "Didn't grow buffer!?");
328 NextBufferSize = BytesUsed;
329 }
330}
331
Zachary Turner11db2642016-11-11 23:57:40 +0000332raw_ostream &raw_ostream::operator<<(const formatv_object_base &Obj) {
333 SmallString<128> S;
334 Obj.format(*this);
335 return *this;
336}
337
Nick Kledzike6480372014-09-25 20:30:58 +0000338raw_ostream &raw_ostream::operator<<(const FormattedString &FS) {
Frederich Munch5e9d6d02017-07-13 16:11:08 +0000339 if (FS.Str.size() >= FS.Width || FS.Justify == FormattedString::JustifyNone) {
340 this->operator<<(FS.Str);
341 return *this;
342 }
343 const size_t Difference = FS.Width - FS.Str.size();
344 switch (FS.Justify) {
345 case FormattedString::JustifyLeft:
346 this->operator<<(FS.Str);
347 this->indent(Difference);
348 break;
349 case FormattedString::JustifyRight:
350 this->indent(Difference);
351 this->operator<<(FS.Str);
352 break;
353 case FormattedString::JustifyCenter: {
354 int PadAmount = Difference / 2;
Nick Kledzike6480372014-09-25 20:30:58 +0000355 this->indent(PadAmount);
Frederich Munch5e9d6d02017-07-13 16:11:08 +0000356 this->operator<<(FS.Str);
357 this->indent(Difference - PadAmount);
358 break;
359 }
360 default:
361 llvm_unreachable("Bad Justification");
362 }
Nick Kledzike6480372014-09-25 20:30:58 +0000363 return *this;
364}
365
366raw_ostream &raw_ostream::operator<<(const FormattedNumber &FN) {
367 if (FN.Hex) {
Zachary Turner5b2243e2016-10-29 00:27:22 +0000368 HexPrintStyle Style;
369 if (FN.Upper && FN.HexPrefix)
370 Style = HexPrintStyle::PrefixUpper;
371 else if (FN.Upper && !FN.HexPrefix)
372 Style = HexPrintStyle::Upper;
373 else if (!FN.Upper && FN.HexPrefix)
374 Style = HexPrintStyle::PrefixLower;
375 else
376 Style = HexPrintStyle::Lower;
377 llvm::write_hex(*this, FN.HexValue, Style, FN.Width);
Nick Kledzike6480372014-09-25 20:30:58 +0000378 } else {
Zachary Turner5b2243e2016-10-29 00:27:22 +0000379 llvm::SmallString<16> Buffer;
380 llvm::raw_svector_ostream Stream(Buffer);
Zachary Turner11db2642016-11-11 23:57:40 +0000381 llvm::write_integer(Stream, FN.DecValue, 0, IntegerStyle::Integer);
Zachary Turner5b2243e2016-10-29 00:27:22 +0000382 if (Buffer.size() < FN.Width)
383 indent(FN.Width - Buffer.size());
384 (*this) << Buffer;
Nick Kledzike6480372014-09-25 20:30:58 +0000385 }
Zachary Turner733be512016-10-11 19:24:45 +0000386 return *this;
Nick Kledzike6480372014-09-25 20:30:58 +0000387}
388
Zachary Turner4a86af02016-11-10 20:16:45 +0000389raw_ostream &raw_ostream::operator<<(const FormattedBytes &FB) {
390 if (FB.Bytes.empty())
391 return *this;
392
Greg Claytonbde0a162016-11-09 00:15:54 +0000393 size_t LineIndex = 0;
Zachary Turner4a86af02016-11-10 20:16:45 +0000394 auto Bytes = FB.Bytes;
395 const size_t Size = Bytes.size();
396 HexPrintStyle HPS = FB.Upper ? HexPrintStyle::Upper : HexPrintStyle::Lower;
397 uint64_t OffsetWidth = 0;
398 if (FB.FirstByteOffset.hasValue()) {
399 // Figure out how many nibbles are needed to print the largest offset
400 // represented by this data set, so that we can align the offset field
401 // to the right width.
402 size_t Lines = Size / FB.NumPerLine;
403 uint64_t MaxOffset = *FB.FirstByteOffset + Lines * FB.NumPerLine;
404 unsigned Power = 0;
405 if (MaxOffset > 0)
406 Power = llvm::Log2_64_Ceil(MaxOffset);
Zachary Turner805d43a2016-11-10 20:35:21 +0000407 OffsetWidth = std::max<uint64_t>(4, llvm::alignTo(Power, 4) / 4);
Zachary Turner4a86af02016-11-10 20:16:45 +0000408 }
409
410 // The width of a block of data including all spaces for group separators.
411 unsigned NumByteGroups =
412 alignTo(FB.NumPerLine, FB.ByteGroupSize) / FB.ByteGroupSize;
413 unsigned BlockCharWidth = FB.NumPerLine * 2 + NumByteGroups - 1;
414
415 while (!Bytes.empty()) {
416 indent(FB.IndentLevel);
417
Greg Claytonbde0a162016-11-09 00:15:54 +0000418 if (FB.FirstByteOffset.hasValue()) {
419 uint64_t Offset = FB.FirstByteOffset.getValue();
Zachary Turner4a86af02016-11-10 20:16:45 +0000420 llvm::write_hex(*this, Offset + LineIndex, HPS, OffsetWidth);
Greg Claytonbde0a162016-11-09 00:15:54 +0000421 *this << ": ";
422 }
Zachary Turner4a86af02016-11-10 20:16:45 +0000423
424 auto Line = Bytes.take_front(FB.NumPerLine);
425
426 size_t CharsPrinted = 0;
427 // Print the hex bytes for this line in groups
428 for (size_t I = 0; I < Line.size(); ++I, CharsPrinted += 2) {
429 if (I && (I % FB.ByteGroupSize) == 0) {
430 ++CharsPrinted;
Greg Claytonbde0a162016-11-09 00:15:54 +0000431 *this << " ";
Zachary Turner4a86af02016-11-10 20:16:45 +0000432 }
433 llvm::write_hex(*this, Line[I], HPS, 2);
Greg Claytonbde0a162016-11-09 00:15:54 +0000434 }
Zachary Turner4a86af02016-11-10 20:16:45 +0000435
Greg Claytonbde0a162016-11-09 00:15:54 +0000436 if (FB.ASCII) {
437 // Print any spaces needed for any bytes that we didn't print on this
438 // line so that the ASCII bytes are correctly aligned.
Zachary Turner4a86af02016-11-10 20:16:45 +0000439 assert(BlockCharWidth >= CharsPrinted);
440 indent(BlockCharWidth - CharsPrinted + 2);
441 *this << "|";
442
Greg Claytonbde0a162016-11-09 00:15:54 +0000443 // Print the ASCII char values for each byte on this line
Zachary Turner4a86af02016-11-10 20:16:45 +0000444 for (uint8_t Byte : Line) {
445 if (isprint(Byte))
446 *this << static_cast<char>(Byte);
Greg Claytonbde0a162016-11-09 00:15:54 +0000447 else
448 *this << '.';
449 }
450 *this << '|';
451 }
Zachary Turner4a86af02016-11-10 20:16:45 +0000452
453 Bytes = Bytes.drop_front(Line.size());
454 LineIndex += Line.size();
Greg Claytonbde0a162016-11-09 00:15:54 +0000455 if (LineIndex < Size)
456 *this << '\n';
457 }
458 return *this;
459}
460
Chris Lattnere6db2c32009-08-22 23:10:29 +0000461/// indent - Insert 'NumSpaces' spaces.
462raw_ostream &raw_ostream::indent(unsigned NumSpaces) {
Dan Gohmanf88f52e2009-08-24 04:13:01 +0000463 static const char Spaces[] = " "
464 " "
465 " ";
Chris Lattnere6db2c32009-08-22 23:10:29 +0000466
467 // Usually the indentation is small, handle it with a fastpath.
Dan Gohmanc9fa0512009-08-24 04:43:38 +0000468 if (NumSpaces < array_lengthof(Spaces))
Chris Lattnere6db2c32009-08-22 23:10:29 +0000469 return write(Spaces, NumSpaces);
Dan Gohmanb452d4e2010-03-24 19:38:02 +0000470
Chris Lattnere6db2c32009-08-22 23:10:29 +0000471 while (NumSpaces) {
Dan Gohmanc9fa0512009-08-24 04:43:38 +0000472 unsigned NumToWrite = std::min(NumSpaces,
473 (unsigned)array_lengthof(Spaces)-1);
Chris Lattnere6db2c32009-08-22 23:10:29 +0000474 write(Spaces, NumToWrite);
475 NumSpaces -= NumToWrite;
476 }
477 return *this;
478}
479
Chris Lattner22b52c92008-08-23 19:23:10 +0000480//===----------------------------------------------------------------------===//
481// Formatted Output
482//===----------------------------------------------------------------------===//
483
484// Out of line virtual method.
485void format_object_base::home() {
486}
487
Chris Lattner84b94f72008-08-17 01:35:29 +0000488//===----------------------------------------------------------------------===//
489// raw_fd_ostream
490//===----------------------------------------------------------------------===//
491
Rafael Espindola79be4cc2015-04-13 10:28:56 +0000492static int getFD(StringRef Filename, std::error_code &EC,
493 sys::fs::OpenFlags Flags) {
Dan Gohmanc825cee2010-08-18 22:26:19 +0000494 // Handle "-" as stdout. Note that when we do this, we consider ourself
Yaron Keren80745c52017-03-31 12:08:45 +0000495 // the owner of stdout and may set the "binary" flag globally based on Flags.
Rafael Espindola3fd1e992014-08-25 18:16:47 +0000496 if (Filename == "-") {
Rafael Espindola79be4cc2015-04-13 10:28:56 +0000497 EC = std::error_code();
Daniel Dunbared90e702008-11-13 05:01:07 +0000498 // If user requested binary then put stdout into binary mode if
499 // possible.
Rafael Espindola90c7f1c2014-02-24 18:20:12 +0000500 if (!(Flags & sys::fs::F_Text))
Rafael Espindolacb2eca02013-06-12 20:58:35 +0000501 sys::ChangeStdoutToBinary();
Yaron Keren9d27c472017-03-30 19:30:51 +0000502 return STDOUT_FILENO;
Chris Lattnerd5bc0682008-08-17 03:53:23 +0000503 }
Dan Gohmanb452d4e2010-03-24 19:38:02 +0000504
Rafael Espindola79be4cc2015-04-13 10:28:56 +0000505 int FD;
Rafael Espindola3fd1e992014-08-25 18:16:47 +0000506 EC = sys::fs::openFileForWrite(Filename, FD, Flags);
Rafael Espindola79be4cc2015-04-13 10:28:56 +0000507 if (EC)
508 return -1;
Dan Gohmanb452d4e2010-03-24 19:38:02 +0000509
Rafael Espindola79be4cc2015-04-13 10:28:56 +0000510 return FD;
Chris Lattner84b94f72008-08-17 01:35:29 +0000511}
512
Rafael Espindola79be4cc2015-04-13 10:28:56 +0000513raw_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
Rafael Espindola62e6ec02015-04-09 16:59:07 +0000517/// FD is the file descriptor that this writes to. If ShouldClose is true, this
518/// closes the file when the stream is destroyed.
Francois Picheta3037c32010-10-14 20:30:58 +0000519raw_fd_ostream::raw_fd_ostream(int fd, bool shouldClose, bool unbuffered)
Bob Haarman9ce2d032017-10-24 01:26:22 +0000520 : raw_pwrite_stream(unbuffered), FD(fd), ShouldClose(shouldClose) {
Rafael Espindola79be4cc2015-04-13 10:28:56 +0000521 if (FD < 0 ) {
522 ShouldClose = false;
523 return;
524 }
Reid Kleckner02aeadc2017-08-04 01:39:23 +0000525
526 // Do not attempt to close stdout or stderr. We used to try to maintain the
527 // property that tools that support writing file to stdout should not also
528 // write informational output to stdout, but in practice we were never able to
529 // maintain this invariant. Many features have been added to LLVM and clang
530 // (-fdump-record-layouts, optimization remarks, etc) that print to stdout, so
531 // users must simply be aware that mixed output and remarks is a possibility.
Yaron Keren9d27c472017-03-30 19:30:51 +0000532 if (FD <= STDERR_FILENO)
533 ShouldClose = false;
Michael J. Spencerb7479902011-01-17 15:53:12 +0000534
535 // Get the starting position.
536 off_t loc = ::lseek(FD, 0, SEEK_CUR);
Rafael Espindolaa9b84ab2015-04-13 11:09:48 +0000537#ifdef LLVM_ON_WIN32
538 // MSVCRT's _lseek(SEEK_CUR) doesn't return -1 for pipes.
539 sys::fs::file_status Status;
540 std::error_code EC = status(FD, Status);
541 SupportsSeeking = !EC && Status.type() == sys::fs::file_type::regular_file;
542#else
Rafael Espindola74d2f612015-04-10 18:15:51 +0000543 SupportsSeeking = loc != (off_t)-1;
Rafael Espindolaa9b84ab2015-04-13 11:09:48 +0000544#endif
Rafael Espindola74d2f612015-04-10 18:15:51 +0000545 if (!SupportsSeeking)
Michael J. Spencerb7479902011-01-17 15:53:12 +0000546 pos = 0;
547 else
548 pos = static_cast<uint64_t>(loc);
Francois Picheta3037c32010-10-14 20:30:58 +0000549}
550
Chris Lattner84b94f72008-08-17 01:35:29 +0000551raw_fd_ostream::~raw_fd_ostream() {
Dan Gohman38adfdd2010-08-20 16:34:20 +0000552 if (FD >= 0) {
553 flush();
Bob Haarman9ce2d032017-10-24 01:26:22 +0000554 if (ShouldClose) {
555 if (auto EC = sys::Process::SafelyCloseFileDescriptor(FD))
556 error_detected(EC);
557 }
Dan Gohman38adfdd2010-08-20 16:34:20 +0000558 }
559
NAKAMURA Takumi76e68ea2011-03-16 02:53:39 +0000560#ifdef __MINGW32__
561 // On mingw, global dtors should not call exit().
562 // report_fatal_error() invokes exit(). We know report_fatal_error()
563 // might not write messages to stderr when any errors were detected
564 // on FD == 2.
565 if (FD == 2) return;
566#endif
567
Dan Gohman38adfdd2010-08-20 16:34:20 +0000568 // If there are any pending errors, report them now. Clients wishing
569 // to avoid report_fatal_error calls should check for errors with
570 // has_error() and clear the error flag with clear_error() before
571 // destructing raw_ostream objects which may have errors.
572 if (has_error())
Bob Haarman9ce2d032017-10-24 01:26:22 +0000573 report_fatal_error("IO failure on output stream: " + error().message(),
574 /*GenCrashDiag=*/false);
Chris Lattnerce3b2c32010-08-17 23:11:56 +0000575}
Chris Lattner9e6f1f12009-08-23 02:51:22 +0000576
Dan Gohmanf199ad62009-07-16 15:24:40 +0000577void raw_fd_ostream::write_impl(const char *Ptr, size_t Size) {
Dan Gohmanb452d4e2010-03-24 19:38:02 +0000578 assert(FD >= 0 && "File already closed.");
Daniel Dunbardb7a36c2009-03-16 23:29:31 +0000579 pos += Size;
Dan Gohmanef969f32010-05-06 01:27:36 +0000580
Yunzhong Gaofb2a9c42016-01-06 00:50:06 +0000581#ifndef LLVM_ON_WIN32
Saleem Abdulrasool8199dad2017-06-20 20:51:51 +0000582#if defined(__linux__)
583 bool ShouldWriteInChunks = true;
584#else
Yunzhong Gaofb2a9c42016-01-06 00:50:06 +0000585 bool ShouldWriteInChunks = false;
Saleem Abdulrasool8199dad2017-06-20 20:51:51 +0000586#endif
Yunzhong Gaofb2a9c42016-01-06 00:50:06 +0000587#else
588 // Writing a large size of output to Windows console returns ENOMEM. It seems
589 // that, prior to Windows 8, WriteFile() is redirecting to WriteConsole(), and
590 // the latter has a size limit (66000 bytes or less, depending on heap usage).
Reid Kleckner5fb7a582016-01-11 23:33:03 +0000591 bool ShouldWriteInChunks = !!::_isatty(FD) && !RunningWindows8OrGreater();
Yunzhong Gaofb2a9c42016-01-06 00:50:06 +0000592#endif
593
Benjamin Kramerce84a252010-05-05 15:17:47 +0000594 do {
Yunzhong Gaofb2a9c42016-01-06 00:50:06 +0000595 size_t ChunkSize = Size;
596 if (ChunkSize > 32767 && ShouldWriteInChunks)
597 ChunkSize = 32767;
598
599 ssize_t ret = ::write(FD, Ptr, ChunkSize);
Dan Gohmanef969f32010-05-06 01:27:36 +0000600
601 if (ret < 0) {
602 // If it's a recoverable error, swallow it and retry the write.
Dan Gohmandea53102010-05-18 15:25:14 +0000603 //
604 // Ideally we wouldn't ever see EAGAIN or EWOULDBLOCK here, since
605 // raw_ostream isn't designed to do non-blocking I/O. However, some
606 // programs, such as old versions of bjam, have mistakenly used
607 // O_NONBLOCK. For compatibility, emulate blocking semantics by
608 // spinning until the write succeeds. If you don't want spinning,
609 // don't use O_NONBLOCK file descriptors with raw_ostream.
Dan Gohmand3511162010-05-06 02:06:20 +0000610 if (errno == EINTR || errno == EAGAIN
611#ifdef EWOULDBLOCK
612 || errno == EWOULDBLOCK
613#endif
614 )
Dan Gohmanef969f32010-05-06 01:27:36 +0000615 continue;
616
617 // Otherwise it's a non-recoverable error. Note it and quit.
Bob Haarman9ce2d032017-10-24 01:26:22 +0000618 error_detected(std::error_code(errno, std::generic_category()));
Dan Gohmanef969f32010-05-06 01:27:36 +0000619 break;
620 }
621
622 // The write may have written some or all of the data. Update the
623 // size and buffer pointer to reflect the remainder that needs
624 // to be written. If there are no bytes left, we're done.
625 Ptr += ret;
626 Size -= ret;
627 } while (Size > 0);
Chris Lattner84b94f72008-08-17 01:35:29 +0000628}
629
Dan Gohman44790e72010-08-18 01:34:52 +0000630void raw_fd_ostream::close() {
631 assert(ShouldClose);
632 ShouldClose = false;
633 flush();
Bob Haarman9ce2d032017-10-24 01:26:22 +0000634 if (auto EC = sys::Process::SafelyCloseFileDescriptor(FD))
635 error_detected(EC);
Dan Gohman44790e72010-08-18 01:34:52 +0000636 FD = -1;
637}
638
Ted Kremeneka2669922009-01-26 21:42:04 +0000639uint64_t raw_fd_ostream::seek(uint64_t off) {
Yaron Keren7cf7f802016-02-23 07:17:58 +0000640 assert(SupportsSeeking && "Stream does not support seeking!");
Ted Kremeneka2669922009-01-26 21:42:04 +0000641 flush();
Peter Collingbourne8db7e5e2016-12-09 05:20:43 +0000642#ifdef LLVM_ON_WIN32
643 pos = ::_lseeki64(FD, off, SEEK_SET);
644#elif defined(HAVE_LSEEK64)
645 pos = ::lseek64(FD, off, SEEK_SET);
646#else
Peter Collingbournef74fcdd2016-12-09 05:04:30 +0000647 pos = ::lseek(FD, off, SEEK_SET);
Peter Collingbourne8db7e5e2016-12-09 05:20:43 +0000648#endif
Rafael Espindola642a2212015-04-14 22:54:16 +0000649 if (pos == (uint64_t)-1)
Bob Haarman9ce2d032017-10-24 01:26:22 +0000650 error_detected(std::error_code(errno, std::generic_category()));
Dan Gohmanb452d4e2010-03-24 19:38:02 +0000651 return pos;
Ted Kremeneka2669922009-01-26 21:42:04 +0000652}
653
Rafael Espindola4ba9af12015-04-20 13:04:30 +0000654void raw_fd_ostream::pwrite_impl(const char *Ptr, size_t Size,
655 uint64_t Offset) {
Rafael Espindola37b70152015-04-14 15:00:34 +0000656 uint64_t Pos = tell();
657 seek(Offset);
658 write(Ptr, Size);
659 seek(Pos);
660}
661
Chris Lattnerdd3e9aa2009-12-19 01:38:42 +0000662size_t raw_fd_ostream::preferred_buffer_size() const {
Chris Lattnerca97c922010-07-07 15:52:27 +0000663#if !defined(_MSC_VER) && !defined(__MINGW32__) && !defined(__minix)
Chris Lattnerc86cdc72010-04-09 20:45:04 +0000664 // Windows and Minix have no st_blksize.
Dan Gohman84487b92009-08-13 17:27:29 +0000665 assert(FD >= 0 && "File not yet open!");
666 struct stat statbuf;
Chris Lattnerdd3e9aa2009-12-19 01:38:42 +0000667 if (fstat(FD, &statbuf) != 0)
668 return 0;
Dan Gohmanb452d4e2010-03-24 19:38:02 +0000669
Chris Lattnerdd3e9aa2009-12-19 01:38:42 +0000670 // If this is a terminal, don't use buffering. Line buffering
671 // would be a more traditional thing to do, but it's not worth
672 // the complexity.
673 if (S_ISCHR(statbuf.st_mode) && isatty(FD))
674 return 0;
675 // Return the preferred block size.
676 return statbuf.st_blksize;
Dan Gohmanfeaeb362010-05-28 16:50:01 +0000677#else
Dan Gohman84487b92009-08-13 17:27:29 +0000678 return raw_ostream::preferred_buffer_size();
Dan Gohmanfeaeb362010-05-28 16:50:01 +0000679#endif
Dan Gohman84487b92009-08-13 17:27:29 +0000680}
681
Torok Edwin9b5a47f2009-06-04 07:09:50 +0000682raw_ostream &raw_fd_ostream::changeColor(enum Colors colors, bool bold,
683 bool bg) {
684 if (sys::Process::ColorNeedsFlush())
685 flush();
686 const char *colorcode =
687 (colors == SAVEDCOLOR) ? sys::Process::OutputBold(bg)
688 : sys::Process::OutputColor(colors, bold, bg);
689 if (colorcode) {
Dan Gohmanf199ad62009-07-16 15:24:40 +0000690 size_t len = strlen(colorcode);
Torok Edwin9b5a47f2009-06-04 07:09:50 +0000691 write(colorcode, len);
692 // don't account colors towards output characters
693 pos -= len;
694 }
695 return *this;
696}
697
698raw_ostream &raw_fd_ostream::resetColor() {
699 if (sys::Process::ColorNeedsFlush())
700 flush();
701 const char *colorcode = sys::Process::ResetColor();
702 if (colorcode) {
Dan Gohmanf199ad62009-07-16 15:24:40 +0000703 size_t len = strlen(colorcode);
Torok Edwin9b5a47f2009-06-04 07:09:50 +0000704 write(colorcode, len);
705 // don't account colors towards output characters
706 pos -= len;
707 }
708 return *this;
709}
710
Benjamin Kramer13d16f32012-04-16 08:56:50 +0000711raw_ostream &raw_fd_ostream::reverseColor() {
712 if (sys::Process::ColorNeedsFlush())
713 flush();
714 const char *colorcode = sys::Process::OutputReverse();
715 if (colorcode) {
716 size_t len = strlen(colorcode);
717 write(colorcode, len);
718 // don't account colors towards output characters
719 pos -= len;
720 }
721 return *this;
722}
723
Dan Gohmane5929232009-09-11 20:46:33 +0000724bool raw_fd_ostream::is_displayed() const {
725 return sys::Process::FileDescriptorIsDisplayed(FD);
726}
727
Daniel Dunbar04b45832012-07-20 18:29:41 +0000728bool raw_fd_ostream::has_colors() const {
729 return sys::Process::FileDescriptorHasColors(FD);
730}
731
Chris Lattnerd3723fc2008-08-17 04:13:37 +0000732//===----------------------------------------------------------------------===//
Dan Gohmane9a46912010-08-20 16:44:56 +0000733// outs(), errs(), nulls()
Chris Lattnerd3723fc2008-08-17 04:13:37 +0000734//===----------------------------------------------------------------------===//
Chris Lattner84b94f72008-08-17 01:35:29 +0000735
Chris Lattnerd3723fc2008-08-17 04:13:37 +0000736/// outs() - This returns a reference to a raw_ostream for standard output.
737/// Use it like: outs() << "foo" << "bar";
Owen Anderson93719642008-08-21 00:14:44 +0000738raw_ostream &llvm::outs() {
Reid Kleckner02aeadc2017-08-04 01:39:23 +0000739 // Set buffer settings to model stdout behavior.
Rafael Espindola79be4cc2015-04-13 10:28:56 +0000740 std::error_code EC;
741 static raw_fd_ostream S("-", EC, sys::fs::F_None);
742 assert(!EC);
Chris Lattnerd3723fc2008-08-17 04:13:37 +0000743 return S;
744}
745
746/// errs() - This returns a reference to a raw_ostream for standard error.
747/// Use it like: errs() << "foo" << "bar";
Owen Anderson93719642008-08-21 00:14:44 +0000748raw_ostream &llvm::errs() {
Dan Gohman443f2d62010-08-20 16:39:41 +0000749 // Set standard error to be unbuffered by default.
750 static raw_fd_ostream S(STDERR_FILENO, false, true);
Chris Lattnerd3723fc2008-08-17 04:13:37 +0000751 return S;
752}
753
Daniel Dunbar95a551a2009-07-16 21:17:53 +0000754/// nulls() - This returns a reference to a raw_ostream which discards output.
755raw_ostream &llvm::nulls() {
756 static raw_null_ostream S;
757 return S;
758}
759
Chris Lattner205af962008-08-23 22:43:04 +0000760//===----------------------------------------------------------------------===//
761// raw_string_ostream
762//===----------------------------------------------------------------------===//
763
Daniel Dunbard882f4b2009-08-18 20:07:36 +0000764raw_string_ostream::~raw_string_ostream() {
765 flush();
766}
767
Dan Gohmanf199ad62009-07-16 15:24:40 +0000768void raw_string_ostream::write_impl(const char *Ptr, size_t Size) {
Daniel Dunbardb7a36c2009-03-16 23:29:31 +0000769 OS.append(Ptr, Size);
Chris Lattner205af962008-08-23 22:43:04 +0000770}
771
772//===----------------------------------------------------------------------===//
773// raw_svector_ostream
774//===----------------------------------------------------------------------===//
775
Yaron Keren3d1173b2015-08-13 06:19:52 +0000776uint64_t raw_svector_ostream::current_pos() const { return OS.size(); }
Daniel Dunbarb090bf42009-08-19 17:54:29 +0000777
Yaron Keren3d1173b2015-08-13 06:19:52 +0000778void raw_svector_ostream::write_impl(const char *Ptr, size_t Size) {
779 OS.append(Ptr, Ptr + Size);
Nick Lewyckye2f6fb52015-08-13 18:10:19 +0000780}
Daniel Dunbard882f4b2009-08-18 20:07:36 +0000781
Rafael Espindola4ba9af12015-04-20 13:04:30 +0000782void raw_svector_ostream::pwrite_impl(const char *Ptr, size_t Size,
783 uint64_t Offset) {
Yaron Keren3d1173b2015-08-13 06:19:52 +0000784 memcpy(OS.data() + Offset, Ptr, Size);
Daniel Dunbare813cba2009-08-19 18:40:58 +0000785}
786
Daniel Dunbar95a551a2009-07-16 21:17:53 +0000787//===----------------------------------------------------------------------===//
788// raw_null_ostream
789//===----------------------------------------------------------------------===//
790
Dan Gohman4b66b472009-07-27 21:46:02 +0000791raw_null_ostream::~raw_null_ostream() {
792#ifndef NDEBUG
793 // ~raw_ostream asserts that the buffer is empty. This isn't necessary
794 // with raw_null_ostream, but it's better to have raw_null_ostream follow
795 // the rules than to change the rules just for raw_null_ostream.
796 flush();
797#endif
798}
799
Daniel Dunbar95a551a2009-07-16 21:17:53 +0000800void raw_null_ostream::write_impl(const char *Ptr, size_t Size) {
801}
802
Chris Lattnerdd3e9aa2009-12-19 01:38:42 +0000803uint64_t raw_null_ostream::current_pos() const {
Daniel Dunbar95a551a2009-07-16 21:17:53 +0000804 return 0;
805}
Rafael Espindola37b70152015-04-14 15:00:34 +0000806
Rafael Espindola4ba9af12015-04-20 13:04:30 +0000807void raw_null_ostream::pwrite_impl(const char *Ptr, size_t Size,
808 uint64_t Offset) {}