[SystemZ][z/OS][Windows] Add new OF_TextWithCRLF flag and use this flag instead of OF_Text

[abhina.sreeskantharajan]

Summary

Problem:
On SystemZ we need to open text files in text mode. On Windows, files opened in text mode adds a CRLF '\r\n' which may not be desirable.

Solution:
This patch adds two new flags

• OF_CRLF which indicates that CRLF translation is used.
• OF_TextWithCRLF = OF_Text | OF_CRLF indicates that the file is text and uses CRLF translation.

Developers should now use either the OF_Text or OF_TextWithCRLF for text files and OF_None for binary files. If the developer doesn't want carriage returns on Windows, they should use OF_Text, if they do want carriage returns on Windows, they should use OF_TextWithCRLF.

So this is the behaviour per platform with my patch:

z/OS:
OF_None: open in binary mode
OF_Text : open in text mode
OF_TextWithCRLF: open in text mode

Windows:
OF_None: open file with no carriage return
OF_Text: open file with no carriage return
OF_TextWithCRLF: open file with carriage return

The Major change is in llvm/lib/Support/Windows/Path.inc to only set text mode if the OF_CRLF is set.

if (Flags & OF_CRLF)
  CrtOpenFlags |= _O_TEXT;

These following files are the ones that still use OF_Text which I left unchanged. I modified all these except raw_ostream.cpp in recent patches so I know these were previously in Binary mode on Windows.
./llvm/lib/Support/raw_ostream.cpp
./llvm/lib/TableGen/Main.cpp
./llvm/tools/dsymutil/DwarfLinkerForBinary.cpp
./llvm/unittests/Support/Path.cpp
./clang/lib/StaticAnalyzer/Core/HTMLDiagnostics.cpp
./clang/lib/Frontend/CompilerInstance.cpp
./clang/lib/Driver/Driver.cpp
./clang/lib/Driver/ToolChains/Clang.cpp

[MaskRay]

This touches a lot of files. I am a bit worried that it would not be easy for a contributor to know OF_TextWithCRLF is needed to make SystemZ happy.

On SystemZ we need to open text files in text mode,

Why can't it be served without CRLF translation?

[abhina.sreeskantharajan]

In D99426#2653725, @MaskRay wrote:

This touches a lot of files. I am a bit worried that it would not be easy for a contributor to know OF_TextWithCRLF is needed to make SystemZ happy.

On SystemZ we need to open text files in text mode,

Why can't it be served without CRLF translation?

So this is a quick summary of the problem we're facing:
On SystemZ, we can accept both OF_Text or OF_TextWithCRLF, it makes no difference. However, there are many text files that are marked as binary/OF_None to suppress CRLF translation on Windows. (e.g. patches like this one https://reviews.llvm.org/rGe78a7a0ecddc747129512fabf4836e22d1805f00). On SystemZ we need the text files to be marked as text and have made patches in the past to do so (e.g. https://reviews.llvm.org/D67696). These efforts are conflicting with each other, so Reid suggested this solution where we create a new flag that will set text mode and turn on CRLF translation on Windows platform. Then we will be able to mark all remaining text files with OF_Text and not turn on CRLF translation for Windows.

I agree this patch is touching a lot of files, I can maybe do the opposite and create a flag called OF_TextWithoutCRLF. I'm open to any new solutions to this problem.

[MaskRay]

In D99426#2653869, @abhina.sreeskantharajan wrote:

In D99426#2653725, @MaskRay wrote:

This touches a lot of files. I am a bit worried that it would not be easy for a contributor to know OF_TextWithCRLF is needed to make SystemZ happy.

On SystemZ we need to open text files in text mode,

Why can't it be served without CRLF translation?

So this is a quick summary of the problem we're facing:
On SystemZ, we can accept both OF_Text or OF_TextWithCRLF, it makes no difference. However, there are many text files that are marked as binary/OF_None to suppress CRLF translation on Windows. (e.g. patches like this one https://reviews.llvm.org/rGe78a7a0ecddc747129512fabf4836e22d1805f00). On SystemZ we need the text files to be marked as text and have made patches in the past to do so (e.g. https://reviews.llvm.org/D67696). These efforts are conflicting with each other, so Reid suggested this solution where we create a new flag that will set text mode and turn on CRLF translation on Windows platform. Then we will be able to mark all remaining text files with OF_Text and not turn on CRLF translation for Windows.

I agree this patch is touching a lot of files, I can maybe do the opposite and create a flag called OF_TextWithoutCRLF. I'm open to any new solutions to this problem.

Hmm. I am still confused after seeting rGe78a7a0ecddc747129512fabf4836e22d1805f00 (does it imply that using OF_None on Windows is fine?)
If OF_None is used on SystemZ, does that regress functionality?

[abhina.sreeskantharajan]

In D99426#2653949, @MaskRay wrote:

In D99426#2653869, @abhina.sreeskantharajan wrote:

In D99426#2653725, @MaskRay wrote:

This touches a lot of files. I am a bit worried that it would not be easy for a contributor to know OF_TextWithCRLF is needed to make SystemZ happy.

On SystemZ we need to open text files in text mode,

Why can't it be served without CRLF translation?

So this is a quick summary of the problem we're facing:
On SystemZ, we can accept both OF_Text or OF_TextWithCRLF, it makes no difference. However, there are many text files that are marked as binary/OF_None to suppress CRLF translation on Windows. (e.g. patches like this one https://reviews.llvm.org/rGe78a7a0ecddc747129512fabf4836e22d1805f00). On SystemZ we need the text files to be marked as text and have made patches in the past to do so (e.g. https://reviews.llvm.org/D67696). These efforts are conflicting with each other, so Reid suggested this solution where we create a new flag that will set text mode and turn on CRLF translation on Windows platform. Then we will be able to mark all remaining text files with OF_Text and not turn on CRLF translation for Windows.

I agree this patch is touching a lot of files, I can maybe do the opposite and create a flag called OF_TextWithoutCRLF. I'm open to any new solutions to this problem.

Hmm. I am still confused after seeting rGe78a7a0ecddc747129512fabf4836e22d1805f00 (does it imply that using OF_None on Windows is fine?)
If OF_None is used on SystemZ, does that regress functionality?

On Windows, OF_None suppresses CRLF translation and OF_Text will allow CRLF translation. On SystemZ it does regress functionality by causing file encoding issues. SystemZ uses a file's text/binary mode to determine whether to perform translation to the system encoding EBCDIC if needed. (On binary files, no translation should be performed)

[rnk]

In D99426#2653725, @MaskRay wrote:

This touches a lot of files. I am a bit worried that it would not be easy for a contributor to know OF_TextWithCRLF is needed to make SystemZ happy.

Right, we need to separate text-ness for System/Z EBCDIC re-encoding from Windows CRLF translation. I think it's best to have a separate, positive CRLF bit, and to make that spelling longer than OF_Text. I think, in general, more problems are caused by extra unintended CRLF than by missing carriage returns.

[MaskRay]

In D99426#2656217, @rnk wrote:

In D99426#2653725, @MaskRay wrote:

This touches a lot of files. I am a bit worried that it would not be easy for a contributor to know OF_TextWithCRLF is needed to make SystemZ happy.

Right, we need to separate text-ness for System/Z EBCDIC re-encoding from Windows CRLF translation. I think it's best to have a separate, positive CRLF bit, and to make that spelling longer than OF_Text. I think, in general, more problems are caused by extra unintended CRLF than by missing carriage returns.

OK.

OF_CRLF which indicates that CRLF translation is used.
OF_TextWithCRLF = OF_Text | OF_CRLF indicates that the file is text and uses CRLF translation.

My confusion came from I do not know what "CRLF translation" in the description refers to. So it seems like EBCDIC->ASCII translation for CRLF? I thought it was related to Windows.

The current comment in the source code should be clarified too:

/// The file should be opened with CRLF translation on platforms that
/// make this distinction.
OF_CRLF = 2,
OF_TextWithCRLF = 3,

[abhina.sreeskantharajan]

Rebase + I updated the comments in FileSystem.h to be a bit more descriptive.

[abhina.sreeskantharajan]

In D99426#2656582, @MaskRay wrote:

In D99426#2656217, @rnk wrote:

In D99426#2653725, @MaskRay wrote:

This touches a lot of files. I am a bit worried that it would not be easy for a contributor to know OF_TextWithCRLF is needed to make SystemZ happy.

Right, we need to separate text-ness for System/Z EBCDIC re-encoding from Windows CRLF translation. I think it's best to have a separate, positive CRLF bit, and to make that spelling longer than OF_Text. I think, in general, more problems are caused by extra unintended CRLF than by missing carriage returns.

OK.

OF_CRLF which indicates that CRLF translation is used.
OF_TextWithCRLF = OF_Text | OF_CRLF indicates that the file is text and uses CRLF translation.

My confusion came from I do not know what "CRLF translation" in the description refers to. So it seems like EBCDIC->ASCII translation for CRLF? I thought it was related to Windows.

The current comment in the source code should be clarified too:

/// The file should be opened with CRLF translation on platforms that
/// make this distinction.
OF_CRLF = 2,
OF_TextWithCRLF = 3,

Sorry for causing confusion. CRLF in text files is a Windows-only problem, it doesn't affect z/OS. On z/OS we only need text files to be marked accurately as text. I updated the description and comments in FileSystem.h to be more clear.

[abhina.sreeskantharajan]

mention OF_CRLF is Windows-only

[abhina.sreeskantharajan]

Set OF_Text for llvm/tools/dsymutil/DwarfLinkerForBinary.cpp instead of OF_TextWithCRLF. This was also another file I recently changed to text from binary.

[amccarth]

I like the composability enabled by making OF_Text and OF_CRLF independent. I wonder, though, if there's a chokepoint where we could/should assert if the caller uses OF_CRLF without OF_Text, which would be suspicious.

I'm not concerned by the number of files touched, since it's mostly a mechanical refactor. If anyone's worried that the mechanical changes obscure the behavior change, this _could_ be broken into an NFC refactor patch for the renaming followed by a patch that implements the behavioral distinction. But I'm not going to insist on that.

llvm/include/llvm/Support/FileSystem.h

745–746

Don't be shy to give examples in the comments, as they can illuminate the motivation for the design.

... on platforms, like SystemZ, that distinguish between text and binary files.

757

Nit: If it were me, I'd put the OF_Text | OF_CRLF directly in the code (in place of the 3) instead of in the comment.

llvm/lib/Support/Windows/Path.inc

1086–1087

I assume it would be weird to set OF_CRLF without also setting OF_Text, so this change seems right for correctness. But maybe this Windows-only code would better express the intent if it were written:

if (Flags & (OF_CRLF | OF_Text))

Another idea would be to assert if OF_CRLF is set but OF_Text is not.

Or maybe it's fine as it is.

[abhina.sreeskantharajan]

llvm/lib/Support/Windows/Path.inc

1086–1087

I chose to create OF_CRLF flag because I only want Windows to turn on text mode for OF_TextWithCRLF and not OF_Text.
This solution would return true even if Flags was just OF_Text.

if (Flags & (OF_CRLF | OF_Text))

I think adding an assertion here would be a good idea.

[abhina.sreeskantharajan]

Specified z/OS in FileSystem.h comments, added an assertion in Window's Path.inc

[abhina.sreeskantharajan]

llvm/include/llvm/Support/FileSystem.h

757

Thanks, your solution will also prevent future errors if there is any renumbering

[abhina.sreeskantharajan]

@MaskRay is there still any confusion about the problem this patch is trying to solve and concerns about the renaming?

[MaskRay]

/// The file should be opened in text mode on platforms like z/OS that make
/// this distinction.
OF_Text = 1,
F_Text = 1, // For compatibility

/// The file should use a carriage linefeed '\r\n'.
/// Only makes a difference on windows.
OF_CRLF = 2,

/// The file should be opened in text mode and use a carriage linefeed '\r\n'
/// on platforms that make this distinction.
OF_TextWithCRLF = OF_Text | OF_CRLF,

OF_TextWithCRLF needs to say what platforms make a difference.

Can you mention in the description for Windows and z/OS, how these flags make a difference, and how developers should use these flags for portability?
It's still a bit unclear to me.

e.g. when I need to use OF_CRLR instead of OF_Text?

[abhina.sreeskantharajan]

Update comment in FileSystem.h for OF_TextWithCRLF

[abhina.sreeskantharajan]

In D99426#2664841, @MaskRay wrote:

/// The file should be opened in text mode on platforms like z/OS that make
/// this distinction.
OF_Text = 1,
F_Text = 1, // For compatibility

/// The file should use a carriage linefeed '\r\n'.
/// Only makes a difference on windows.
OF_CRLF = 2,

/// The file should be opened in text mode and use a carriage linefeed '\r\n'
/// on platforms that make this distinction.
OF_TextWithCRLF = OF_Text | OF_CRLF,

OF_TextWithCRLF needs to say what platforms make a difference.

Can you mention in the description for Windows and z/OS, how these flags make a difference, and how developers should use these flags for portability?
It's still a bit unclear to me.

e.g. when I need to use OF_CRLR instead of OF_Text?

So developers should use either the OF_Text or OF_TextWithCRLF for text files and OF_None for binary files. If the developer doesn't want carriage returns on Windows, they should use OF_Text, if they do want carriage returns on Windows, they should use OF_TextWithCRLF.

So this is the behaviour per platform with my patch:

z/OS:
OF_None: open in binary mode
OF_Text : open in text mode
OF_TextWithCRLF: open in text mode

Windows:
OF_None: open file with no carriage return
OF_Text: open file with no carriage return
OF_TextWithCRLF: open file with carriage return

This is the old behaviour for comparison:
z/OS:
OF_None: open in binary mode
OF_Text: open in text mode

Windows:
OF_None: open file with no carriage return
OF_Text: open file with carriage return

[MaskRay]

In D99426#2664883, @abhina.sreeskantharajan wrote:

In D99426#2664841, @MaskRay wrote:

/// The file should be opened in text mode on platforms like z/OS that make
/// this distinction.
OF_Text = 1,
F_Text = 1, // For compatibility

/// The file should use a carriage linefeed '\r\n'.
/// Only makes a difference on windows.
OF_CRLF = 2,

/// The file should be opened in text mode and use a carriage linefeed '\r\n'
/// on platforms that make this distinction.
OF_TextWithCRLF = OF_Text | OF_CRLF,

OF_TextWithCRLF needs to say what platforms make a difference.

Can you mention in the description for Windows and z/OS, how these flags make a difference, and how developers should use these flags for portability?
It's still a bit unclear to me.

e.g. when I need to use OF_CRLR instead of OF_Text?

So developers should use either the OF_Text or OF_TextWithCRLF for text files and OF_None for binary files. If the developer doesn't want carriage returns on Windows, they should use OF_Text, if they do want carriage returns on Windows, they should use OF_TextWithCRLF.

So this is the behaviour per platform with my patch:

z/OS:
OF_None: open in binary mode
OF_Text : open in text mode
OF_TextWithCRLF: open in text mode

Windows:
OF_None: open file with no carriage return
OF_Text: open file with no carriage return
OF_TextWithCRLF: open file with carriage return

This is the old behaviour for comparison:
z/OS:
OF_None: open in binary mode
OF_Text: open in text mode

Windows:
OF_None: open file with no carriage return
OF_Text: open file with carriage return

Thanks for the information. LG.
Please update the summary to include the information.

If the patch also affects SystemZ, please adjust the [Windows] tag in the subject.

llvm/include/llvm/Support/FileSystem.h

752

Am I right that this is an implementation detail and should not be used directly by users (use OF_TextWithCRLF instead)?
If so, please add a comment.

771

windows -> Windows

[aganea]

I am still concerned by the fact that this patch doesn't fix the issue mentionned in https://reviews.llvm.org/D96363#2650460
Was the intention to fix that issue? Will the fix be done in a subsequent patch?

llvm/lib/Support/Windows/Path.inc

1087

s/,/ &&/

[abhina.sreeskantharajan]

In D99426#2665361, @aganea wrote:

I am still concerned by the fact that this patch doesn't fix the issue mentionned in https://reviews.llvm.org/D96363#2650460
Was the intention to fix that issue? Will the fix be done in a subsequent patch?

I was fairly confident that if https://reviews.llvm.org/D96363 was the patch that was causing the issue for you, then this patch would have fixed the problem. I've already reverted the change in clang/lib/Frontend/Rewrite/FrontendActions.cpp and you mentioned that reverting the change in clang/lib/Driver/Driver.cpp didn't resolve the issue either. This patch should turn off CRLF translation in the remaining 2 files modified in that patch (Driver.cpp and DwarfLinkerForBinary.cpp). Since this doesn't seem to fix your problem, I'll need to do further investigation into which patch actually does cause the issue.

[abhina.sreeskantharajan]

Updated comments and assertion

[aganea]

In D99426#2666141, @abhina.sreeskantharajan wrote:

In D99426#2665361, @aganea wrote:

I am still concerned by the fact that this patch doesn't fix the issue mentionned in https://reviews.llvm.org/D96363#2650460
Was the intention to fix that issue? Will the fix be done in a subsequent patch?

I was fairly confident that if https://reviews.llvm.org/D96363 was the patch that was causing the issue for you

That is the case! I've confirmed that git checkout fdb640ea30d416368b76b68b106deda580c6aced~1 && ninja clang -C build generates a clang-cl.exe that works with my above test case. git revert fdb640ea30d416368b76b68b106deda580c6aced locally over ToT fixes the issue.

[abhina.sreeskantharajan]

In D99426#2666341, @aganea wrote:

In D99426#2666141, @abhina.sreeskantharajan wrote:

In D99426#2665361, @aganea wrote:

I am still concerned by the fact that this patch doesn't fix the issue mentionned in https://reviews.llvm.org/D96363#2650460
Was the intention to fix that issue? Will the fix be done in a subsequent patch?

I was fairly confident that if https://reviews.llvm.org/D96363 was the patch that was causing the issue for you

That is the case! I've confirmed that git checkout fdb640ea30d416368b76b68b106deda580c6aced~1 && ninja clang -C build generates a clang-cl.exe that works with my above test case. git revert fdb640ea30d416368b76b68b106deda580c6aced locally over ToT fixes the issue.

After scratching my head, I realized that I accidentally changed another function to Binary in clang/lib/Frontend/Rewrite/FrontendActions.cpp so that change was never properly reverted. I fixed this in https://reviews.llvm.org/D99837. Hopefully, this will fix your issue. Apologies for the confusion on my side.

[abhina.sreeskantharajan]

Is there any more feedback on this patch?

[yroux]

Hi,

Sorry I'm bit lost in the various patches proposed to fix the issue introduced by https://reviews.llvm.org/D97785
My understanding is that this is missing one to fix our Windows on ARM bots (broken for more than 2 weeks now)
So it'd be great to have it applied

[abhina.sreeskantharajan]

In D99426#2670552, @yroux wrote:

Hi,

Sorry I'm bit lost in the various patches proposed to fix the issue introduced by https://reviews.llvm.org/D97785
My understanding is that this is missing one to fix our Windows on ARM bots (broken for more than 2 weeks now)
So it'd be great to have it applied

I've committed this and it looks like the bot is back to green :) https://lab.llvm.org/buildbot/#/builders/65/builds/1400. Sorry for the delayed fix

[yroux]

I've committed this and it looks like the bot is back to green :) https://lab.llvm.org/buildbot/#/builders/65/builds/1400. Sorry for the delayed fix

Great, thanks a lot

clang-tools-extra/clang-move/tool/ClangMove.cpp

 using namespace clang;
 using namespace llvm;
 
 namespace {
 
 std::error_code CreateNewFile(const llvm::Twine &path) {
   int fd = 0;
   if (std::error_code ec = llvm::sys::fs::openFileForWrite(
-          path, fd, llvm::sys::fs::CD_CreateAlways, llvm::sys::fs::OF_Text))
+          path, fd, llvm::sys::fs::CD_CreateAlways,
+          llvm::sys::fs::OF_TextWithCRLF))
     return ec;
 
   return llvm::sys::Process::SafelyCloseFileDescriptor(fd);
 }
 
 cl::OptionCategory ClangMoveCategory("clang-move options");
 
 cl::list<std::string> Names("names", cl::CommaSeparated,

clang-tools-extra/modularize/ModuleAssistant.cpp

if ((HeaderDirectory.size() == 0) && (HeaderPrefix.size() != 0)) {
     llvm::sys::path::native(FilePath);
   } else {
     FilePath = ModuleMapPath;
     llvm::sys::path::native(FilePath);
   }
 
   // Set up module map output file.
   std::error_code EC;
-  llvm::ToolOutputFile Out(FilePath, EC, llvm::sys::fs::OF_Text);
+  llvm::ToolOutputFile Out(FilePath, EC, llvm::sys::fs::OF_TextWithCRLF);
   if (EC) {
     llvm::errs() << Argv0 << ": error opening " << FilePath << ":"
                  << EC.message() << "\n";
     return false;
   }
 
   // Get output stream from tool output buffer/manager.
   llvm::raw_fd_ostream &OS = Out.os();

clang-tools-extra/pp-trace/PPTrace.cpp

else
       error(toString(Pat.takeError()));
   }
 
   // Create the tool and run the compilation.
   clang::tooling::ClangTool Tool(OptionsParser->getCompilations(),
                                  OptionsParser->getSourcePathList());
 
   std::error_code EC;
-  llvm::ToolOutputFile Out(OutputFileName, EC, llvm::sys::fs::OF_Text);
+  llvm::ToolOutputFile Out(OutputFileName, EC, llvm::sys::fs::OF_TextWithCRLF);
   if (EC)
     error(EC.message());
   PPTraceFrontendActionFactory Factory(Filters, Out.os());
   int HadErrors = Tool.run(&Factory);
 
   // If we had errors, exit early.
   if (HadErrors)
     return HadErrors;
 
   Out.keep();
 
   return 0;
 }

clang/lib/ARCMigrate/PlistReporter.cpp

for (ArrayRef<StoredDiagnostic>::iterator
     for (StoredDiagnostic::range_iterator
            RI = D.range_begin(), RE = D.range_end(); RI != RE; ++RI) {
       AddFID(FM, Fids, SM, RI->getBegin());
       AddFID(FM, Fids, SM, RI->getEnd());
     }
   }
 
   std::error_code EC;
-  llvm::raw_fd_ostream o(outPath, EC, llvm::sys::fs::OF_Text);
+  llvm::raw_fd_ostream o(outPath, EC, llvm::sys::fs::OF_TextWithCRLF);
   if (EC) {
     llvm::errs() << "error: could not create file: " << outPath << '\n';
     return;
   }
 
   EmitPlistHeader(o);
 
   // Write the root object: a <dict> containing...

clang/lib/Driver/Compilation.cpp

if ((getDriver().CCPrintOptions ||
 
     // Follow gcc implementation of CC_PRINT_OPTIONS; we could also cache the
     // output stream.
     if (getDriver().CCPrintOptions &&
         !getDriver().CCPrintOptionsFilename.empty()) {
       std::error_code EC;
       OwnedStream.reset(new llvm::raw_fd_ostream(
           getDriver().CCPrintOptionsFilename.c_str(), EC,
-          llvm::sys::fs::OF_Append | llvm::sys::fs::OF_Text));
+          llvm::sys::fs::OF_Append | llvm::sys::fs::OF_TextWithCRLF));
       if (EC) {
         getDriver().Diag(diag::err_drv_cc_print_options_failure)
             << EC.message();
         FailingCommand = &C;
         return 1;
       }
       OS = OwnedStream.get();
     }

clang/lib/Driver/ToolChains/Clang.cpp

void Clang::DumpCompilationDatabase(Compilation &C, StringRef Filename,
   if (C.getArgs().hasArg(options::OPT__HASH_HASH_HASH))
     return;
 
   using llvm::yaml::escape;
   const Driver &D = getToolChain().getDriver();
 
   if (!CompilationDatabase) {
     std::error_code EC;
-    auto File = std::make_unique<llvm::raw_fd_ostream>(Filename, EC,
-                                                        llvm::sys::fs::OF_Text);
+    auto File = std::make_unique<llvm::raw_fd_ostream>(
+        Filename, EC, llvm::sys::fs::OF_TextWithCRLF);
     if (EC) {
       D.Diag(clang::diag::err_drv_compilationdatabase) << Filename
                                                        << EC.message();
       return;
     }
     CompilationDatabase = std::move(File);
   }
   auto &CDB = *CompilationDatabase;

clang/lib/Frontend/CompilerInstance.cpp

static void SetUpDiagnosticLog(DiagnosticOptions *DiagOpts,
                                DiagnosticsEngine &Diags) {
   std::error_code EC;
   std::unique_ptr<raw_ostream> StreamOwner;
   raw_ostream *OS = &llvm::errs();
   if (DiagOpts->DiagnosticLogFile != "-") {
     // Create the output stream.
     auto FileOS = std::make_unique<llvm::raw_fd_ostream>(
         DiagOpts->DiagnosticLogFile, EC,
-        llvm::sys::fs::OF_Append | llvm::sys::fs::OF_Text);
+        llvm::sys::fs::OF_Append | llvm::sys::fs::OF_TextWithCRLF);
     if (EC) {
       Diags.Report(diag::warn_fe_cc_log_diagnostics_failure)
           << DiagOpts->DiagnosticLogFile << EC.message();
     } else {
       FileOS->SetUnbuffered();
       OS = FileOS.get();
       StreamOwner = std::move(FileOS);
     }
if (UseTemporary) {
     // directory, but can write to the file.
   }
 
   if (!OS) {
     OSFile = OutputPath;
     std::error_code EC;
     OS.reset(new llvm::raw_fd_ostream(
         *OSFile, EC,
-        (Binary ? llvm::sys::fs::OF_None : llvm::sys::fs::OF_Text)));
+        (Binary ? llvm::sys::fs::OF_None : llvm::sys::fs::OF_TextWithCRLF)));
     if (EC)
       return llvm::errorCodeToError(EC);
   }
 
   // Make sure the out stream file gets removed if we crash.
   if (RemoveFileOnSignal)
     llvm::sys::RemoveFileOnSignal(*OSFile);
 
if (hasFileManager()) {
       OS << '\n';
     }
     llvm::PrintStatistics(OS);
   }
   StringRef StatsFile = getFrontendOpts().StatsFile;
   if (!StatsFile.empty()) {
     std::error_code EC;
     auto StatS = std::make_unique<llvm::raw_fd_ostream>(
-        StatsFile, EC, llvm::sys::fs::OF_Text);
+        StatsFile, EC, llvm::sys::fs::OF_TextWithCRLF);
     if (EC) {
       getDiagnostics().Report(diag::warn_fe_unable_to_open_stats_file)
           << StatsFile << EC.message();
     } else {
       llvm::PrintStatisticsJSON(*StatS);
     }
   }
 

clang/lib/Frontend/DependencyFile.cpp

 
 void DependencyFileGenerator::outputDependencyFile(DiagnosticsEngine &Diags) {
   if (SeenMissingHeader) {
     llvm::sys::fs::remove(OutputFile);
     return;
   }
 
   std::error_code EC;
-  llvm::raw_fd_ostream OS(OutputFile, EC, llvm::sys::fs::OF_Text);
+  llvm::raw_fd_ostream OS(OutputFile, EC, llvm::sys::fs::OF_TextWithCRLF);
   if (EC) {
     Diags.Report(diag::err_fe_error_opening) << OutputFile << EC.message();
     return;
   }
 
   outputDependencyFile(OS);
 }
 

clang/lib/Frontend/DependencyGraph.cpp

 DependencyGraphCallback::writeNodeReference(raw_ostream &OS,
                                             const FileEntry *Node) {
   OS << "header_" << Node->getUID();
   return OS;
 }
 
 void DependencyGraphCallback::OutputGraphFile() {
   std::error_code EC;
-  llvm::raw_fd_ostream OS(OutputFile, EC, llvm::sys::fs::OF_Text);
+  llvm::raw_fd_ostream OS(OutputFile, EC, llvm::sys::fs::OF_TextWithCRLF);
   if (EC) {
     PP->getDiagnostics().Report(diag::err_fe_error_opening) << OutputFile
                                                             << EC.message();
     return;
   }
 
   OS << "digraph \"dependencies\" {\n";
 

clang/lib/Frontend/FrontendActions.cpp

 
 void DumpModuleInfoAction::ExecuteAction() {
   // Set up the output file.
   std::unique_ptr<llvm::raw_fd_ostream> OutFile;
   StringRef OutputFileName = getCompilerInstance().getFrontendOpts().OutputFile;
   if (!OutputFileName.empty() && OutputFileName != "-") {
     std::error_code EC;
     OutFile.reset(new llvm::raw_fd_ostream(OutputFileName.str(), EC,
-                                           llvm::sys::fs::OF_Text));
+                                           llvm::sys::fs::OF_TextWithCRLF));
   }
   llvm::raw_ostream &Out = OutFile.get()? *OutFile.get() : llvm::outs();
 
   Out << "Information for module file '" << getCurrentFile() << "':\n";
   auto &FileMgr = getCompilerInstance().getFileManager();
   auto Buffer = FileMgr.getBufferForFile(getCurrentFile());
   StringRef Magic = (*Buffer)->getMemBufferRef().getBuffer();
   bool IsRaw = (Magic.size() >= 4 && Magic[0] == 'C' && Magic[1] == 'P' &&

clang/lib/Frontend/HeaderIncludeGen.cpp

if (MSStyle) {
     }
   }
 
   // Open the output file, if used.
   if (!OutputPath.empty()) {
     std::error_code EC;
     llvm::raw_fd_ostream *OS = new llvm::raw_fd_ostream(
         OutputPath.str(), EC,
-        llvm::sys::fs::OF_Append | llvm::sys::fs::OF_Text);
+        llvm::sys::fs::OF_Append | llvm::sys::fs::OF_TextWithCRLF);
     if (EC) {
       PP.getDiagnostics().Report(clang::diag::warn_fe_cc_print_header_failure)
           << EC.message();
       delete OS;
     } else {
       OS->SetUnbuffered();
       OutputFile = OS;
       OwnsOutputFile = true;

clang/lib/Frontend/ModuleDependencyCollector.cpp

void ModuleDependencyCollector::writeFileMap() {
 
   // Do not rely on real path names when executing the crash reproducer scripts
   // since we only want to actually use the files we have on the VFS cache.
   VFSWriter.setUseExternalNames(false);
 
   std::error_code EC;
   SmallString<256> YAMLPath = VFSDir;
   llvm::sys::path::append(YAMLPath, "vfs.yaml");
-  llvm::raw_fd_ostream OS(YAMLPath, EC, llvm::sys::fs::OF_Text);
+  llvm::raw_fd_ostream OS(YAMLPath, EC, llvm::sys::fs::OF_TextWithCRLF);
   if (EC) {
     HasErrors = true;
     return;
   }
   VFSWriter.write(OS);
 }
 
 std::error_code ModuleDependencyCollector::copyToRoot(StringRef Src,

clang/lib/Serialization/ASTReader.cpp

bool ASTReader::isGlobalIndexUnavailable() const {
   return PP.getLangOpts().Modules && UseGlobalIndex &&
          !hasGlobalIndex() && TriedLoadingGlobalIndex;
 }
 
 static void updateModuleTimestamp(ModuleFile &MF) {
   // Overwrite the timestamp file contents so that file's mtime changes.
   std::string TimestampFilename = MF.getTimestampFilename();
   std::error_code EC;
-  llvm::raw_fd_ostream OS(TimestampFilename, EC, llvm::sys::fs::OF_Text);
+  llvm::raw_fd_ostream OS(TimestampFilename, EC,
+                          llvm::sys::fs::OF_TextWithCRLF);
   if (EC)
     return;
   OS << "Timestamp file\n";
   OS.close();
   OS.clear_error(); // Avoid triggering a fatal error.
 }
 
 /// Given a cursor at the start of an AST file, scan ahead and drop the

clang/lib/StaticAnalyzer/Core/PlistDiagnostics.cpp

while (!WorkList.empty()) {
           WorkList.push_back(&Macro->subPieces);
         }
       }
     }
   }
 
   // Open the file.
   std::error_code EC;
-  llvm::raw_fd_ostream o(OutputFile, EC, llvm::sys::fs::OF_Text);
+  llvm::raw_fd_ostream o(OutputFile, EC, llvm::sys::fs::OF_TextWithCRLF);
   if (EC) {
     llvm::errs() << "warning: could not create file: " << EC.message() << '\n';
     return;
   }
 
   EmitPlistHeader(o);
 
   // Write the root object: a <dict> containing...

clang/lib/StaticAnalyzer/Core/SarifDiagnostics.cpp

 void SarifDiagnostics::FlushDiagnosticsImpl(
     std::vector<const PathDiagnostic *> &Diags, FilesMade *) {
   // We currently overwrite the file if it already exists. However, it may be
   // useful to add a feature someday that allows the user to append a run to an
   // existing SARIF file. One danger from that approach is that the size of the
   // file can become large very quickly, so decoding into JSON to append a run
   // may be an expensive operation.
   std::error_code EC;
-  llvm::raw_fd_ostream OS(OutputFile, EC, llvm::sys::fs::OF_Text);
+  llvm::raw_fd_ostream OS(OutputFile, EC, llvm::sys::fs::OF_TextWithCRLF);
   if (EC) {
     llvm::errs() << "warning: could not create file: " << EC.message() << '\n';
     return;
   }
   json::Object Sarif{
       {"$schema",
        "https://raw.githubusercontent.com/oasis-tcs/sarif-spec/master/Schemata/sarif-schema-2.1.0.json"},
       {"version", "2.1.0"},
       {"runs", json::Array{createRun(LO, Diags)}}};
   OS << llvm::formatv("{0:2}\n", json::Value(std::move(Sarif)));
 }

clang/tools/clang-refactor/ClangRefactor.cpp

for (const auto &File : Files) {
                                                 Changes, Spec);
       if (!Result) {
         llvm::errs() << toString(Result.takeError());
         return true;
       }
 
       if (opts::Inplace) {
         std::error_code EC;
-        llvm::raw_fd_ostream OS(File, EC, llvm::sys::fs::OF_Text);
+        llvm::raw_fd_ostream OS(File, EC, llvm::sys::fs::OF_TextWithCRLF);
         if (EC) {
           llvm::errs() << EC.message() << "\n";
           return true;
         }
         OS << *Result;
         continue;
       }
 

clang/tools/driver/cc1as_main.cpp

 getOutputStream(StringRef Path, DiagnosticsEngine &Diags, bool Binary) {
   // Make sure that the Out file gets unlinked from the disk if we get a
   // SIGINT.
   if (Path != "-")
     sys::RemoveFileOnSignal(Path);
 
   std::error_code EC;
   auto Out = std::make_unique<raw_fd_ostream>(
-      Path, EC, (Binary ? sys::fs::OF_None : sys::fs::OF_Text));
+      Path, EC, (Binary ? sys::fs::OF_None : sys::fs::OF_TextWithCRLF));
   if (EC) {
     Diags.Report(diag::err_fe_unable_to_open_output) << Path << EC.message();
     return nullptr;
   }
 
   return Out;
 }
 

flang/lib/Frontend/CompilerInstance.cpp

std::unique_ptr<llvm::raw_pwrite_stream> CompilerInstance::CreateOutputFile(
     llvm::StringRef outputFilePath, std::error_code &error, bool binary) {
 
   // Creates the file descriptor for the output file
   std::unique_ptr<llvm::raw_fd_ostream> os;
   std::string osFile;
   if (!os) {
     osFile = outputFilePath;
     os.reset(new llvm::raw_fd_ostream(osFile, error,
-        (binary ? llvm::sys::fs::OF_None : llvm::sys::fs::OF_Text)));
+        (binary ? llvm::sys::fs::OF_None : llvm::sys::fs::OF_TextWithCRLF)));
     if (error)
       return nullptr;
   }
 
   // Return the stream corresponding to the output file.
   // For non-seekable streams, wrap it in llvm::buffer_ostream first.
   if (!binary || os->supportsSeeking())
     return std::move(os);

lld/COFF/DriverUtils.cpp

static std::string createManifestXmlWithInternalMt(StringRef defaultXml) {
 
   return std::string(merger.getMergedManifest().get()->getBuffer());
 }
 
 static std::string createManifestXmlWithExternalMt(StringRef defaultXml) {
   // Create the default manifest file as a temporary file.
   TemporaryFile Default("defaultxml", "manifest");
   std::error_code ec;
-  raw_fd_ostream os(Default.path, ec, sys::fs::OF_Text);
+  raw_fd_ostream os(Default.path, ec, sys::fs::OF_TextWithCRLF);
   if (ec)
     fatal("failed to open " + Default.path + ": " + ec.message());
   os << defaultXml;
   os.close();
 
   // Merge user-supplied manifests if they are given.  Since libxml2 is not
   // enabled, we must shell out to Microsoft's mt.exe tool.
   TemporaryFile user("user", "manifest");
std::unique_ptr<MemoryBuffer> createManifestRes() {
   return std::move(res);
 }
 
 void createSideBySideManifest() {
   std::string path = std::string(config->manifestFile);
   if (path == "")
     path = config->outputFile + ".manifest";
   std::error_code ec;
-  raw_fd_ostream out(path, ec, sys::fs::OF_Text);
+  raw_fd_ostream out(path, ec, sys::fs::OF_TextWithCRLF);
   if (ec)
     fatal("failed to create manifest: " + ec.message());
   out << createManifestXml();
 }
 
 // Parse a string in the form of
 // "<name>[=<internalname>][,@ordinal[,NONAME]][,DATA][,PRIVATE]"
 // or "<name>=<dllname>.<name>".

lld/lib/ReaderWriter/YAML/ReaderWriterYAML.cpp

 
 class Writer : public lld::Writer {
 public:
   Writer(const LinkingContext &context) : _ctx(context) {}
 
   llvm::Error writeFile(const lld::File &file, StringRef outPath) override {
     // Create stream to path.
     std::error_code ec;
-    llvm::raw_fd_ostream out(outPath, ec, llvm::sys::fs::OF_Text);
+    llvm::raw_fd_ostream out(outPath, ec, llvm::sys::fs::OF_TextWithCRLF);
     if (ec)
       return llvm::errorCodeToError(ec);
 
     // Create yaml Output writer, using yaml options for context.
     YamlContext yamlContext;
     yamlContext._ctx = &_ctx;
     yamlContext._registry = &_ctx.registry();
     llvm::yaml::Output yout(out, &yamlContext);

lldb/include/lldb/Utility/ReproducerProvider.h

 
 /// The recorder is a small object handed out by a provider to record data. It
 /// is commonly used in combination with a MultiProvider which is meant to
 /// record information for multiple instances of the same source of data.
 class AbstractRecorder {
 protected:
   AbstractRecorder(const FileSpec &filename, std::error_code &ec)
       : m_filename(filename.GetFilename().GetStringRef()),
-        m_os(filename.GetPath(), ec, llvm::sys::fs::OF_Text), m_record(true) {}
+        m_os(filename.GetPath(), ec, llvm::sys::fs::OF_TextWithCRLF),
+        m_record(true) {}
 
 public:
   const FileSpec &GetFilename() { return m_filename; }
 
   void Stop() {
     assert(m_record);
     m_record = false;
   }
public:
   void SetDirectory(std::string directory) {
     m_directory = std::move(directory);
   }
   llvm::StringRef GetDirectory() { return m_directory; }
 
   void Keep() override {
     FileSpec file = this->GetRoot().CopyByAppendingPathComponent(T::Info::file);
     std::error_code ec;
-    llvm::raw_fd_ostream os(file.GetPath(), ec, llvm::sys::fs::OF_Text);
+    llvm::raw_fd_ostream os(file.GetPath(), ec, llvm::sys::fs::OF_TextWithCRLF);
     if (ec)
       return;
     os << m_directory << "\n";
   }
 
 protected:
   std::string m_directory;
 };
void Keep() override {
     std::vector<std::string> files;
     for (auto &recorder : m_recorders) {
       recorder->Stop();
       files.push_back(recorder->GetFilename().GetPath());
     }
 
     FileSpec file = this->GetRoot().CopyByAppendingPathComponent(V::Info::file);
     std::error_code ec;
-    llvm::raw_fd_ostream os(file.GetPath(), ec, llvm::sys::fs::OF_Text);
+    llvm::raw_fd_ostream os(file.GetPath(), ec, llvm::sys::fs::OF_TextWithCRLF);
     if (ec)
       return;
     llvm::yaml::Output yout(os);
     yout << files;
   }
 
   void Discard() override { m_recorders.clear(); }
 

lldb/source/Utility/GDBRemote.cpp

 void GDBRemoteProvider::Keep() {
   std::vector<std::string> files;
   for (auto &recorder : m_packet_recorders) {
     files.push_back(recorder->GetFilename().GetPath());
   }
 
   FileSpec file = GetRoot().CopyByAppendingPathComponent(Info::file);
   std::error_code ec;
-  llvm::raw_fd_ostream os(file.GetPath(), ec, llvm::sys::fs::OF_Text);
+  llvm::raw_fd_ostream os(file.GetPath(), ec, llvm::sys::fs::OF_TextWithCRLF);
   if (ec)
     return;
   yaml::Output yout(os);
   yout << files;
 }
 
 void GDBRemoteProvider::Discard() { m_packet_recorders.clear(); }
 
void PacketRecorder::Record(const GDBRemotePacket &packet) {
   yout << const_cast<GDBRemotePacket &>(packet);
   m_os.flush();
 }
 
 llvm::raw_ostream *GDBRemoteProvider::GetHistoryStream() {
   FileSpec history_file = GetRoot().CopyByAppendingPathComponent(Info::file);
 
   std::error_code EC;
-  m_stream_up = std::make_unique<raw_fd_ostream>(history_file.GetPath(), EC,
-                                                 sys::fs::OpenFlags::OF_Text);
+  m_stream_up = std::make_unique<raw_fd_ostream>(
+      history_file.GetPath(), EC, sys::fs::OpenFlags::OF_TextWithCRLF);
   return m_stream_up.get();
 }
 
 char GDBRemoteProvider::ID = 0;
 const char *GDBRemoteProvider::Info::file = "gdb-remote.yaml";
 const char *GDBRemoteProvider::Info::name = "gdb-remote";

lldb/source/Utility/ReproducerProvider.cpp

YamlRecorder::Create(const FileSpec &filename) {
   if (ec)
     return llvm::errorCodeToError(ec);
   return std::move(recorder);
 }
 
 void VersionProvider::Keep() {
   FileSpec file = GetRoot().CopyByAppendingPathComponent(Info::file);
   std::error_code ec;
-  llvm::raw_fd_ostream os(file.GetPath(), ec, llvm::sys::fs::OF_Text);
+  llvm::raw_fd_ostream os(file.GetPath(), ec, llvm::sys::fs::OF_TextWithCRLF);
   if (ec)
     return;
   os << m_version << "\n";
 }
 
 FlushingFileCollector::FlushingFileCollector(llvm::StringRef files_path,
                                              llvm::StringRef dirs_path,
                                              std::error_code &ec) {
void ProcessInfoProvider::Keep() {
   std::vector<std::string> files;
   for (auto &recorder : m_process_info_recorders) {
     recorder->Stop();
     files.push_back(recorder->GetFilename().GetPath());
   }
 
   FileSpec file = GetRoot().CopyByAppendingPathComponent(Info::file);
   std::error_code ec;
-  llvm::raw_fd_ostream os(file.GetPath(), ec, llvm::sys::fs::OF_Text);
+  llvm::raw_fd_ostream os(file.GetPath(), ec, llvm::sys::fs::OF_TextWithCRLF);
   if (ec)
     return;
   llvm::yaml::Output yout(os);
   yout << files;
 }
 
 void ProcessInfoProvider::Discard() { m_process_info_recorders.clear(); }
 
if (!uuid || (!module_file && !symbol_file))
     return;
   m_symbol_files.emplace_back(uuid->GetAsString(), module_file.GetPath(),
                               symbol_file.GetPath());
 }
 
 void SymbolFileProvider::Keep() {
   FileSpec file = this->GetRoot().CopyByAppendingPathComponent(Info::file);
   std::error_code ec;
-  llvm::raw_fd_ostream os(file.GetPath(), ec, llvm::sys::fs::OF_Text);
+  llvm::raw_fd_ostream os(file.GetPath(), ec, llvm::sys::fs::OF_TextWithCRLF);
   if (ec)
     return;
 
   // Remove duplicates.
   llvm::sort(m_symbol_files.begin(), m_symbol_files.end());
   m_symbol_files.erase(
       std::unique(m_symbol_files.begin(), m_symbol_files.end()),
       m_symbol_files.end());

lldb/tools/lldb-server/LLDBServerUtilities.cpp

 using namespace lldb;
 using namespace lldb_private::lldb_server;
 using namespace llvm;
 
 static std::shared_ptr<raw_ostream> GetLogStream(StringRef log_file) {
   if (!log_file.empty()) {
     std::error_code EC;
     std::shared_ptr<raw_ostream> stream_sp = std::make_shared<raw_fd_ostream>(
-        log_file, EC, sys::fs::OF_Text | sys::fs::OF_Append);
+        log_file, EC, sys::fs::OF_TextWithCRLF | sys::fs::OF_Append);
     if (!EC)
       return stream_sp;
     errs() << llvm::formatv(
         "Failed to open log file `{0}`: {1}\nWill log to stderr instead.\n",
         log_file, EC.message());
   }
   // No need to delete the stderr stream.
   return std::shared_ptr<raw_ostream>(&errs(), [](raw_ostream *) {});

llvm/include/llvm/Analysis/DOTGraphTraitsPass.h

if (!processFunction(F, Analysis))
       return false;
 
     GraphT Graph = AnalysisGraphTraitsT::getGraph(&Analysis);
     std::string Filename = Name + "." + F.getName().str() + ".dot";
     std::error_code EC;
 
     errs() << "Writing '" << Filename << "'...";
 
-    raw_fd_ostream File(Filename, EC, sys::fs::OF_Text);
+    raw_fd_ostream File(Filename, EC, sys::fs::OF_TextWithCRLF);
     std::string GraphName = DOTGraphTraits<GraphT>::getGraphName(Graph);
     std::string Title = GraphName + " for '" + F.getName().str() + "' function";
 
     if (!EC)
       WriteGraph(File, Graph, IsSimple, Title);
     else
       errs() << "  error opening file for writing!";
     errs() << "\n";
public:
 
   bool runOnModule(Module &M) override {
     GraphT Graph = AnalysisGraphTraitsT::getGraph(&getAnalysis<AnalysisT>());
     std::string Filename = Name + ".dot";
     std::error_code EC;
 
     errs() << "Writing '" << Filename << "'...";
 
-    raw_fd_ostream File(Filename, EC, sys::fs::OF_Text);
+    raw_fd_ostream File(Filename, EC, sys::fs::OF_TextWithCRLF);
     std::string Title = DOTGraphTraits<GraphT>::getGraphName(Graph);
 
     if (!EC)
       WriteGraph(File, Graph, IsSimple, Title);
     else
       errs() << "  error opening file for writing!";
     errs() << "\n";
 

llvm/include/llvm/Support/FileSystem.h

enum FileAccess : unsigned {
   FA_Read = 1,
   FA_Write = 2,
 };
 
 enum OpenFlags : unsigned {
   OF_None = 0,
   F_None = 0, // For compatibility
 
-  /// The file should be opened in text mode on platforms that make this
-  /// distinction.
+  /// The file should be opened in text mode on platforms like z/OS that make
+  /// this distinction.
   OF_Text = 1,
   F_Text = 1, // For compatibility
 
+  /// The file should use a carriage linefeed '\r\n'. This flag should only be
+  /// used with OF_Text. Only makes a difference on Windows.
+  OF_CRLF = 2,
+
+  /// The file should be opened in text mode and use a carriage linefeed '\r\n'.
+  /// This flag has the same functionality as OF_Text on z/OS but adds a
+  /// carriage linefeed on Windows.
+  OF_TextWithCRLF = OF_Text | OF_CRLF,
+
   /// The file should be opened in append mode.
-  OF_Append = 2,
-  F_Append = 2, // For compatibility
+  OF_Append = 4,
+  F_Append = 4, // For compatibility
 
   /// Delete the file on close. Only makes a difference on windows.
-  OF_Delete = 4,
+  OF_Delete = 8,
 
   /// When a child process is launched, this file should remain open in the
   /// child process.
-  OF_ChildInherit = 8,
+  OF_ChildInherit = 16,
 
-  /// Force files Atime to be updated on access. Only makes a difference on windows.
-  OF_UpdateAtime = 16,
+  /// Force files Atime to be updated on access. Only makes a difference on
+  /// Windows.
+  OF_UpdateAtime = 32,
 };
 
 /// Create a potentially unique file name but does not create it.
 ///
 /// Generates a unique path suitable for a temporary file but does not
 /// open or create the file. The name is based on \a Model with '%'
 /// replaced by a random char in [0-9a-f]. If \a MakeAbsolute is true
 /// then the system's temp directory is prepended first. If \a MakeAbsolute

llvm/lib/CodeGen/RegAllocPBQP.cpp

 
 #ifndef NDEBUG
       if (PBQPDumpGraphs) {
         std::ostringstream RS;
         RS << Round;
         std::string GraphFileName = FullyQualifiedName + "." + RS.str() +
                                     ".pbqpgraph";
         std::error_code EC;
-        raw_fd_ostream OS(GraphFileName, EC, sys::fs::OF_Text);
+        raw_fd_ostream OS(GraphFileName, EC, sys::fs::OF_TextWithCRLF);
         LLVM_DEBUG(dbgs() << "Dumping graph for round " << Round << " to \""
                           << GraphFileName << "\"\n");
         G.dump(OS);
       }
 #endif
 
       PBQP::Solution Solution = PBQP::RegAlloc::solve(G);
       PBQPAllocComplete = mapPBQPToRegAlloc(G, Solution, VRM, *VRegSpiller);

llvm/lib/IR/Core.cpp

 void LLVMDumpModule(LLVMModuleRef M) {
   unwrap(M)->print(errs(), nullptr,
                    /*ShouldPreserveUseListOrder=*/false, /*IsForDebug=*/true);
 }
 
 LLVMBool LLVMPrintModuleToFile(LLVMModuleRef M, const char *Filename,
                                char **ErrorMessage) {
   std::error_code EC;
-  raw_fd_ostream dest(Filename, EC, sys::fs::OF_Text);
+  raw_fd_ostream dest(Filename, EC, sys::fs::OF_TextWithCRLF);
   if (EC) {
     *ErrorMessage = strdup(EC.message().c_str());
     return true;
   }
 
   unwrap(M)->print(dest, nullptr);
 
   dest.close();

llvm/lib/IR/LLVMRemarkStreamer.cpp

Expected<std::unique_ptr<ToolOutputFile>> llvm::setupLLVMOptimizationRemarks(
   if (RemarksFilename.empty())
     return nullptr;
 
   Expected<remarks::Format> Format = remarks::parseFormat(RemarksFormat);
   if (Error E = Format.takeError())
     return make_error<LLVMRemarkSetupFormatError>(std::move(E));
 
   std::error_code EC;
-  auto Flags = *Format == remarks::Format::YAML ? sys::fs::OF_Text
+  auto Flags = *Format == remarks::Format::YAML ? sys::fs::OF_TextWithCRLF
                                                 : sys::fs::OF_None;
   auto RemarksFile =
       std::make_unique<ToolOutputFile>(RemarksFilename, EC, Flags);
   // We don't use llvm::FileError here because some diagnostics want the file
   // name separately.
   if (EC)
     return make_error<LLVMRemarkSetupFileError>(errorCodeToError(EC));
 

llvm/lib/LTO/LTOBackend.cpp

LLVM_ATTRIBUTE_NORETURN static void reportOpenError(StringRef Path, Twine Msg) {
   exit(1);
 }
 
 Error Config::addSaveTemps(std::string OutputFileName,
                            bool UseInputModulePath) {
   ShouldDiscardValueNames = false;
 
   std::error_code EC;
-  ResolutionFile = std::make_unique<raw_fd_ostream>(
-      OutputFileName + "resolution.txt", EC, sys::fs::OpenFlags::OF_Text);
+  ResolutionFile =
+      std::make_unique<raw_fd_ostream>(OutputFileName + "resolution.txt", EC,
+                                       sys::fs::OpenFlags::OF_TextWithCRLF);
   if (EC) {
     ResolutionFile.reset();
     return errorCodeToError(EC);
   }
 
   auto setHook = [&](std::string PathSuffix, ModuleHookFn &Hook) {
     // Keep track of the hook provided by the linker, which also needs to run.
     ModuleHookFn LinkerHook = Hook;

llvm/lib/MC/MCParser/DarwinAsmParser.cpp

bool DarwinAsmParser::parseDirectiveSecureLogUnique(StringRef, SMLoc IDLoc) {
   if (!SecureLogFile)
     return Error(IDLoc, ".secure_log_unique used but AS_SECURE_LOG_FILE "
                  "environment variable unset.");
 
   // Open the secure log file if we haven't already.
   raw_fd_ostream *OS = getContext().getSecureLog();
   if (!OS) {
     std::error_code EC;
-    auto NewOS = std::make_unique<raw_fd_ostream>(
-        StringRef(SecureLogFile), EC, sys::fs::OF_Append | sys::fs::OF_Text);
+    auto NewOS = std::make_unique<raw_fd_ostream>(StringRef(SecureLogFile), EC,
+                                                  sys::fs::OF_Append |
+                                                      sys::fs::OF_TextWithCRLF);
     if (EC)
        return Error(IDLoc, Twine("can't open secure log file: ") +
                                SecureLogFile + " (" + EC.message() + ")");
     OS = NewOS.get();
     getContext().setSecureLog(std::move(NewOS));
   }
 
   // Write the message.

llvm/lib/ProfileData/GCOV.cpp

if (!options.UseStdout) {
       os << '\n';
     }
 
     if (options.NoOutput || options.Intermediate)
       continue;
     Optional<raw_fd_ostream> os;
     if (!options.UseStdout) {
       std::error_code ec;
-      os.emplace(gcovName, ec, sys::fs::OF_Text);
+      os.emplace(gcovName, ec, sys::fs::OF_TextWithCRLF);
       if (ec) {
         errs() << ec.message() << '\n';
         continue;
       }
     }
     annotateSource(si, file, gcno, gcda,
                    options.UseStdout ? llvm::outs() : *os);
   }
 
   if (options.Intermediate && !options.NoOutput) {
     // gcov 7.* unexpectedly create multiple .gcov files, which was fixed in 8.0
     // (PR GCC/82702). We create just one file.
     std::string outputPath(sys::path::filename(filename));
     std::error_code ec;
-    raw_fd_ostream os(outputPath + ".gcov", ec, sys::fs::OF_Text);
+    raw_fd_ostream os(outputPath + ".gcov", ec, sys::fs::OF_TextWithCRLF);
     if (ec) {
       errs() << ec.message() << '\n';
       return;
     }
 
     for (const SourceInfo &si : sources)
       printSourceToIntermediate(si, os);
   }

llvm/lib/ProfileData/SampleProfWriter.cpp

 ErrorOr<std::unique_ptr<SampleProfileWriter>>
 SampleProfileWriter::create(StringRef Filename, SampleProfileFormat Format) {
   std::error_code EC;
   std::unique_ptr<raw_ostream> OS;
   if (Format == SPF_Binary || Format == SPF_Ext_Binary ||
       Format == SPF_Compact_Binary)
     OS.reset(new raw_fd_ostream(Filename, EC, sys::fs::OF_None));
   else
-    OS.reset(new raw_fd_ostream(Filename, EC, sys::fs::OF_Text));
+    OS.reset(new raw_fd_ostream(Filename, EC, sys::fs::OF_TextWithCRLF));
   if (EC)
     return EC;
 
   return create(OS, Format);
 }
 
 /// Create a sample profile stream writer based on the specified format.
 ///

llvm/lib/Support/FileCollector.cpp

 std::error_code FileCollector::writeMapping(StringRef MappingFile) {
   std::lock_guard<std::mutex> lock(Mutex);
 
   VFSWriter.setOverlayDir(OverlayRoot);
   VFSWriter.setCaseSensitivity(isCaseSensitivePath(OverlayRoot));
   VFSWriter.setUseExternalNames(false);
 
   std::error_code EC;
-  raw_fd_ostream os(MappingFile, EC, sys::fs::OF_Text);
+  raw_fd_ostream os(MappingFile, EC, sys::fs::OF_TextWithCRLF);
   if (EC)
     return EC;
 
   VFSWriter.write(os);
 
   return {};
 }
 

llvm/lib/Support/MemoryBuffer.cpp

getOpenFileImpl(sys::fs::file_t FD, const Twine &Filename, uint64_t FileSize,
                 uint64_t MapSize, int64_t Offset, bool RequiresNullTerminator,
                 bool IsVolatile);
 
 template <typename MB>
 static ErrorOr<std::unique_ptr<MB>>
 getFileAux(const Twine &Filename, uint64_t MapSize, uint64_t Offset,
            bool IsText, bool RequiresNullTerminator, bool IsVolatile) {
   Expected<sys::fs::file_t> FDOrErr = sys::fs::openNativeFileForRead(
-      Filename, IsText ? sys::fs::OF_Text : sys::fs::OF_None);
+      Filename, IsText ? sys::fs::OF_TextWithCRLF : sys::fs::OF_None);
   if (!FDOrErr)
     return errorToErrorCode(FDOrErr.takeError());
   sys::fs::file_t FD = *FDOrErr;
   auto Ret = getOpenFileImpl<MB>(FD, Filename, /*FileSize=*/-1, MapSize, Offset,
                                  RequiresNullTerminator, IsVolatile);
   sys::fs::closeFile(FD);
   return Ret;
 }

llvm/lib/Support/TimeProfiler.cpp

Error llvm::timeTraceProfilerWrite(StringRef PreferredFileName,
 
   std::string Path = PreferredFileName.str();
   if (Path.empty()) {
     Path = FallbackFileName == "-" ? "out" : FallbackFileName.str();
     Path += ".time-trace";
   }
 
   std::error_code EC;
-  raw_fd_ostream OS(Path, EC, sys::fs::OF_Text);
+  raw_fd_ostream OS(Path, EC, sys::fs::OF_TextWithCRLF);
   if (EC)
     return createStringError(EC, "Could not open " + Path);
 
   timeTraceProfilerWrite(OS);
   return Error::success();
 }
 
 void llvm::timeTraceProfilerBegin(StringRef Name, StringRef Detail) {

llvm/lib/Support/Timer.cpp

if (OutputFilename == "-")
     return std::make_unique<raw_fd_ostream>(1, false); // stdout.
 
   // Append mode is used because the info output file is opened and closed
   // each time -stats or -time-passes wants to print output to it. To
   // compensate for this, the test-suite Makefiles have code to delete the
   // info output file before running commands which write to it.
   std::error_code EC;
   auto Result = std::make_unique<raw_fd_ostream>(
-      OutputFilename, EC, sys::fs::OF_Append | sys::fs::OF_Text);
+      OutputFilename, EC, sys::fs::OF_Append | sys::fs::OF_TextWithCRLF);
   if (!EC)
     return Result;
 
   errs() << "Error opening info-output-file '"
     << OutputFilename << " for appending!\n";
   return std::make_unique<raw_fd_ostream>(2, false); // stderr.
 }
 

llvm/lib/Support/Unix/Program.inc

std::error_code llvm::sys::ChangeStdoutToBinary() {
   // Do nothing, as Unix doesn't differentiate between text and binary.
   return std::error_code();
 }
 
 std::error_code
 llvm::sys::writeFileWithEncoding(StringRef FileName, StringRef Contents,
                                  WindowsEncodingMethod Encoding /*unused*/) {
   std::error_code EC;
-  llvm::raw_fd_ostream OS(FileName, EC, llvm::sys::fs::OpenFlags::OF_Text);
+  llvm::raw_fd_ostream OS(FileName, EC, llvm::sys::fs::OpenFlags::OF_TextWithCRLF);
 
   if (EC)
     return EC;
 
   OS << Contents;
 
   if (OS.has_error())
     return make_error_code(errc::io_error);

llvm/lib/Support/Windows/Path.inc

 }
 
 static std::error_code nativeFileToFd(Expected<HANDLE> H, int &ResultFD,
                                       OpenFlags Flags) {
   int CrtOpenFlags = 0;
   if (Flags & OF_Append)
     CrtOpenFlags |= _O_APPEND;
 
-  if (Flags & OF_Text)
+  if (Flags & OF_CRLF) {
+    assert(Flags & OF_Text && "Flags set OF_CRLF without OF_Text");
     CrtOpenFlags |= _O_TEXT;
+  }
 
   ResultFD = -1;
   if (!H)
     return errorToErrorCode(H.takeError());
 
   ResultFD = ::_open_osfhandle(intptr_t(*H), CrtOpenFlags);
   if (ResultFD == -1) {
     ::CloseHandle(*H);

llvm/lib/Support/Windows/Program.inc

if (result == -1)
     return std::error_code(errno, std::generic_category());
   return std::error_code();
 }
 
 std::error_code
 llvm::sys::writeFileWithEncoding(StringRef FileName, StringRef Contents,
                                  WindowsEncodingMethod Encoding) {
   std::error_code EC;
-  llvm::raw_fd_ostream OS(FileName, EC, llvm::sys::fs::OF_Text);
+  llvm::raw_fd_ostream OS(FileName, EC, llvm::sys::fs::OF_TextWithCRLF);
   if (EC)
     return EC;
 
   if (Encoding == WEM_UTF8) {
     OS << Contents;
   } else if (Encoding == WEM_CurrentCodePage) {
     SmallVector<wchar_t, 1> ArgsUTF16;
     SmallVector<char, 1> ArgsCurCP;

llvm/lib/Transforms/IPO/Attributor.cpp

else
     Prefix = "dep_graph";
   std::string Filename =
       Prefix + "_" + std::to_string(CallTimes.load()) + ".dot";
 
   outs() << "Dependency graph dump to " << Filename << ".\n";
 
   std::error_code EC;
 
-  raw_fd_ostream File(Filename, EC, sys::fs::OF_Text);
+  raw_fd_ostream File(Filename, EC, sys::fs::OF_TextWithCRLF);
   if (!EC)
     llvm::WriteGraph(File, this);
 
   CallTimes++;
 }
 
 void AADepGraph::print() {
   for (auto DepAA : SyntheticRoot.Deps)

llvm/lib/Transforms/IPO/LowerTypeTests.cpp

bool Changed =
           ClSummaryAction == PassSummaryAction::Import ? &Summary : nullptr,
           /*DropTypeTests*/ false)
           .lower();
 
   if (!ClWriteSummary.empty()) {
     ExitOnError ExitOnErr("-lowertypetests-write-summary: " + ClWriteSummary +
                           ": ");
     std::error_code EC;
-    raw_fd_ostream OS(ClWriteSummary, EC, sys::fs::OF_Text);
+    raw_fd_ostream OS(ClWriteSummary, EC, sys::fs::OF_TextWithCRLF);
     ExitOnErr(errorCodeToError(EC));
 
     yaml::Output Out(OS);
     Out << Summary;
   }
 
   return Changed;
 }

llvm/lib/Transforms/IPO/WholeProgramDevirt.cpp

if (!ClWriteSummary.empty()) {
     ExitOnError ExitOnErr(
         "-wholeprogramdevirt-write-summary: " + ClWriteSummary + ": ");
     std::error_code EC;
     if (StringRef(ClWriteSummary).endswith(".bc")) {
       raw_fd_ostream OS(ClWriteSummary, EC, sys::fs::OF_None);
       ExitOnErr(errorCodeToError(EC));
       WriteIndexToFile(*Summary, OS);
     } else {
-      raw_fd_ostream OS(ClWriteSummary, EC, sys::fs::OF_Text);
+      raw_fd_ostream OS(ClWriteSummary, EC, sys::fs::OF_TextWithCRLF);
       ExitOnErr(errorCodeToError(EC));
       yaml::Output Out(OS);
       Out << *Summary;
     }
   }
 
   return Changed;
 }

llvm/lib/Transforms/Utils/Debugify.cpp

 }
 
 // Write the json data into the specifed file.
 static void writeJSON(StringRef OrigDIVerifyBugsReportFilePath,
                       StringRef FileNameFromCU, StringRef NameOfWrappedPass,
                       llvm::json::Array &Bugs) {
   std::error_code EC;
   raw_fd_ostream OS_FILE{OrigDIVerifyBugsReportFilePath, EC,
-                         sys::fs::OF_Append | sys::fs::OF_Text};
+                         sys::fs::OF_Append | sys::fs::OF_TextWithCRLF};
   if (EC) {
     errs() << "Could not open file: " << EC.message() << ", "
            << OrigDIVerifyBugsReportFilePath << '\n';
     return;
   }
 
   OS_FILE << "{\"file\":\"" << FileNameFromCU << "\", ";
 

llvm/tools/dsymutil/dsymutil.cpp

 }
 
 static Error createPlistFile(StringRef Bin, StringRef BundleRoot,
                              StringRef Toolchain) {
   // Create plist file to write to.
   SmallString<128> InfoPlist(BundleRoot);
   sys::path::append(InfoPlist, "Contents/Info.plist");
   std::error_code EC;
-  raw_fd_ostream PL(InfoPlist, EC, sys::fs::OF_Text);
+  raw_fd_ostream PL(InfoPlist, EC, sys::fs::OF_TextWithCRLF);
   if (EC)
     return make_error<StringError>(
         "cannot create Plist: " + toString(errorCodeToError(EC)), EC);
 
   CFBundleInfo BI = getBundleInfo(Bin);
 
   if (BI.IDStr.empty()) {
     StringRef BundleID = *sys::path::rbegin(BundleRoot);

llvm/tools/llc/llc.cpp

case CGFT_Null:
     Binary = true;
     break;
   }
 
   // Open the file.
   std::error_code EC;
   sys::fs::OpenFlags OpenFlags = sys::fs::OF_None;
   if (!Binary)
-    OpenFlags |= sys::fs::OF_Text;
+    OpenFlags |= sys::fs::OF_TextWithCRLF;
   auto FDOut = std::make_unique<ToolOutputFile>(OutputFilename, EC, OpenFlags);
   if (EC) {
     reportError(EC.message());
     return nullptr;
   }
 
   return FDOut;
 }

llvm/tools/lli/lli.cpp

static std::function<void(Module &)> createDebugDumper() {
   case DumpKind::DumpModsToStdOut:
     return [](Module &M) {
       outs() << "----- Module Start -----\n" << M << "----- Module End -----\n";
     };
 
   case DumpKind::DumpModsToDisk:
     return [](Module &M) {
       std::error_code EC;
-      raw_fd_ostream Out(M.getModuleIdentifier() + ".ll", EC, sys::fs::OF_Text);
+      raw_fd_ostream Out(M.getModuleIdentifier() + ".ll", EC,
+                         sys::fs::OF_TextWithCRLF);
       if (EC) {
         errs() << "Couldn't open " << M.getModuleIdentifier()
                << " for dumping.\nError:" << EC.message() << "\n";
         exit(1);
       }
       Out << M;
     };
   }

llvm/tools/llvm-cxxmap/llvm-cxxmap.cpp

int main(int argc, const char *argv[]) {
   if (!NewSymbolBufOrError)
     exitWithErrorCode(NewSymbolBufOrError.getError(), NewSymbolFile);
 
   auto RemappingBufOrError = MemoryBuffer::getFileOrSTDIN(RemappingFile);
   if (!RemappingBufOrError)
     exitWithErrorCode(RemappingBufOrError.getError(), RemappingFile);
 
   std::error_code EC;
-  raw_fd_ostream OS(OutputFilename.data(), EC, sys::fs::OF_Text);
+  raw_fd_ostream OS(OutputFilename.data(), EC, sys::fs::OF_TextWithCRLF);
   if (EC)
     exitWithErrorCode(EC, OutputFilename);
 
   remapSymbols(*OldSymbolBufOrError.get(), *NewSymbolBufOrError.get(),
                *RemappingBufOrError.get(), OS);
 }

llvm/tools/llvm-dis/llvm-dis.cpp

if (FinalFilename.empty()) { // Unspecified output, infer it.
       }
     } else {
       if (N > 1)
         FinalFilename += std::string(".") + std::to_string(i);
     }
 
     std::error_code EC;
     std::unique_ptr<ToolOutputFile> Out(
-        new ToolOutputFile(FinalFilename, EC, sys::fs::OF_Text));
+        new ToolOutputFile(FinalFilename, EC, sys::fs::OF_TextWithCRLF));
     if (EC) {
       errs() << EC.message() << '\n';
       return 1;
     }
 
     std::unique_ptr<AssemblyAnnotationWriter> Annotator;
     if (ShowAnnotations)
       Annotator.reset(new CommentWriter());

llvm/tools/llvm-dwarfdump/llvm-dwarfdump.cpp

int main(int argc, char **argv) {
   //        compatible.
   if (Diff && Verbose) {
     WithColor::error() << "incompatible arguments: specifying both -diff and "
                           "-verbose is currently not supported";
     return 1;
   }
 
   std::error_code EC;
-  ToolOutputFile OutputFile(OutputFilename, EC, sys::fs::OF_Text);
+  ToolOutputFile OutputFile(OutputFilename, EC, sys::fs::OF_TextWithCRLF);
   error("Unable to open output file" + OutputFilename, EC);
   // Don't remove output file if we exit with an error.
   OutputFile.keep();
 
   bool OffsetRequested = false;
 
   // Defaults to dumping all sections, unless brief mode is specified in which
   // case only the .debug_info section in dumped.

llvm/tools/llvm-exegesis/lib/BenchmarkResult.cpp

 
 Error InstructionBenchmark::writeYaml(const LLVMState &State,
                                       const StringRef Filename) {
   if (Filename == "-") {
     if (auto Err = writeYamlTo(State, outs()))
       return Err;
   } else {
     int ResultFD = 0;
-    if (auto E = errorCodeToError(openFileForWrite(
-            Filename, ResultFD, sys::fs::CD_CreateAlways, sys::fs::OF_Text))) {
+    if (auto E = errorCodeToError(openFileForWrite(Filename, ResultFD,
+                                                   sys::fs::CD_CreateAlways,
+                                                   sys::fs::OF_TextWithCRLF))) {
       return E;
     }
     raw_fd_ostream Ostr(ResultFD, true /*shouldClose*/);
     if (auto Err = writeYamlTo(State, Ostr))
       return Err;
   }
   return Error::success();
 }

llvm/tools/llvm-link/llvm-link.cpp

int main(int argc, char **argv) {
   if (!importFunctions(argv[0], *Composite))
     return 1;
 
   if (DumpAsm)
     errs() << "Here's the assembly:\n" << *Composite;
 
   std::error_code EC;
   ToolOutputFile Out(OutputFilename, EC,
-                     OutputAssembly ? sys::fs::OF_Text : sys::fs::OF_None);
+                     OutputAssembly ? sys::fs::OF_TextWithCRLF
+                                    : sys::fs::OF_None);
   if (EC) {
     WithColor::error() << EC.message() << '\n';
     return 1;
   }
 
   if (!NoVerify && verifyModule(*Composite, &errs())) {
     errs() << argv[0] << ": ";
     WithColor::error() << "linked module is broken!\n";

llvm/tools/llvm-mc/llvm-mc.cpp

int main(int argc, char **argv) {
   std::string FeaturesStr;
   if (MAttrs.size()) {
     SubtargetFeatures Features;
     for (unsigned i = 0; i != MAttrs.size(); ++i)
       Features.AddFeature(MAttrs[i]);
     FeaturesStr = Features.getString();
   }
 
-  sys::fs::OpenFlags Flags = (FileType == OFT_AssemblyFile) ? sys::fs::OF_Text
-                                                            : sys::fs::OF_None;
+  sys::fs::OpenFlags Flags = (FileType == OFT_AssemblyFile)
+                                 ? sys::fs::OF_TextWithCRLF
   std::unique_ptr<ToolOutputFile> Out = GetOutputStream(OutputFilename, Flags);
   if (!Out)
     return 1;
 
   std::unique_ptr<ToolOutputFile> DwoOut;
   if (!SplitDwarfFile.empty()) {
     if (FileType != OFT_ObjectFile) {
       WithColor::error() << "dwo output only supported with object files\n";

llvm/tools/llvm-mca/llvm-mca.cpp

const Target *getTarget(const char *ProgName) {
   // Return the found target.
   return TheTarget;
 }
 
 ErrorOr<std::unique_ptr<ToolOutputFile>> getOutputStream() {
   if (OutputFilename == "")
     OutputFilename = "-";
   std::error_code EC;
-  auto Out =
-      std::make_unique<ToolOutputFile>(OutputFilename, EC, sys::fs::OF_Text);
+  auto Out = std::make_unique<ToolOutputFile>(OutputFilename, EC,
+                                              sys::fs::OF_TextWithCRLF);
   if (!EC)
     return std::move(Out);
   return EC;
 }
 } // end of anonymous namespace
 
 static void processOptionImpl(cl::opt<bool> &O, const cl::opt<bool> &Default) {
   if (!O.getNumOccurrences() || O.getPosition() < Default.getPosition())

llvm/tools/llvm-opt-report/OptReport.cpp

while (true) {
     }
   }
 
   return true;
 }
 
 static bool writeReport(LocationInfoTy &LocationInfo) {
   std::error_code EC;
-  llvm::raw_fd_ostream OS(OutputFileName, EC, llvm::sys::fs::OF_Text);
+  llvm::raw_fd_ostream OS(OutputFileName, EC, llvm::sys::fs::OF_TextWithCRLF);
   if (EC) {
     WithColor::error() << "Can't open file " << OutputFileName << ": "
                        << EC.message() << "\n";
     return false;
   }
 
   bool FirstFile = true;
   for (auto &FI : LocationInfo) {

llvm/tools/llvm-profdata/llvm-profdata.cpp

static void mergeWriterContexts(WriterContext *Dst, WriterContext *Src) {
   });
 }
 
 static void writeInstrProfile(StringRef OutputFilename,
                               ProfileFormat OutputFormat,
                               InstrProfWriter &Writer) {
   std::error_code EC;
   raw_fd_ostream Output(OutputFilename.data(), EC,
-                        OutputFormat == PF_Text ? sys::fs::OF_Text
+                        OutputFormat == PF_Text ? sys::fs::OF_TextWithCRLF
                                                 : sys::fs::OF_None);
   if (EC)
     exitWithErrorCode(EC, OutputFilename);
 
   if (OutputFormat == PF_Text) {
     if (Error E = Writer.writeText(Output))
       warn(std::move(E));
   } else {
cl::opt<unsigned long long> SimilarityCutoff(
                "with similarities below the cutoff (percentage times 10000)."));
   cl::opt<ProfileKinds> ProfileKind(
       cl::desc("Profile kind:"), cl::init(instr),
       cl::values(clEnumVal(instr, "Instrumentation profile (default)"),
                  clEnumVal(sample, "Sample profile")));
   cl::ParseCommandLineOptions(argc, argv, "LLVM profile data overlap tool\n");
 
   std::error_code EC;
-  raw_fd_ostream OS(Output.data(), EC, sys::fs::OF_Text);
+  raw_fd_ostream OS(Output.data(), EC, sys::fs::OF_TextWithCRLF);
   if (EC)
     exitWithErrorCode(EC, Output);
 
   if (ProfileKind == instr)
     overlapInstrProfile(BaseFilename, TestFilename,
                         OverlapFuncFilters{ValueCutoff, FuncNameFilter}, OS,
                         IsCS);
   else
static int show_main(int argc, const char *argv[]) {
 
   if (Filename == OutputFilename) {
     errs() << sys::path::filename(argv[0])
            << ": Input file name cannot be the same as the output file name!\n";
     return 1;
   }
 
   std::error_code EC;
-  raw_fd_ostream OS(OutputFilename.data(), EC, sys::fs::OF_Text);
+  raw_fd_ostream OS(OutputFilename.data(), EC, sys::fs::OF_TextWithCRLF);
   if (EC)
     exitWithErrorCode(EC, OutputFilename);
 
   if (ShowAllFunctions && !ShowFunction.empty())
     WithColor::warning() << "-function argument ignored: showing all functions\n";
 
   if (ProfileKind == instr)
     return showInstrProfile(Filename, ShowCounts, TopNFunctions,

llvm/tools/llvm-xray/xray-account.cpp

if (!InstrumentationMapOrError)
                             Twine("Cannot open instrumentation map '") +
                                 AccountInstrMap + "'",
                             std::make_error_code(std::errc::invalid_argument)),
                         InstrumentationMapOrError.takeError());
     Map = std::move(*InstrumentationMapOrError);
   }
 
   std::error_code EC;
-  raw_fd_ostream OS(AccountOutput, EC, sys::fs::OpenFlags::OF_Text);
+  raw_fd_ostream OS(AccountOutput, EC, sys::fs::OpenFlags::OF_TextWithCRLF);
   if (EC)
     return make_error<StringError>(
         Twine("Cannot open file '") + AccountOutput + "' for writing.", EC);
 
   const auto &FunctionAddresses = Map.getFunctionAddresses();
   symbolize::LLVMSymbolizer Symbolizer;
   llvm::xray::FuncIdConversionHelper FuncIdHelper(AccountInstrMap, Symbolizer,
                                                   FunctionAddresses);

llvm/tools/llvm-xray/xray-converter.cpp

static CommandRegistration Unused(&Convert, []() -> Error {
   symbolize::LLVMSymbolizer Symbolizer;
   llvm::xray::FuncIdConversionHelper FuncIdHelper(ConvertInstrMap, Symbolizer,
                                                   FunctionAddresses);
   llvm::xray::TraceConverter TC(FuncIdHelper, ConvertSymbolize);
   std::error_code EC;
   raw_fd_ostream OS(ConvertOutput, EC,
                     ConvertOutputFormat == ConvertFormats::BINARY
                         ? sys::fs::OpenFlags::OF_None
-                        : sys::fs::OpenFlags::OF_Text);
+                        : sys::fs::OpenFlags::OF_TextWithCRLF);
   if (EC)
     return make_error<StringError>(
         Twine("Cannot open file '") + ConvertOutput + "' for writing.", EC);
 
   auto TraceOrErr = loadTraceFile(ConvertInput, ConvertSortInput);
   if (!TraceOrErr)
     return joinErrors(
         make_error<StringError>(

llvm/tools/llvm-xray/xray-extract.cpp

static CommandRegistration Unused(&Extract, []() -> Error {
   if (!InstrumentationMapOrError)
     return joinErrors(make_error<StringError>(
                           Twine("Cannot extract instrumentation map from '") +
                               ExtractInput + "'.",
                           std::make_error_code(std::errc::invalid_argument)),
                       InstrumentationMapOrError.takeError());
 
   std::error_code EC;
-  raw_fd_ostream OS(ExtractOutput, EC, sys::fs::OpenFlags::OF_Text);
+  raw_fd_ostream OS(ExtractOutput, EC, sys::fs::OpenFlags::OF_TextWithCRLF);
   if (EC)
     return make_error<StringError>(
         Twine("Cannot open file '") + ExtractOutput + "' for writing.", EC);
   const auto &FunctionAddresses =
       InstrumentationMapOrError->getFunctionAddresses();
   symbolize::LLVMSymbolizer::Options opts;
   if (ExtractNoDemangle)
     opts.Demangle = false;
   symbolize::LLVMSymbolizer Symbolizer(opts);
   llvm::xray::FuncIdConversionHelper FuncIdHelper(ExtractInput, Symbolizer,
                                                   FunctionAddresses);
   exportAsYAML(*InstrumentationMapOrError, OS, FuncIdHelper);
   return Error::success();
 });

llvm/tools/llvm-xray/xray-graph-diff.cpp

static CommandRegistration Unused(&GraphDiff, []() -> Error {
 
   auto GDROrErr = DGF.getGraphDiffRenderer();
   if (!GDROrErr)
     return GDROrErr.takeError();
 
   auto &GDR = *GDROrErr;
 
   std::error_code EC;
-  raw_fd_ostream OS(GraphDiffOutput, EC, sys::fs::OpenFlags::OF_Text);
+  raw_fd_ostream OS(GraphDiffOutput, EC, sys::fs::OpenFlags::OF_TextWithCRLF);
   if (EC)
     return make_error<StringError>(
         Twine("Cannot open file '") + GraphDiffOutput + "' for writing.", EC);
 
   GDR.exportGraphAsDOT(OS, GraphDiffEdgeLabel, GraphDiffEdgeColor,
                        GraphDiffVertexLabel, GraphDiffVertexColor,
                        GraphDiffVertexLabelTrunc);
 
   return Error::success();
 });

llvm/tools/llvm-xray/xray-graph.cpp

static CommandRegistration Unused(&GraphC, []() -> Error {
 
   F.Trace = std::move(*TraceOrErr);
   auto GROrError = F.getGraphRenderer();
   if (!GROrError)
     return GROrError.takeError();
   auto &GR = *GROrError;
 
   std::error_code EC;
-  raw_fd_ostream OS(GraphOutput, EC, sys::fs::OpenFlags::OF_Text);
+  raw_fd_ostream OS(GraphOutput, EC, sys::fs::OpenFlags::OF_TextWithCRLF);
   if (EC)
     return make_error<StringError>(
         Twine("Cannot open file '") + GraphOutput + "' for writing.", EC);
 
   GR.exportGraphAsDOT(OS, GraphEdgeLabel, GraphEdgeColorType, GraphVertexLabel,
                       GraphVertexColorType);
   return Error::success();
 });

llvm/tools/opt/opt.cpp

if (!OutputFilename.empty())
       errs() << "WARNING: The -o (output filename) option is ignored when\n"
                 "the --disable-output option is used.\n";
   } else {
     // Default to standard output.
     if (OutputFilename.empty())
       OutputFilename = "-";
 
     std::error_code EC;
-    sys::fs::OpenFlags Flags = OutputAssembly ? sys::fs::OF_Text
-                                              : sys::fs::OF_None;
+    sys::fs::OpenFlags Flags =
+        OutputAssembly ? sys::fs::OF_TextWithCRLF : sys::fs::OF_None;
     Out.reset(new ToolOutputFile(OutputFilename, EC, Flags));
     if (EC) {
       errs() << EC.message() << '\n';
       return 1;
     }
 
     if (!ThinLinkBitcodeFile.empty()) {
       ThinLinkOut.reset(

llvm/tools/verify-uselistorder/verify-uselistorder.cpp

bool TempFile::writeBitcode(const Module &M) const {
 
   WriteBitcodeToFile(M, OS, /* ShouldPreserveUseListOrder */ true);
   return false;
 }
 
 bool TempFile::writeAssembly(const Module &M) const {
   LLVM_DEBUG(dbgs() << " - write assembly\n");
   std::error_code EC;
-  raw_fd_ostream OS(Filename, EC, sys::fs::OF_Text);
+  raw_fd_ostream OS(Filename, EC, sys::fs::OF_TextWithCRLF);
   if (EC) {
     errs() << "verify-uselistorder: error: " << EC.message() << "\n";
     return true;
   }
 
   M.print(OS, nullptr, /* ShouldPreserveUseListOrder */ true);
   return false;
 }

llvm/unittests/Support/Path.cpp

 
 #ifdef _WIN32
 TEST_F(FileSystemTest, CarriageReturn) {
   SmallString<128> FilePathname(TestDirectory);
   std::error_code EC;
   path::append(FilePathname, "test");
 
   {
-    raw_fd_ostream File(FilePathname, EC, sys::fs::OF_Text);
+    raw_fd_ostream File(FilePathname, EC, sys::fs::OF_TextWithCRLF);
     ASSERT_NO_ERROR(EC);
     File << '\n';
   }
   {
     auto Buf = MemoryBuffer::getFile(FilePathname.str());
     EXPECT_TRUE((bool)Buf);
     EXPECT_EQ(Buf.get()->getBuffer(), "\r\n");
   }

polly/lib/Exchange/JSONExporter.cpp

 
 static void exportScop(Scop &S) {
   std::string FileName = ImportDir + "/" + getFileName(S);
 
   json::Value jscop = getJSON(S);
 
   // Write to file.
   std::error_code EC;
-  ToolOutputFile F(FileName, EC, llvm::sys::fs::OF_Text);
+  ToolOutputFile F(FileName, EC, llvm::sys::fs::OF_TextWithCRLF);
 
   std::string FunctionName = S.getFunction().getName().str();
   errs() << "Writing JScop '" << S.getNameStr() << "' in function '"
          << FunctionName << "' to '" << FileName << "'.\n";
 
   if (!EC) {
     F.os() << formatv("{0:3}", jscop);
     F.os().close();