/Users/buildslave/jenkins/workspace/clang-stage2-coverage-R/llvm/include/llvm/Support/raw_ostream.h
Line | Count | Source (jump to first uncovered line) |
1 | | //===--- raw_ostream.h - Raw output stream ----------------------*- C++ -*-===// |
2 | | // |
3 | | // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
4 | | // See https://llvm.org/LICENSE.txt for license information. |
5 | | // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
6 | | // |
7 | | //===----------------------------------------------------------------------===// |
8 | | // |
9 | | // This file defines the raw_ostream class. |
10 | | // |
11 | | //===----------------------------------------------------------------------===// |
12 | | |
13 | | #ifndef LLVM_SUPPORT_RAW_OSTREAM_H |
14 | | #define LLVM_SUPPORT_RAW_OSTREAM_H |
15 | | |
16 | | #include "llvm/ADT/SmallVector.h" |
17 | | #include "llvm/ADT/StringRef.h" |
18 | | #include <cassert> |
19 | | #include <cstddef> |
20 | | #include <cstdint> |
21 | | #include <cstring> |
22 | | #include <string> |
23 | | #include <system_error> |
24 | | |
25 | | namespace llvm { |
26 | | |
27 | | class formatv_object_base; |
28 | | class format_object_base; |
29 | | class FormattedString; |
30 | | class FormattedNumber; |
31 | | class FormattedBytes; |
32 | | |
33 | | namespace sys { |
34 | | namespace fs { |
35 | | enum FileAccess : unsigned; |
36 | | enum OpenFlags : unsigned; |
37 | | enum CreationDisposition : unsigned; |
38 | | } // end namespace fs |
39 | | } // end namespace sys |
40 | | |
41 | | /// This class implements an extremely fast bulk output stream that can *only* |
42 | | /// output to a stream. It does not support seeking, reopening, rewinding, line |
43 | | /// buffered disciplines etc. It is a simple buffer that outputs |
44 | | /// a chunk at a time. |
45 | | class raw_ostream { |
46 | | private: |
47 | | /// The buffer is handled in such a way that the buffer is |
48 | | /// uninitialized, unbuffered, or out of space when OutBufCur >= |
49 | | /// OutBufEnd. Thus a single comparison suffices to determine if we |
50 | | /// need to take the slow path to write a single character. |
51 | | /// |
52 | | /// The buffer is in one of three states: |
53 | | /// 1. Unbuffered (BufferMode == Unbuffered) |
54 | | /// 1. Uninitialized (BufferMode != Unbuffered && OutBufStart == 0). |
55 | | /// 2. Buffered (BufferMode != Unbuffered && OutBufStart != 0 && |
56 | | /// OutBufEnd - OutBufStart >= 1). |
57 | | /// |
58 | | /// If buffered, then the raw_ostream owns the buffer if (BufferMode == |
59 | | /// InternalBuffer); otherwise the buffer has been set via SetBuffer and is |
60 | | /// managed by the subclass. |
61 | | /// |
62 | | /// If a subclass installs an external buffer using SetBuffer then it can wait |
63 | | /// for a \see write_impl() call to handle the data which has been put into |
64 | | /// this buffer. |
65 | | char *OutBufStart, *OutBufEnd, *OutBufCur; |
66 | | |
67 | | enum BufferKind { |
68 | | Unbuffered = 0, |
69 | | InternalBuffer, |
70 | | ExternalBuffer |
71 | | } BufferMode; |
72 | | |
73 | | public: |
74 | | // color order matches ANSI escape sequence, don't change |
75 | | enum Colors { |
76 | | BLACK = 0, |
77 | | RED, |
78 | | GREEN, |
79 | | YELLOW, |
80 | | BLUE, |
81 | | MAGENTA, |
82 | | CYAN, |
83 | | WHITE, |
84 | | SAVEDCOLOR |
85 | | }; |
86 | | |
87 | | explicit raw_ostream(bool unbuffered = false) |
88 | 112M | : BufferMode(unbuffered ? Unbuffered : InternalBuffer) { |
89 | 112M | // Start out ready to flush. |
90 | 112M | OutBufStart = OutBufEnd = OutBufCur = nullptr; |
91 | 112M | } |
92 | | |
93 | | raw_ostream(const raw_ostream &) = delete; |
94 | | void operator=(const raw_ostream &) = delete; |
95 | | |
96 | | virtual ~raw_ostream(); |
97 | | |
98 | | /// tell - Return the current offset with the file. |
99 | 19.0M | uint64_t tell() const { return current_pos() + GetNumBytesInBuffer(); } |
100 | | |
101 | | //===--------------------------------------------------------------------===// |
102 | | // Configuration Interface |
103 | | //===--------------------------------------------------------------------===// |
104 | | |
105 | | /// Set the stream to be buffered, with an automatically determined buffer |
106 | | /// size. |
107 | | void SetBuffered(); |
108 | | |
109 | | /// Set the stream to be buffered, using the specified buffer size. |
110 | 25.2M | void SetBufferSize(size_t Size) { |
111 | 25.2M | flush(); |
112 | 25.2M | SetBufferAndMode(new char[Size], Size, InternalBuffer); |
113 | 25.2M | } |
114 | | |
115 | 673k | size_t GetBufferSize() const { |
116 | 673k | // If we're supposed to be buffered but haven't actually gotten around |
117 | 673k | // to allocating the buffer yet, return the value that would be used. |
118 | 673k | if (BufferMode != Unbuffered && OutBufStart == nullptr652k ) |
119 | 52.0k | return preferred_buffer_size(); |
120 | 620k | |
121 | 620k | // Otherwise just return the size of the allocated buffer. |
122 | 620k | return OutBufEnd - OutBufStart; |
123 | 620k | } |
124 | | |
125 | | /// Set the stream to be unbuffered. When unbuffered, the stream will flush |
126 | | /// after every write. This routine will also flush the buffer immediately |
127 | | /// when the stream is being set to unbuffered. |
128 | 87.7M | void SetUnbuffered() { |
129 | 87.7M | flush(); |
130 | 87.7M | SetBufferAndMode(nullptr, 0, Unbuffered); |
131 | 87.7M | } |
132 | | |
133 | 28.3M | size_t GetNumBytesInBuffer() const { |
134 | 28.3M | return OutBufCur - OutBufStart; |
135 | 28.3M | } |
136 | | |
137 | | //===--------------------------------------------------------------------===// |
138 | | // Data Output Interface |
139 | | //===--------------------------------------------------------------------===// |
140 | | |
141 | 146M | void flush() { |
142 | 146M | if (OutBufCur != OutBufStart) |
143 | 26.7M | flush_nonempty(); |
144 | 146M | } |
145 | | |
146 | 456M | raw_ostream &operator<<(char C) { |
147 | 456M | if (OutBufCur >= OutBufEnd) |
148 | 239M | return write(C); |
149 | 216M | *OutBufCur++ = C; |
150 | 216M | return *this; |
151 | 216M | } |
152 | | |
153 | 12.2M | raw_ostream &operator<<(unsigned char C) { |
154 | 12.2M | if (OutBufCur >= OutBufEnd) |
155 | 853k | return write(C); |
156 | 11.4M | *OutBufCur++ = C; |
157 | 11.4M | return *this; |
158 | 11.4M | } |
159 | | |
160 | 152 | raw_ostream &operator<<(signed char C) { |
161 | 152 | if (OutBufCur >= OutBufEnd) |
162 | 0 | return write(C); |
163 | 152 | *OutBufCur++ = C; |
164 | 152 | return *this; |
165 | 152 | } |
166 | | |
167 | 671M | raw_ostream &operator<<(StringRef Str) { |
168 | 671M | // Inline fast path, particularly for strings with a known length. |
169 | 671M | size_t Size = Str.size(); |
170 | 671M | |
171 | 671M | // Make sure we can use the fast path. |
172 | 671M | if (Size > (size_t)(OutBufEnd - OutBufCur)) |
173 | 322M | return write(Str.data(), Size); |
174 | 348M | |
175 | 348M | if (Size) { |
176 | 327M | memcpy(OutBufCur, Str.data(), Size); |
177 | 327M | OutBufCur += Size; |
178 | 327M | } |
179 | 348M | return *this; |
180 | 348M | } |
181 | | |
182 | 400M | raw_ostream &operator<<(const char *Str) { |
183 | 400M | // Inline fast path, particularly for constant strings where a sufficiently |
184 | 400M | // smart compiler will simplify strlen. |
185 | 400M | |
186 | 400M | return this->operator<<(StringRef(Str)); |
187 | 400M | } |
188 | | |
189 | 71.8M | raw_ostream &operator<<(const std::string &Str) { |
190 | 71.8M | // Avoid the fast path, it would only increase code size for a marginal win. |
191 | 71.8M | return write(Str.data(), Str.length()); |
192 | 71.8M | } |
193 | | |
194 | 31.2M | raw_ostream &operator<<(const SmallVectorImpl<char> &Str) { |
195 | 31.2M | return write(Str.data(), Str.size()); |
196 | 31.2M | } |
197 | | |
198 | | raw_ostream &operator<<(unsigned long N); |
199 | | raw_ostream &operator<<(long N); |
200 | | raw_ostream &operator<<(unsigned long long N); |
201 | | raw_ostream &operator<<(long long N); |
202 | | raw_ostream &operator<<(const void *P); |
203 | | |
204 | 45.4M | raw_ostream &operator<<(unsigned int N) { |
205 | 45.4M | return this->operator<<(static_cast<unsigned long>(N)); |
206 | 45.4M | } |
207 | | |
208 | 15.4M | raw_ostream &operator<<(int N) { |
209 | 15.4M | return this->operator<<(static_cast<long>(N)); |
210 | 15.4M | } |
211 | | |
212 | | raw_ostream &operator<<(double N); |
213 | | |
214 | | /// Output \p N in hexadecimal, without any prefix or padding. |
215 | | raw_ostream &write_hex(unsigned long long N); |
216 | | |
217 | | /// Output a formatted UUID with dash separators. |
218 | | using uuid_t = uint8_t[16]; |
219 | | raw_ostream &write_uuid(const uuid_t UUID); |
220 | | |
221 | | /// Output \p Str, turning '\\', '\t', '\n', '"', and anything that doesn't |
222 | | /// satisfy llvm::isPrint into an escape sequence. |
223 | | raw_ostream &write_escaped(StringRef Str, bool UseHexEscapes = false); |
224 | | |
225 | | raw_ostream &write(unsigned char C); |
226 | | raw_ostream &write(const char *Ptr, size_t Size); |
227 | | |
228 | | // Formatted output, see the format() function in Support/Format.h. |
229 | | raw_ostream &operator<<(const format_object_base &Fmt); |
230 | | |
231 | | // Formatted output, see the leftJustify() function in Support/Format.h. |
232 | | raw_ostream &operator<<(const FormattedString &); |
233 | | |
234 | | // Formatted output, see the formatHex() function in Support/Format.h. |
235 | | raw_ostream &operator<<(const FormattedNumber &); |
236 | | |
237 | | // Formatted output, see the formatv() function in Support/FormatVariadic.h. |
238 | | raw_ostream &operator<<(const formatv_object_base &); |
239 | | |
240 | | // Formatted output, see the format_bytes() function in Support/Format.h. |
241 | | raw_ostream &operator<<(const FormattedBytes &); |
242 | | |
243 | | /// indent - Insert 'NumSpaces' spaces. |
244 | | raw_ostream &indent(unsigned NumSpaces); |
245 | | |
246 | | /// write_zeros - Insert 'NumZeros' nulls. |
247 | | raw_ostream &write_zeros(unsigned NumZeros); |
248 | | |
249 | | /// Changes the foreground color of text that will be output from this point |
250 | | /// forward. |
251 | | /// @param Color ANSI color to use, the special SAVEDCOLOR can be used to |
252 | | /// change only the bold attribute, and keep colors untouched |
253 | | /// @param Bold bold/brighter text, default false |
254 | | /// @param BG if true change the background, default: change foreground |
255 | | /// @returns itself so it can be used within << invocations |
256 | | virtual raw_ostream &changeColor(enum Colors Color, |
257 | | bool Bold = false, |
258 | 0 | bool BG = false) { |
259 | 0 | (void)Color; |
260 | 0 | (void)Bold; |
261 | 0 | (void)BG; |
262 | 0 | return *this; |
263 | 0 | } |
264 | | |
265 | | /// Resets the colors to terminal defaults. Call this when you are done |
266 | | /// outputting colored text, or before program exit. |
267 | 0 | virtual raw_ostream &resetColor() { return *this; } |
268 | | |
269 | | /// Reverses the foreground and background colors. |
270 | 0 | virtual raw_ostream &reverseColor() { return *this; } |
271 | | |
272 | | /// This function determines if this stream is connected to a "tty" or |
273 | | /// "console" window. That is, the output would be displayed to the user |
274 | | /// rather than being put on a pipe or stored in a file. |
275 | 2.25k | virtual bool is_displayed() const { return false; } |
276 | | |
277 | | /// This function determines if this stream is displayed and supports colors. |
278 | 8.61k | virtual bool has_colors() const { return is_displayed(); } |
279 | | |
280 | | //===--------------------------------------------------------------------===// |
281 | | // Subclass Interface |
282 | | //===--------------------------------------------------------------------===// |
283 | | |
284 | | private: |
285 | | /// The is the piece of the class that is implemented by subclasses. This |
286 | | /// writes the \p Size bytes starting at |
287 | | /// \p Ptr to the underlying stream. |
288 | | /// |
289 | | /// This function is guaranteed to only be called at a point at which it is |
290 | | /// safe for the subclass to install a new buffer via SetBuffer. |
291 | | /// |
292 | | /// \param Ptr The start of the data to be written. For buffered streams this |
293 | | /// is guaranteed to be the start of the buffer. |
294 | | /// |
295 | | /// \param Size The number of bytes to be written. |
296 | | /// |
297 | | /// \invariant { Size > 0 } |
298 | | virtual void write_impl(const char *Ptr, size_t Size) = 0; |
299 | | |
300 | | /// Return the current position within the stream, not counting the bytes |
301 | | /// currently in the buffer. |
302 | | virtual uint64_t current_pos() const = 0; |
303 | | |
304 | | protected: |
305 | | /// Use the provided buffer as the raw_ostream buffer. This is intended for |
306 | | /// use only by subclasses which can arrange for the output to go directly |
307 | | /// into the desired output buffer, instead of being copied on each flush. |
308 | 0 | void SetBuffer(char *BufferStart, size_t Size) { |
309 | 0 | SetBufferAndMode(BufferStart, Size, ExternalBuffer); |
310 | 0 | } |
311 | | |
312 | | /// Return an efficient buffer size for the underlying output mechanism. |
313 | | virtual size_t preferred_buffer_size() const; |
314 | | |
315 | | /// Return the beginning of the current stream buffer, or 0 if the stream is |
316 | | /// unbuffered. |
317 | 4.51M | const char *getBufferStart() const { return OutBufStart; } |
318 | | |
319 | | //===--------------------------------------------------------------------===// |
320 | | // Private Interface |
321 | | //===--------------------------------------------------------------------===// |
322 | | private: |
323 | | /// Install the given buffer and mode. |
324 | | void SetBufferAndMode(char *BufferStart, size_t Size, BufferKind Mode); |
325 | | |
326 | | /// Flush the current buffer, which is known to be non-empty. This outputs the |
327 | | /// currently buffered data and resets the buffer to empty. |
328 | | void flush_nonempty(); |
329 | | |
330 | | /// Copy data into the buffer. Size must not be greater than the number of |
331 | | /// unused bytes in the buffer. |
332 | | void copy_to_buffer(const char *Ptr, size_t Size); |
333 | | |
334 | | virtual void anchor(); |
335 | | }; |
336 | | |
337 | | /// An abstract base class for streams implementations that also support a |
338 | | /// pwrite operation. This is useful for code that can mostly stream out data, |
339 | | /// but needs to patch in a header that needs to know the output size. |
340 | | class raw_pwrite_stream : public raw_ostream { |
341 | | virtual void pwrite_impl(const char *Ptr, size_t Size, uint64_t Offset) = 0; |
342 | | void anchor() override; |
343 | | |
344 | | public: |
345 | | explicit raw_pwrite_stream(bool Unbuffered = false) |
346 | 89.0M | : raw_ostream(Unbuffered) {} |
347 | 14.0k | void pwrite(const char *Ptr, size_t Size, uint64_t Offset) { |
348 | | #ifndef NDEBUG |
349 | | uint64_t Pos = tell(); |
350 | | // /dev/null always reports a pos of 0, so we cannot perform this check |
351 | | // in that case. |
352 | | if (Pos) |
353 | | assert(Size + Offset <= Pos && "We don't support extending the stream"); |
354 | | #endif |
355 | | pwrite_impl(Ptr, Size, Offset); |
356 | 14.0k | } |
357 | | }; |
358 | | |
359 | | //===----------------------------------------------------------------------===// |
360 | | // File Output Streams |
361 | | //===----------------------------------------------------------------------===// |
362 | | |
363 | | /// A raw_ostream that writes to a file descriptor. |
364 | | /// |
365 | | class raw_fd_ostream : public raw_pwrite_stream { |
366 | | int FD; |
367 | | bool ShouldClose; |
368 | | |
369 | | bool SupportsSeeking; |
370 | | |
371 | | #ifdef _WIN32 |
372 | | /// True if this fd refers to a Windows console device. Mintty and other |
373 | | /// terminal emulators are TTYs, but they are not consoles. |
374 | | bool IsWindowsConsole = false; |
375 | | #endif |
376 | | |
377 | | std::error_code EC; |
378 | | |
379 | | uint64_t pos; |
380 | | |
381 | | /// See raw_ostream::write_impl. |
382 | | void write_impl(const char *Ptr, size_t Size) override; |
383 | | |
384 | | void pwrite_impl(const char *Ptr, size_t Size, uint64_t Offset) override; |
385 | | |
386 | | /// Return the current position within the stream, not counting the bytes |
387 | | /// currently in the buffer. |
388 | 7.68M | uint64_t current_pos() const override { return pos; } |
389 | | |
390 | | /// Determine an efficient buffer size. |
391 | | size_t preferred_buffer_size() const override; |
392 | | |
393 | | /// Set the flag indicating that an output error has been encountered. |
394 | 11 | void error_detected(std::error_code EC) { this->EC = EC; } |
395 | | |
396 | | void anchor() override; |
397 | | |
398 | | public: |
399 | | /// Open the specified file for writing. If an error occurs, information |
400 | | /// about the error is put into EC, and the stream should be immediately |
401 | | /// destroyed; |
402 | | /// \p Flags allows optional flags to control how the file will be opened. |
403 | | /// |
404 | | /// As a special case, if Filename is "-", then the stream will use |
405 | | /// STDOUT_FILENO instead of opening a file. This will not close the stdout |
406 | | /// descriptor. |
407 | | raw_fd_ostream(StringRef Filename, std::error_code &EC); |
408 | | raw_fd_ostream(StringRef Filename, std::error_code &EC, |
409 | | sys::fs::CreationDisposition Disp); |
410 | | raw_fd_ostream(StringRef Filename, std::error_code &EC, |
411 | | sys::fs::FileAccess Access); |
412 | | raw_fd_ostream(StringRef Filename, std::error_code &EC, |
413 | | sys::fs::OpenFlags Flags); |
414 | | raw_fd_ostream(StringRef Filename, std::error_code &EC, |
415 | | sys::fs::CreationDisposition Disp, sys::fs::FileAccess Access, |
416 | | sys::fs::OpenFlags Flags); |
417 | | |
418 | | /// FD is the file descriptor that this writes to. If ShouldClose is true, |
419 | | /// this closes the file when the stream is destroyed. If FD is for stdout or |
420 | | /// stderr, it will not be closed. |
421 | | raw_fd_ostream(int fd, bool shouldClose, bool unbuffered=false); |
422 | | |
423 | | ~raw_fd_ostream() override; |
424 | | |
425 | | /// Manually flush the stream and close the file. Note that this does not call |
426 | | /// fsync. |
427 | | void close(); |
428 | | |
429 | 25.7k | bool supportsSeeking() { return SupportsSeeking; } |
430 | | |
431 | | /// Flushes the stream and repositions the underlying file descriptor position |
432 | | /// to the offset specified from the beginning of the file. |
433 | | uint64_t seek(uint64_t off); |
434 | | |
435 | | raw_ostream &changeColor(enum Colors colors, bool bold=false, |
436 | | bool bg=false) override; |
437 | | raw_ostream &resetColor() override; |
438 | | |
439 | | raw_ostream &reverseColor() override; |
440 | | |
441 | | bool is_displayed() const override; |
442 | | |
443 | | bool has_colors() const override; |
444 | | |
445 | 5 | std::error_code error() const { return EC; } |
446 | | |
447 | | /// Return the value of the flag in this raw_fd_ostream indicating whether an |
448 | | /// output error has been encountered. |
449 | | /// This doesn't implicitly flush any pending output. Also, it doesn't |
450 | | /// guarantee to detect all errors unless the stream has been closed. |
451 | 249k | bool has_error() const { return bool(EC); } |
452 | | |
453 | | /// Set the flag read by has_error() to false. If the error flag is set at the |
454 | | /// time when this raw_ostream's destructor is called, report_fatal_error is |
455 | | /// called to report the error. Use clear_error() after handling the error to |
456 | | /// avoid this behavior. |
457 | | /// |
458 | | /// "Errors should never pass silently. |
459 | | /// Unless explicitly silenced." |
460 | | /// - from The Zen of Python, by Tim Peters |
461 | | /// |
462 | 10 | void clear_error() { EC = std::error_code(); } |
463 | | }; |
464 | | |
465 | | /// This returns a reference to a raw_ostream for standard output. Use it like: |
466 | | /// outs() << "foo" << "bar"; |
467 | | raw_ostream &outs(); |
468 | | |
469 | | /// This returns a reference to a raw_ostream for standard error. Use it like: |
470 | | /// errs() << "foo" << "bar"; |
471 | | raw_ostream &errs(); |
472 | | |
473 | | /// This returns a reference to a raw_ostream which simply discards output. |
474 | | raw_ostream &nulls(); |
475 | | |
476 | | //===----------------------------------------------------------------------===// |
477 | | // Output Stream Adaptors |
478 | | //===----------------------------------------------------------------------===// |
479 | | |
480 | | /// A raw_ostream that writes to an std::string. This is a simple adaptor |
481 | | /// class. This class does not encounter output errors. |
482 | | class raw_string_ostream : public raw_ostream { |
483 | | std::string &OS; |
484 | | |
485 | | /// See raw_ostream::write_impl. |
486 | | void write_impl(const char *Ptr, size_t Size) override; |
487 | | |
488 | | /// Return the current position within the stream, not counting the bytes |
489 | | /// currently in the buffer. |
490 | 41.1k | uint64_t current_pos() const override { return OS.size(); } |
491 | | |
492 | | public: |
493 | 7.03M | explicit raw_string_ostream(std::string &O) : OS(O) {} |
494 | | ~raw_string_ostream() override; |
495 | | |
496 | | /// Flushes the stream contents to the target string and returns the string's |
497 | | /// reference. |
498 | 5.89M | std::string& str() { |
499 | 5.89M | flush(); |
500 | 5.89M | return OS; |
501 | 5.89M | } |
502 | | }; |
503 | | |
504 | | /// A raw_ostream that writes to an SmallVector or SmallString. This is a |
505 | | /// simple adaptor class. This class does not encounter output errors. |
506 | | /// raw_svector_ostream operates without a buffer, delegating all memory |
507 | | /// management to the SmallString. Thus the SmallString is always up-to-date, |
508 | | /// may be used directly and there is no need to call flush(). |
509 | | class raw_svector_ostream : public raw_pwrite_stream { |
510 | | SmallVectorImpl<char> &OS; |
511 | | |
512 | | /// See raw_ostream::write_impl. |
513 | | void write_impl(const char *Ptr, size_t Size) override; |
514 | | |
515 | | void pwrite_impl(const char *Ptr, size_t Size, uint64_t Offset) override; |
516 | | |
517 | | /// Return the current position within the stream. |
518 | | uint64_t current_pos() const override; |
519 | | |
520 | | public: |
521 | | /// Construct a new raw_svector_ostream. |
522 | | /// |
523 | | /// \param O The vector to write to; this should generally have at least 128 |
524 | | /// bytes free to avoid any extraneous memory overhead. |
525 | 87.3M | explicit raw_svector_ostream(SmallVectorImpl<char> &O) : OS(O) { |
526 | 87.3M | SetUnbuffered(); |
527 | 87.3M | } |
528 | | |
529 | 87.3M | ~raw_svector_ostream() override = default; |
530 | | |
531 | | void flush() = delete; |
532 | | |
533 | | /// Return a StringRef for the vector contents. |
534 | 9.13M | StringRef str() { return StringRef(OS.data(), OS.size()); } |
535 | | }; |
536 | | |
537 | | /// A raw_ostream that discards all output. |
538 | | class raw_null_ostream : public raw_pwrite_stream { |
539 | | /// See raw_ostream::write_impl. |
540 | | void write_impl(const char *Ptr, size_t size) override; |
541 | | void pwrite_impl(const char *Ptr, size_t Size, uint64_t Offset) override; |
542 | | |
543 | | /// Return the current position within the stream, not counting the bytes |
544 | | /// currently in the buffer. |
545 | | uint64_t current_pos() const override; |
546 | | |
547 | | public: |
548 | 1.38M | explicit raw_null_ostream() = default; |
549 | | ~raw_null_ostream() override; |
550 | | }; |
551 | | |
552 | | class buffer_ostream : public raw_svector_ostream { |
553 | | raw_ostream &OS; |
554 | | SmallVector<char, 0> Buffer; |
555 | | |
556 | | virtual void anchor() override; |
557 | | |
558 | | public: |
559 | 4.23k | buffer_ostream(raw_ostream &OS) : raw_svector_ostream(Buffer), OS(OS) {} |
560 | 4.21k | ~buffer_ostream() override { OS << str(); } |
561 | | }; |
562 | | |
563 | | } // end namespace llvm |
564 | | |
565 | | #endif // LLVM_SUPPORT_RAW_OSTREAM_H |