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

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

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

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;
 
+#ifdef _WIN64
+  // Windows _write() requires unsigned 32 bit input for 'count',
+  // however to follow POSIX a value above unsigned max should not be used.
+  // Win64 size_t is 64 bit so int 32 max is used below.
+  size_t MaxWriteSize = _I32_MAX;
+#else
   // 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;
+#endif
 
 #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