15#include "llvm/Config/config.h"
32#if defined(HAVE_FCNTL_H)
36#if defined(HAVE_UNISTD_H)
40#if defined(__CYGWIN__)
47# define STDIN_FILENO 0
50# define STDOUT_FILENO 1
53# define STDERR_FILENO 2
79 assert(OutBufCur == OutBufStart &&
80 "raw_ostream destructor called with non-empty buffer!");
82 if (BufferMode == BufferKind::InternalBuffer)
83 delete [] OutBufStart;
107void raw_ostream::SetBufferAndMode(
char *BufferStart,
size_t Size,
109 assert(((Mode == BufferKind::Unbuffered && !BufferStart &&
Size == 0) ||
110 (Mode != BufferKind::Unbuffered && BufferStart &&
Size != 0)) &&
111 "stream must be unbuffered or have at least one byte");
116 if (BufferMode == BufferKind::InternalBuffer)
117 delete [] OutBufStart;
118 OutBufStart = BufferStart;
119 OutBufEnd = OutBufStart+
Size;
120 OutBufCur = OutBufStart;
123 assert(OutBufStart <= OutBufEnd &&
"Invalid size!");
170 bool UseHexEscapes) {
171 for (
unsigned char c : Str) {
174 *
this <<
'\\' <<
'\\';
177 *
this <<
'\\' <<
't';
180 *
this <<
'\\' <<
'n';
183 *
this <<
'\\' <<
'"';
193 *
this <<
'\\' <<
'x';
194 *
this << hexdigit((c >> 4) & 0xF);
195 *
this << hexdigit((c >> 0) & 0xF);
199 *
this <<
char(
'0' + ((c >> 6) & 7));
200 *
this <<
char(
'0' + ((c >> 3) & 7));
201 *
this <<
char(
'0' + ((c >> 0) & 7));
219void raw_ostream::flush_nonempty() {
220 assert(OutBufCur > OutBufStart &&
"Invalid call to flush_nonempty.");
221 size_t Length = OutBufCur - OutBufStart;
222 OutBufCur = OutBufStart;
223 flush_tied_then_write(OutBufStart,
Length);
230 if (BufferMode == BufferKind::Unbuffered) {
231 flush_tied_then_write(
reinterpret_cast<char *
>(&
C), 1);
250 if (BufferMode == BufferKind::Unbuffered) {
251 flush_tied_then_write(
Ptr,
Size);
259 size_t NumBytes = OutBufEnd - OutBufCur;
265 assert(NumBytes != 0 &&
"undefined behavior");
266 size_t BytesToWrite =
Size - (
Size % NumBytes);
267 flush_tied_then_write(
Ptr, BytesToWrite);
268 size_t BytesRemaining =
Size - BytesToWrite;
269 if (BytesRemaining >
size_t(OutBufEnd - OutBufCur)) {
271 return write(
Ptr + BytesToWrite, BytesRemaining);
273 copy_to_buffer(
Ptr + BytesToWrite, BytesRemaining);
279 copy_to_buffer(
Ptr, NumBytes);
289void raw_ostream::copy_to_buffer(
const char *
Ptr,
size_t Size) {
290 assert(
Size <=
size_t(OutBufEnd - OutBufCur) &&
"Buffer overrun!");
295 case 4: OutBufCur[3] =
Ptr[3]; [[fallthrough]];
296 case 3: OutBufCur[2] =
Ptr[2]; [[fallthrough]];
297 case 2: OutBufCur[1] =
Ptr[1]; [[fallthrough]];
298 case 1: OutBufCur[0] =
Ptr[0]; [[fallthrough]];
308void raw_ostream::flush_tied_then_write(
const char *
Ptr,
size_t Size) {
318 size_t NextBufferSize = 127;
319 size_t BufferBytesLeft = OutBufEnd - OutBufCur;
320 if (BufferBytesLeft > 3) {
321 size_t BytesUsed = Fmt.
print(OutBufCur, BufferBytesLeft);
324 if (BytesUsed <= BufferBytesLeft) {
325 OutBufCur += BytesUsed;
331 NextBufferSize = BytesUsed;
340 V.resize(NextBufferSize);
343 size_t BytesUsed = Fmt.
print(V.data(), NextBufferSize);
346 if (BytesUsed <= NextBufferSize)
347 return write(V.data(), BytesUsed);
350 assert(BytesUsed > NextBufferSize &&
"Didn't grow buffer!?");
351 NextBufferSize = BytesUsed;
361 unsigned LeftIndent = 0;
362 unsigned RightIndent = 0;
363 const ssize_t Difference = FS.Width - FS.Str.size();
364 if (Difference > 0) {
365 switch (FS.Justify) {
369 RightIndent = Difference;
372 LeftIndent = Difference;
375 LeftIndent = Difference / 2;
376 RightIndent = Difference - LeftIndent;
389 if (FN.Upper && FN.HexPrefix)
391 else if (FN.Upper && !FN.HexPrefix)
393 else if (!FN.Upper && FN.HexPrefix)
402 if (Buffer.
size() < FN.Width)
410 if (FB.Bytes.
empty())
413 size_t LineIndex = 0;
414 auto Bytes = FB.Bytes;
415 const size_t Size = Bytes.size();
418 if (FB.FirstByteOffset) {
422 size_t Lines =
Size / FB.NumPerLine;
423 uint64_t MaxOffset = *FB.FirstByteOffset + Lines * FB.NumPerLine;
427 OffsetWidth = std::max<uint64_t>(4,
llvm::alignTo(Power, 4) / 4);
431 unsigned NumByteGroups =
432 alignTo(FB.NumPerLine, FB.ByteGroupSize) / FB.ByteGroupSize;
433 unsigned BlockCharWidth = FB.NumPerLine * 2 + NumByteGroups - 1;
435 while (!Bytes.empty()) {
438 if (FB.FirstByteOffset) {
444 auto Line = Bytes.take_front(FB.NumPerLine);
446 size_t CharsPrinted = 0;
448 for (
size_t I = 0;
I < Line.size(); ++
I, CharsPrinted += 2) {
449 if (
I && (
I % FB.ByteGroupSize) == 0) {
459 assert(BlockCharWidth >= CharsPrinted);
460 indent(BlockCharWidth - CharsPrinted + 2);
464 for (uint8_t Byte : Line) {
466 *this << static_cast<char>(Byte);
473 Bytes = Bytes.drop_front(Line.size());
474 LineIndex += Line.size();
475 if (LineIndex <
Size)
483 static const char Chars[] = {
C,
C,
C,
C,
C,
C,
C,
C,
C,
C,
C,
C,
C,
C,
C,
C,
484 C,
C,
C,
C,
C,
C,
C,
C,
C,
C,
C,
C,
C,
C,
C,
C,
485 C,
C,
C,
C,
C,
C,
C,
C,
C,
C,
C,
C,
C,
C,
C,
C,
486 C,
C,
C,
C,
C,
C,
C,
C,
C,
C,
C,
C,
C,
C,
C,
C,
487 C,
C,
C,
C,
C,
C,
C,
C,
C,
C,
C,
C,
C,
C,
C,
C};
490 if (NumChars < std::size(Chars))
491 return OS.
write(Chars, NumChars);
494 unsigned NumToWrite = std::min(NumChars, (
unsigned)std::size(Chars) - 1);
496 NumChars -= NumToWrite;
503 return write_padding<' '>(*
this, NumSpaces);
508 return write_padding<'\0'>(*
this, NumZeros);
511bool raw_ostream::prepare_colors() {
528 if (!prepare_colors())
531 const char *colorcode =
536 write(colorcode, strlen(colorcode));
541 if (!prepare_colors())
545 write(colorcode, strlen(colorcode));
550 if (!prepare_colors())
554 write(colorcode, strlen(colorcode));
558void raw_ostream::anchor() {}
576 "Cannot make a raw_ostream from a read-only descriptor!");
580 if (Filename ==
"-") {
581 EC = std::error_code();
584 return STDOUT_FILENO;
599 :
raw_fd_ostream(Filename, EC, sys::fs::CD_CreateAlways, sys::fs::FA_Write,
604 :
raw_fd_ostream(Filename, EC, Disp, sys::fs::FA_Write, sys::fs::OF_None) {}
613 :
raw_fd_ostream(Filename, EC, sys::fs::CD_CreateAlways, sys::fs::FA_Write,
640 if (FD <= STDERR_FILENO)
646 ::GetFileType((HANDLE)::_get_osfhandle(fd)) == FILE_TYPE_CHAR;
650 off_t loc = ::lseek(FD, 0, SEEK_CUR);
652 std::error_code EC = status(FD,
Status);
656 SupportsSeeking = !EC && IsRegularFile;
658 SupportsSeeking = !EC && loc != (off_t)-1;
660 if (!SupportsSeeking)
712 if (
auto EC = sys::windows::UTF8ToUTF16(
Data, WideText))
717 size_t MaxWriteSize = WideText.
size();
719 MaxWriteSize = 32767;
721 size_t WCharsWritten = 0;
723 size_t WCharsToWrite =
724 std::min(MaxWriteSize, WideText.
size() - WCharsWritten);
725 DWORD ActuallyWritten;
727 ::WriteConsoleW((HANDLE)::_get_osfhandle(FD), &WideText[WCharsWritten],
728 WCharsToWrite, &ActuallyWritten,
737 WCharsWritten += ActuallyWritten;
738 }
while (WCharsWritten != WideText.
size());
743void raw_fd_ostream::write_impl(
const char *
Ptr,
size_t Size) {
744 assert(FD >= 0 &&
"File already closed.");
750 if (IsWindowsConsole)
758 size_t MaxWriteSize = INT32_MAX;
760#if defined(__linux__)
763 MaxWriteSize = 1024 * 1024 * 1024;
767 size_t ChunkSize = std::min(
Size, MaxWriteSize);
779 if (errno == EINTR || errno == EAGAIN
781 || errno == EWOULDBLOCK
788 DWORD WinLastError = GetLastError();
789 if (WinLastError == ERROR_BROKEN_PIPE ||
790 (WinLastError == ERROR_NO_DATA && errno == EINVAL)) {
791 llvm::sys::CallOneShotPipeSignalHandler();
818 assert(SupportsSeeking &&
"Stream does not support seeking!");
821 pos = ::_lseeki64(FD, off, SEEK_SET);
823 pos = ::lseek(FD, off, SEEK_SET);
830void raw_fd_ostream::pwrite_impl(
const char *
Ptr,
size_t Size,
838size_t raw_fd_ostream::preferred_buffer_size()
const {
845 if (IsWindowsConsole)
849 assert(FD >= 0 &&
"File not yet open!");
851 if (fstat(FD, &statbuf) != 0)
860 return statbuf.st_blksize;
889void raw_fd_ostream::anchor() {}
921 sys::fs::FA_Write | sys::fs::FA_Read,
928 EC = std::make_error_code(std::errc::invalid_argument);
949void raw_string_ostream::write_impl(
const char *
Ptr,
size_t Size) {
957uint64_t raw_svector_ostream::current_pos()
const {
return OS.size(); }
959void raw_svector_ostream::write_impl(
const char *
Ptr,
size_t Size) {
963void raw_svector_ostream::pwrite_impl(
const char *
Ptr,
size_t Size,
981void raw_null_ostream::write_impl(
const char *
Ptr,
size_t Size) {
984uint64_t raw_null_ostream::current_pos()
const {
988void raw_null_ostream::pwrite_impl(
const char *
Ptr,
size_t Size,
991void raw_pwrite_stream::anchor() {}
993void buffer_ostream::anchor() {}
995void buffer_unique_ostream::anchor() {}
999 if (OutputFileName ==
"-")
1000 return Write(
outs());
1002 if (OutputFileName ==
"/dev/null") {
1015 if (
Error E = Write(Out)) {
1016 if (
Error DiscardError = Temp->discard())
1017 return joinErrors(std::move(
E), std::move(DiscardError));
1022 return Temp->keep(OutputFileName);
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
#define LLVM_UNLIKELY(EXPR)
Returns the sub type a function will return at a given Idx Should correspond to the result type of an ExtractValue instruction executed with just that one unsigned Idx
Provides a library for accessing information about this process and other processes on the operating ...
static cl::opt< RegAllocEvictionAdvisorAnalysis::AdvisorMode > Mode("regalloc-enable-advisor", cl::Hidden, cl::init(RegAllocEvictionAdvisorAnalysis::AdvisorMode::Default), cl::desc("Enable regalloc advisor mode"), cl::values(clEnumValN(RegAllocEvictionAdvisorAnalysis::AdvisorMode::Default, "default", "Default"), clEnumValN(RegAllocEvictionAdvisorAnalysis::AdvisorMode::Release, "release", "precompiled"), clEnumValN(RegAllocEvictionAdvisorAnalysis::AdvisorMode::Development, "development", "for training")))
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
std::pair< llvm::MachO::Target, std::string > UUID
bool empty() const
empty - Check if the array is empty.
std::chrono::milliseconds getDuration() const
Lightweight error class with error context and mandatory checking.
Tagged union holding either a T or a Error.
Error takeError()
Take ownership of the stored error.
SmallString - A SmallString is just a SmallVector with methods and accessors that make it work better...
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
StringRef - Represent a constant reference to a string, i.e.
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
A raw_ostream that writes to a file descriptor.
bool is_displayed() const override
This function determines if this stream is connected to a "tty" or "console" window.
bool has_error() const
Return the value of the flag in this raw_fd_ostream indicating whether an output error has been encou...
std::error_code error() const
void close()
Manually flush the stream and close the file.
void inc_pos(uint64_t Delta)
Expected< sys::fs::FileLocker > lock()
Locks the underlying file.
~raw_fd_ostream() override
bool has_colors() const override
This function determines if this stream is displayed and supports colors.
bool isRegularFile() const
uint64_t seek(uint64_t off)
Flushes the stream and repositions the underlying file descriptor position to the offset specified fr...
int get_fd() const
Return the file descriptor.
Expected< sys::fs::FileLocker > tryLockFor(Duration const &Timeout)
Tries to lock the underlying file within the specified period.
raw_fd_ostream(StringRef Filename, std::error_code &EC)
Open the specified file for writing.
void error_detected(std::error_code EC)
Set the flag indicating that an output error has been encountered.
static bool classof(const raw_ostream *OS)
Check if OS is a pointer of type raw_fd_stream*.
raw_fd_stream(StringRef Filename, std::error_code &EC)
Open the specified file for reading/writing/seeking.
ssize_t read(char *Ptr, size_t Size)
This reads the Size bytes into a buffer pointed by Ptr.
A raw_ostream that discards all output.
~raw_null_ostream() override
This class implements an extremely fast bulk output stream that can only output to a stream.
static constexpr Colors YELLOW
raw_ostream & write_zeros(unsigned NumZeros)
write_zeros - Insert 'NumZeros' nulls.
uint64_t tell() const
tell - Return the current offset with the file.
void SetBufferSize(size_t Size)
Set the stream to be buffered, using the specified buffer size.
static constexpr Colors CYAN
virtual raw_ostream & changeColor(enum Colors Color, bool Bold=false, bool BG=false)
Changes the foreground color of text that will be output from this point forward.
raw_ostream & write_hex(unsigned long long N)
Output N in hexadecimal, without any prefix or padding.
virtual raw_ostream & resetColor()
Resets the colors to terminal defaults.
raw_ostream & write_uuid(const uuid_t UUID)
raw_ostream & operator<<(char C)
raw_ostream & write_escaped(StringRef Str, bool UseHexEscapes=false)
Output Str, turning '\', '\t', ' ', '"', and anything that doesn't satisfy llvm::isPrint into an esca...
virtual raw_ostream & reverseColor()
Reverses the foreground and background colors.
static constexpr Colors BLUE
virtual size_t preferred_buffer_size() const
Return an efficient buffer size for the underlying output mechanism.
raw_ostream & write(unsigned char C)
void SetUnbuffered()
Set the stream to be unbuffered.
virtual bool is_displayed() const
This function determines if this stream is connected to a "tty" or "console" window.
raw_ostream & indent(unsigned NumSpaces)
indent - Insert 'NumSpaces' spaces.
static constexpr Colors RESET
uint8_t[16] uuid_t
Output a formatted UUID with dash separators.
static constexpr Colors MAGENTA
virtual void enable_colors(bool enable)
static constexpr Colors SAVEDCOLOR
size_t GetNumBytesInBuffer() const
static constexpr Colors BLACK
static constexpr Colors GREEN
static constexpr Colors RED
OStreamKind get_kind() const
void SetBuffered()
Set the stream to be buffered, with an automatically determined buffer size.
static constexpr Colors WHITE
An abstract base class for streams implementations that also support a pwrite operation.
A raw_ostream that writes to an SmallVector or SmallString.
static std::error_code SafelyCloseFileDescriptor(int FD)
static const char * OutputColor(char c, bool bold, bool bg)
This function returns the colorcode escape sequences.
static bool FileDescriptorIsDisplayed(int fd)
This function determines if the given file descriptor is connected to a "tty" or "console" window.
static const char * OutputBold(bool bg)
Same as OutputColor, but only enables the bold attribute.
static bool FileDescriptorHasColors(int fd)
This function determines if the given file descriptor is displayd and supports colors.
static const char * OutputReverse()
This function returns the escape sequence to reverse forground and background colors.
static const char * ResetColor()
Resets the terminals colors, or returns an escape sequence to do so.
static bool ColorNeedsFlush()
Whether changing colors requires the output to be flushed.
RAII class that facilitates file locking.
static Expected< TempFile > create(const Twine &Model, unsigned Mode=all_read|all_write, OpenFlags ExtraFlags=OF_None)
This creates a temporary file with createUniqueFile and schedules it for deletion with sys::RemoveFil...
Represents the result of a call to sys::fs::status().
@ C
The default llvm calling convention, compatible with C.
std::error_code openFileForReadWrite(const Twine &Name, int &ResultFD, CreationDisposition Disp, OpenFlags Flags, unsigned Mode=0666)
Opens the file with the given name in a write-only or read-write mode, returning its open file descri...
std::error_code tryLockFile(int FD, std::chrono::milliseconds Timeout=std::chrono::milliseconds(0))
Try to locks the file during the specified time.
std::error_code lockFile(int FD)
Lock the file.
std::error_code openFileForWrite(const Twine &Name, int &ResultFD, CreationDisposition Disp=CD_CreateAlways, OpenFlags Flags=OF_None, unsigned Mode=0666)
Opens the file with the given name in a write-only or read-write mode, returning its open file descri...
std::error_code ChangeStdoutMode(fs::OpenFlags Flags)
This is an optimization pass for GlobalISel generic memory operations.
Error createFileError(const Twine &F, Error E)
Concatenate a source file path and/or name with an Error.
unsigned Log2_64_Ceil(uint64_t Value)
Return the ceil log base 2 of the specified value, 64 if the value is zero.
raw_fd_ostream & outs()
This returns a reference to a raw_fd_ostream for standard output.
Error write(MCStreamer &Out, ArrayRef< std::string > Inputs, bool ContinueOnCuIndexOverflow)
bool RunningWindows8OrGreater()
Determines if the program is running on Windows 8 or newer.
void write_integer(raw_ostream &S, unsigned int N, size_t MinDigits, IntegerStyle Style)
Error joinErrors(Error E1, Error E2)
Concatenate errors.
void report_fatal_error(Error Err, bool gen_crash_diag=true)
Report a serious error, calling any installed error handler.
Error writeToOutput(StringRef OutputFileName, std::function< Error(raw_ostream &)> Write)
This helper creates an output stream and then passes it to Write.
raw_ostream & nulls()
This returns a reference to a raw_ostream which simply discards output.
format_object< Ts... > format(const char *Fmt, const Ts &... Vals)
These are helper functions used to produce formatted output.
raw_fd_ostream & errs()
This returns a reference to a raw_ostream for standard error.
uint64_t alignTo(uint64_t Size, Align A)
Returns a multiple of A needed to store Size bytes.
void write_hex(raw_ostream &S, uint64_t N, HexPrintStyle Style, std::optional< size_t > Width=std::nullopt)
void write_double(raw_ostream &S, double D, FloatStyle Style, std::optional< size_t > Precision=std::nullopt)
Error errorCodeToError(std::error_code EC)
Helper for converting an std::error_code to a Error.
static int getFD(StringRef Filename, std::error_code &EC, sys::fs::CreationDisposition Disp, sys::fs::FileAccess Access, sys::fs::OpenFlags Flags)
static raw_ostream & write_padding(raw_ostream &OS, unsigned NumChars)