Fix raw_fd_ostream::write_impl hang due to an infinite loop with large output

[gbreynoo]

Summary

On windows when raw_fd_ostream::write_impl calls write, a 32 bit input is required for character count. As a variable with size_t is used for this argument on x64 integral demotion occurs. In the case of large files an infinite loop follows.
See: https://bugs.llvm.org/show_bug.cgi?id=37926

This fix allows the output of files larger than previous int32 limit.

[zturner]

lib/Support/raw_ostream.cpp

617–618 ↗

(On Diff #154136)

Doesn't it actually require 32-bit unsigned input?

https://docs.microsoft.com/en-us/cpp/c-runtime-library/reference/write

int _write(
   int fd,
   const void *buffer,
   unsigned int count
);

[gbreynoo]

lib/Support/raw_ostream.cpp

617–618 ↗

(On Diff #154136)

I'll clarify this in the comment above.
Although the input type for _write is unsigned, the return type is signed ("-1" is returned in cases of an error). This is checked for in line 642. As the standard return of _write is to return how many bytes are written, in the case this value is larger than the signed max, the return value is a negative value. If the maximum unsigned value is written this will be -1 and indicate an error.

As the comment below states, windows _write is following POSIX as the behaviour for a write greater than SSIZE_MAX is implementation defined. I think it's best to keep to the portable behaviour below and not write anything windows specific to allow for a larger than SSIZE_MAX write.

[zturner]

Ok, makes sense. Lgtm then

[ruiu]

Do we have to save the number of system calls if we have really huge (>2GiB) buffer? I'm thinking if we can always use 1GiB as the maximum write size. That should make code simpler and easy to maintain.

[gbreynoo]

Made maximum write size portable as suggested by Rui

[gbreynoo]

ping

[zturner]

I think you addressed all the concerns and i lgtmed earlier anyway. Go for
it :) if there’s anything else you can follow up with another patch

llvm/trunk/lib/Support/raw_ostream.cpp

if (has_error())
     report_fatal_error("IO failure on output stream: " + error().message(),
                        /*GenCrashDiag=*/false);
 }
 
 void raw_fd_ostream::write_impl(const char *Ptr, size_t Size) {
   assert(FD >= 0 && "File already closed.");
   pos += Size;
 
-  // The maximum write size is limited to SSIZE_MAX because a write
-  // greater than SSIZE_MAX is implementation-defined in POSIX.
-  // Since SSIZE_MAX is not portable, we use SIZE_MAX >> 1 instead.
-  size_t MaxWriteSize = SIZE_MAX >> 1;
+  // The maximum write size is limited to INT32_MAX. A write
+  // greater than SSIZE_MAX is implementation-defined in POSIX,
+  // and Windows _write requires 32 bit input.
+  size_t MaxWriteSize = INT32_MAX;
 
 #if defined(__linux__)
   // It is observed that Linux returns EINVAL for a very large write (>2G).
   // Make it a reasonably small value.
   MaxWriteSize = 1024 * 1024 * 1024;
 #elif defined(_WIN32)
   // Writing a large size of output to Windows console returns ENOMEM. It seems
   // that, prior to Windows 8, WriteFile() is redirecting to WriteConsole(), and