[SystemZ][z/OS][Windows] Add new functions that set Text/Binary mode for Stdin and Stdout based on OpenFlags

[abhina.sreeskantharajan]

Summary

On Windows, we want to open a file in Binary mode if OF_CRLF bit is not set. On z/OS, we want to open a file in Binary mode if the OF_Text bit is not set.

This patch creates two new functions called ChangeStdinMode and ChangeStdoutMode which will take OpenFlags as an arg to determine which mode to set stdin and stdout to. This will enable patches like https://reviews.llvm.org/D100056 to not affect Windows when setting the OF_Text flag for raw_fd_streams.

[abhina.sreeskantharajan]

Fix syntax

[abhina.sreeskantharajan]

Add return value

[anirudhp]

llvm/lib/Support/raw_ostream.cpp

578

We are foregoing the check for the code returned by here. Is this okay? Should we be complete and assign it to EC? On unix this shouldn't matter because it just returns std::error_code (which is already what EC is). However, Windows seems to be different.

[abhina.sreeskantharajan]

llvm/lib/Support/raw_ostream.cpp

578

I think it's ok, we didn't check the return code in the old version either.

[Jonathan.Crowther]

llvm/lib/Support/MemoryBuffer.cpp

514–515

This will no longer call _setmode(_fileno(stdin), _O_BINARY); on Windows. Is that expected?

[abhina.sreeskantharajan]

llvm/lib/Support/MemoryBuffer.cpp

514–515

Some background info about the flags: I changed the behaviour of the Flags here https://reviews.llvm.org/D99426 and this patch is an extension of that.

On Windows, we only want to open a file in text mode if the OF_CRLF bit is set with OF_TextWithCRLF. If you see in Windows/Program.inc, we only check the OF_CRLF bit to determine whether to open the file as binary/text. In Unix/Program.inc, we use OF_Text bit to determine whether to open the file as binary/text.

[abhina.sreeskantharajan]

ping :)
Is there any concerns about this change on Windows? I think this should be NFC on Windows because we updated all the OF_Text to OF_TextWithCRLF in a previous commit.

[rnk]

lgtm

llvm/include/llvm/Support/Program.h

 #define LLVM_SUPPORT_PROGRAM_H
 
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/BitVector.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Config/llvm-config.h"
 #include "llvm/Support/ErrorOr.h"
+#include "llvm/Support/FileSystem.h"
 #include <chrono>
 #include <system_error>
 
 namespace llvm {
 namespace sys {
 
   /// This is the OS-specific separator for PATH like environment variables:
   // a colon on Unix or a semicolon on Windows.
#endif
   /// \param Paths optional list of paths to search for \p Name. If empty it
   ///   will use the system PATH environment instead.
   ///
   /// \returns The fully qualified path to the first \p Name in \p Paths if it
   ///   exists. \p Name if \p Name has slashes in it. Otherwise an error.
   ErrorOr<std::string>
   findProgramByName(StringRef Name, ArrayRef<StringRef> Paths = {});
 
+  // These functions change the specified standard stream (stdin or stdout) mode
+  // based on the Flags. They return errc::success if the specified stream was
+  // changed. Otherwise, a platform dependent error is returned.
+  std::error_code ChangeStdinMode(fs::OpenFlags Flags);
+  std::error_code ChangeStdoutMode(fs::OpenFlags Flags);
+
   // These functions change the specified standard stream (stdin or stdout) to
   // binary mode. They return errc::success if the specified stream
   // was changed. Otherwise a platform dependent error is returned.
   std::error_code ChangeStdinToBinary();
   std::error_code ChangeStdoutToBinary();
 
   /// This function executes the program using the arguments provided.  The
   /// invoked program will inherit the stdin, stdout, and stderr file

llvm/lib/Support/MemoryBuffer.cpp

MemoryBuffer::getOpenFileSlice(sys::fs::file_t FD, const Twine &Filename, uint64_t MapSize,
   return getOpenFileImpl<MemoryBuffer>(FD, Filename, -1, MapSize, Offset, false,
                                        IsVolatile);
 }
 
 ErrorOr<std::unique_ptr<MemoryBuffer>> MemoryBuffer::getSTDIN() {
   // Read in all of the data from stdin, we cannot mmap stdin.
   //
   // FIXME: That isn't necessarily true, we should try to mmap stdin and
   // fallback if it fails.
-  sys::ChangeStdinToBinary();
+  sys::ChangeStdinMode(sys::fs::OF_Text);
 
   return getMemoryBufferForStream(sys::fs::getStdinHandle(), "<stdin>");
 }
 
 ErrorOr<std::unique_ptr<MemoryBuffer>>
 MemoryBuffer::getFileAsStream(const Twine &Filename) {
   Expected<sys::fs::file_t> FDOrErr =
       sys::fs::openNativeFileForRead(Filename, sys::fs::OF_None);

llvm/lib/Support/Unix/Program.inc

#endif
     }
     // Return a special value to indicate that the process received an unhandled
     // signal during execution as opposed to failing to execute.
     WaitResult.ReturnCode = -2;
   }
   return WaitResult;
 }
 
+std::error_code llvm::sys::ChangeStdinMode(fs::OpenFlags Flags){
+  if (!(Flags & fs::OF_Text))
+    return ChangeStdinToBinary();
+  return std::error_code();
+}
+
+std::error_code llvm::sys::ChangeStdoutMode(fs::OpenFlags Flags){
+  if (!(Flags & fs::OF_Text))
+    return ChangeStdoutToBinary();
+  return std::error_code();
+}
+
 std::error_code llvm::sys::ChangeStdinToBinary() {
   // Do nothing, as Unix doesn't differentiate between text and binary.
   return std::error_code();
 }
 
 std::error_code llvm::sys::ChangeStdoutToBinary() {
   // Do nothing, as Unix doesn't differentiate between text and binary.
   return std::error_code();

llvm/lib/Support/Windows/Program.inc

ProcessInfo sys::Wait(const ProcessInfo &PI, unsigned SecondsToWait,
   else if (status & 0xFF)
     WaitResult.ReturnCode = status & 0x7FFFFFFF;
   else
     WaitResult.ReturnCode = 1;
 
   return WaitResult;
 }
 
+std::error_code llvm::sys::ChangeStdinMode(sys::fs::OpenFlags Flags){
+  if (!(Flags & fs::OF_CRLF))
+    ChangeStdinToBinary();
+}
+
+std::error_code llvm::sys::ChangeStdoutMode(sys::fs::OpenFlags Flags){
+  if (!(Flags & fs::OF_CRLF))
+    ChangeStdoutToBinary();
+}
+
 std::error_code sys::ChangeStdinToBinary() {
   int result = _setmode(_fileno(stdin), _O_BINARY);
   if (result == -1)
     return std::error_code(errno, std::generic_category());
   return std::error_code();
 }
 
 std::error_code sys::ChangeStdoutToBinary() {

llvm/lib/Support/raw_ostream.cpp

static int getFD(StringRef Filename, std::error_code &EC,
                  sys::fs::OpenFlags Flags) {
   assert((Access & sys::fs::FA_Write) &&
          "Cannot make a raw_ostream from a read-only descriptor!");
 
   // Handle "-" as stdout. Note that when we do this, we consider ourself
   // the owner of stdout and may set the "binary" flag globally based on Flags.
   if (Filename == "-") {
     EC = std::error_code();
-    // If user requested binary then put stdout into binary mode if
-    // possible.
-    if (!(Flags & sys::fs::OF_Text))
-      sys::ChangeStdoutToBinary();
+    // Change stdout's text/binary mode based on the Flags.
+    sys::ChangeStdoutMode(Flags);
     return STDOUT_FILENO;
   }
 
   int FD;
   if (Access & sys::fs::FA_Read)
     EC = sys::fs::openFileForReadWrite(Filename, FD, Disp, Flags);
   else
     EC = sys::fs::openFileForWrite(Filename, FD, Disp, Flags);