Use OpenFlags instead of boolean to set a file as text/binary

[abhina.sreeskantharajan]

Summary

This patch updates the functions createDefaultOutputFile, createOutputFile, createOutputFileImpl to use OpenFlags instead of a boolean binary flag.

I mapped the bool to the OpenFlags like the following
Binary = true -> OF_None
Binary = false -> OF_TextWithCRLF

[rnk]

+@dexonsmith who touched this API last.

clang/include/clang/Frontend/CompilerInstance.h

738–740

I think this is only going to be worth it if we can roll up all of these booleans into a new flags enum for compiler instance. It also prevents introducing a new use of FileSystem.h, which is an expensive header to include.

[abhina.sreeskantharajan]

clang/include/clang/Frontend/CompilerInstance.h

738–740

Sorry, I don't think I completely understand your suggestion. Are you proposing that we create a new enum just for CompilerInstance.h for the other booleans like RemoveFileOnSignal, UseTemporary, CreateMissingDirectories? And this new enum also contain text/binary flags so we don't need to use the enum in FileSystem.h?

For background, I need this specific change to set some more text files with OF_Text because my old commit got reverted since it caused CRLF issues on Windows https://reviews.llvm.org/D96363.

[abhina.sreeskantharajan]

ping :)

[dexonsmith]

clang/include/clang/Frontend/CompilerInstance.h

738–740

Yes, I think that's what @rnk is suggesting, maybe along the lines of the OutputConfigFlag in the (languishing, I need to get back to it) OutputBackend/OutputManager proposal I have (see, e.g., https://reviews.llvm.org/D95501, which needs to be split up), or maybe as a struct with named members as @sammccall suggests there.

It also prevents introducing a new use of FileSystem.h, which is an expensive header to include.

Another option that'd be more isolated would be to split the OpenFlag enum (and/or its friends) out to another header in llvm/include/llvm/Support/FileSystem/ (say, .../FileSystem/FileSystemEnums.h), like was done for UniqueID.h.

[abhina.sreeskantharajan]

clang/include/clang/Frontend/CompilerInstance.h

738–740

Thanks for clarifying. I think having a duplicate copy of the OpenFlags may be confusing. I like the idea of putting the enums in its own header file. But can that be done in a separate change than this patch? It will be a much larger change touching more files than this patcch.

clang/include/clang/Frontend/CompilerInstance.h

public:
   ///
   /// The files created by this are usually removed on signal, and, depending
   /// on FrontendOptions, may also use a temporary file (that is, the data is
   /// written to a temporary file which will atomically replace the target
   /// output on success). If a client (like libclang) needs to disable
   /// RemoveFileOnSignal, temporary files will be forced on.
   ///
   /// \return - Null on error.
-  std::unique_ptr<raw_pwrite_stream>
-  createDefaultOutputFile(bool Binary = true, StringRef BaseInput = "",
-                          StringRef Extension = "",
-                          bool RemoveFileOnSignal = true,
-                          bool CreateMissingDirectories = false);
+  std::unique_ptr<raw_pwrite_stream> createDefaultOutputFile(
+      llvm::sys::fs::OpenFlags Flags = llvm::sys::fs::OF_None,
+      StringRef BaseInput = "", StringRef Extension = "",
+      bool RemoveFileOnSignal = true, bool CreateMissingDirectories = false);
 
   /// Create a new output file, optionally deriving the output path name, and
   /// add it to the list of tracked output files.
   ///
   /// \return - Null on error.
   std::unique_ptr<raw_pwrite_stream>
-  createOutputFile(StringRef OutputPath, bool Binary, bool RemoveFileOnSignal,
-                   bool UseTemporary, bool CreateMissingDirectories = false);
+  createOutputFile(StringRef OutputPath, llvm::sys::fs::OpenFlags Flags,
+                   bool RemoveFileOnSignal, bool UseTemporary,
+                   bool CreateMissingDirectories = false);
 
 private:
   /// Create a new output file and add it to the list of tracked output files.
   ///
   /// If \p OutputPath is empty, then createOutputFile will derive an output
   /// path location as \p BaseInput, with any suffix removed, and \p Extension
   /// appended. If \p OutputPath is not stdout and \p UseTemporary
   /// is true, createOutputFile will create a new temporary file that must be
   /// renamed to \p OutputPath in the end.
   ///
   /// \param OutputPath - If given, the path to the output file.
   /// \param Binary - The mode to open the file in.
   /// \param RemoveFileOnSignal - Whether the file should be registered with
   /// llvm::sys::RemoveFileOnSignal. Note that this is not safe for
   /// multithreaded use, as the underlying signal mechanism is not reentrant
   /// \param UseTemporary - Create a new temporary file that must be renamed to
   /// OutputPath in the end.
   /// \param CreateMissingDirectories - When \p UseTemporary is true, create
   /// missing directories in the output path.
   Expected<std::unique_ptr<raw_pwrite_stream>>
-  createOutputFileImpl(StringRef OutputPath, bool Binary,
+  createOutputFileImpl(StringRef OutputPath, llvm::sys::fs::OpenFlags Flags,
                        bool RemoveFileOnSignal, bool UseTemporary,
                        bool CreateMissingDirectories);
 
 public:
   std::unique_ptr<raw_pwrite_stream> createNullOutputFile();
 
   /// }
   /// @name Initialization Utility Methods
   /// {
 

clang/lib/CodeGen/CodeGenAction.cpp

llvm::LLVMContext *CodeGenAction::takeLLVMContext() {
   OwnsVMContext = false;
   return VMContext;
 }
 
 static std::unique_ptr<raw_pwrite_stream>
 GetOutputStream(CompilerInstance &CI, StringRef InFile, BackendAction Action) {
   switch (Action) {
   case Backend_EmitAssembly:
-    return CI.createDefaultOutputFile(false, InFile, "s");
+    return CI.createDefaultOutputFile(llvm::sys::fs::OF_TextWithCRLF, InFile,
+                                      "s");
   case Backend_EmitLL:
-    return CI.createDefaultOutputFile(false, InFile, "ll");
+    return CI.createDefaultOutputFile(llvm::sys::fs::OF_TextWithCRLF, InFile,
+                                      "ll");
   case Backend_EmitBC:
-    return CI.createDefaultOutputFile(true, InFile, "bc");
+    return CI.createDefaultOutputFile(llvm::sys::fs::OF_None, InFile, "bc");
   case Backend_EmitNothing:
     return nullptr;
   case Backend_EmitMCNull:
     return CI.createNullOutputFile();
   case Backend_EmitObj:
-    return CI.createDefaultOutputFile(true, InFile, "o");
+    return CI.createDefaultOutputFile(llvm::sys::fs::OF_None, InFile, "o");
   }
 
   llvm_unreachable("Invalid action!");
 }
 
 std::unique_ptr<ASTConsumer>
 CodeGenAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) {
   BackendAction BA = static_cast<BackendAction>(Act);

clang/lib/Frontend/CompilerInstance.cpp

void CompilerInstance::clearOutputFiles(bool EraseFiles) {
   OutputFiles.clear();
   if (DeleteBuiltModules) {
     for (auto &Module : BuiltModules)
       llvm::sys::fs::remove(Module.second);
     BuiltModules.clear();
   }
 }
 
-std::unique_ptr<raw_pwrite_stream>
-CompilerInstance::createDefaultOutputFile(bool Binary, StringRef InFile,
-                                          StringRef Extension,
-                                          bool RemoveFileOnSignal,
-                                          bool CreateMissingDirectories) {
+std::unique_ptr<raw_pwrite_stream> CompilerInstance::createDefaultOutputFile(
+    llvm::sys::fs::OpenFlags Flags, StringRef InFile, StringRef Extension,
+    bool RemoveFileOnSignal, bool CreateMissingDirectories) {
   StringRef OutputPath = getFrontendOpts().OutputFile;
   Optional<SmallString<128>> PathStorage;
   if (OutputPath.empty()) {
     if (InFile == "-" || Extension.empty()) {
       OutputPath = "-";
     } else {
       PathStorage.emplace(InFile);
       llvm::sys::path::replace_extension(*PathStorage, Extension);
       OutputPath = *PathStorage;
     }
   }
 
   // Force a temporary file if RemoveFileOnSignal was disabled.
-  return createOutputFile(OutputPath, Binary, RemoveFileOnSignal,
+  return createOutputFile(OutputPath, Flags, RemoveFileOnSignal,
                           getFrontendOpts().UseTemporary || !RemoveFileOnSignal,
                           CreateMissingDirectories);
 }
 
 std::unique_ptr<raw_pwrite_stream> CompilerInstance::createNullOutputFile() {
   return std::make_unique<llvm::raw_null_ostream>();
 }
 
-std::unique_ptr<raw_pwrite_stream>
-CompilerInstance::createOutputFile(StringRef OutputPath, bool Binary,
-                                   bool RemoveFileOnSignal, bool UseTemporary,
-                                   bool CreateMissingDirectories) {
+std::unique_ptr<raw_pwrite_stream> CompilerInstance::createOutputFile(
+    StringRef OutputPath, llvm::sys::fs::OpenFlags Flags,
+    bool RemoveFileOnSignal, bool UseTemporary, bool CreateMissingDirectories) {
   Expected<std::unique_ptr<raw_pwrite_stream>> OS =
-      createOutputFileImpl(OutputPath, Binary, RemoveFileOnSignal, UseTemporary,
+      createOutputFileImpl(OutputPath, Flags, RemoveFileOnSignal, UseTemporary,
                            CreateMissingDirectories);
   if (OS)
     return std::move(*OS);
   getDiagnostics().Report(diag::err_fe_unable_to_open_output)
       << OutputPath << errorToErrorCode(OS.takeError()).message();
   return nullptr;
 }
 
 Expected<std::unique_ptr<llvm::raw_pwrite_stream>>
-CompilerInstance::createOutputFileImpl(StringRef OutputPath, bool Binary,
+CompilerInstance::createOutputFileImpl(StringRef OutputPath,
+                                       llvm::sys::fs::OpenFlags Flags,
                                        bool RemoveFileOnSignal,
                                        bool UseTemporary,
                                        bool CreateMissingDirectories) {
   assert((!CreateMissingDirectories || UseTemporary) &&
          "CreateMissingDirectories is only allowed when using temporary files");
 
   std::unique_ptr<llvm::raw_fd_ostream> OS;
   Optional<StringRef> OSFile;
if (UseTemporary) {
     // artifacts, also append .tmp.
     StringRef OutputExtension = llvm::sys::path::extension(OutputPath);
     SmallString<128> TempPath =
         StringRef(OutputPath).drop_back(OutputExtension.size());
     TempPath += "-%%%%%%%%";
     TempPath += OutputExtension;
     TempPath += ".tmp";
     int fd;
-    std::error_code EC = llvm::sys::fs::createUniqueFile(
-        TempPath, fd, TempPath,
-        Binary ? llvm::sys::fs::OF_None : llvm::sys::fs::OF_Text);
+    std::error_code EC =
+        llvm::sys::fs::createUniqueFile(TempPath, fd, TempPath, Flags);
 
     if (CreateMissingDirectories &&
         EC == llvm::errc::no_such_file_or_directory) {
       StringRef Parent = llvm::sys::path::parent_path(OutputPath);
       EC = llvm::sys::fs::create_directories(Parent);
       if (!EC) {
-        EC = llvm::sys::fs::createUniqueFile(TempPath, fd, TempPath,
-                                             Binary ? llvm::sys::fs::OF_None
-                                                    : llvm::sys::fs::OF_Text);
+        EC = llvm::sys::fs::createUniqueFile(TempPath, fd, TempPath, Flags);
       }
     }
 
     if (!EC) {
       OS.reset(new llvm::raw_fd_ostream(fd, /*shouldClose=*/true));
       OSFile = TempFile = std::string(TempPath.str());
     }
     // If we failed to create the temporary, fallback to writing to the file
     // directly. This handles the corner case where we cannot write to the
     // 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_TextWithCRLF)));
+    OS.reset(new llvm::raw_fd_ostream(*OSFile, EC, Flags));
     if (EC)
       return llvm::errorCodeToError(EC);
   }
 
   // Make sure the out stream file gets removed if we crash.
   if (RemoveFileOnSignal)
     llvm::sys::RemoveFileOnSignal(*OSFile);
 
   // Add the output file -- but don't try to remove "-", since this means we are
   // using stdin.
   OutputFiles.emplace_back(((OutputPath != "-") ? OutputPath : "").str(),
                            std::move(TempFile));
 
-  if (!Binary || OS->supportsSeeking())
+  if ((Flags & llvm::sys::fs::OF_Text) || OS->supportsSeeking())
     return std::move(OS);
 
   return std::make_unique<llvm::buffer_unique_ostream>(std::move(OS));
 }
 
 // Initialization Utilities
 
 bool CompilerInstance::InitializeSourceManager(const FrontendInputFile &Input){

clang/lib/Frontend/FrontendActions.cpp

 
 //===----------------------------------------------------------------------===//
 // AST Consumer Actions
 //===----------------------------------------------------------------------===//
 
 std::unique_ptr<ASTConsumer>
 ASTPrintAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) {
   if (std::unique_ptr<raw_ostream> OS =
-          CI.createDefaultOutputFile(false, InFile))
+          CI.createDefaultOutputFile(llvm::sys::fs::OF_TextWithCRLF, InFile))
     return CreateASTPrinter(std::move(OS), CI.getFrontendOpts().ASTDumpFilter);
   return nullptr;
 }
 
 std::unique_ptr<ASTConsumer>
 ASTDumpAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) {
   const FrontendOptions &Opts = CI.getFrontendOpts();
   return CreateASTDumper(nullptr /*Dump to stdout.*/, Opts.ASTDumpFilter,
bool GeneratePCHAction::ComputeASTConsumerArguments(CompilerInstance &CI,
   return true;
 }
 
 std::unique_ptr<llvm::raw_pwrite_stream>
 GeneratePCHAction::CreateOutputFile(CompilerInstance &CI, StringRef InFile,
                                     std::string &OutputFile) {
   // Because this is exposed via libclang we must disable RemoveFileOnSignal.
   std::unique_ptr<raw_pwrite_stream> OS = CI.createDefaultOutputFile(
-      /*Binary=*/true, InFile, /*Extension=*/"", /*RemoveFileOnSignal=*/false);
+      llvm::sys::fs::OF_None, InFile, /*Extension=*/"",
+      /*RemoveFileOnSignal=*/false);
   if (!OS)
     return nullptr;
 
   OutputFile = CI.getFrontendOpts().OutputFile;
   return OS;
 }
 
 bool GeneratePCHAction::shouldEraseOutputFiles() {
if (CI.getFrontendOpts().OutputFile.empty()) {
 
     HeaderSearch &HS = CI.getPreprocessor().getHeaderSearchInfo();
     CI.getFrontendOpts().OutputFile =
         HS.getCachedModuleFileName(CI.getLangOpts().CurrentModule,
                                    ModuleMapFile);
   }
 
   // Because this is exposed via libclang we must disable RemoveFileOnSignal.
-  return CI.createDefaultOutputFile(/*Binary=*/true, InFile, /*Extension=*/"",
+  return CI.createDefaultOutputFile(llvm::sys::fs::OF_None, InFile,
+                                    /*Extension=*/"",
                                     /*RemoveFileOnSignal=*/false,
                                     /*CreateMissingDirectories=*/true);
 }
 
 bool GenerateModuleInterfaceAction::BeginSourceFileAction(
     CompilerInstance &CI) {
   if (!CI.getLangOpts().ModulesTS && !CI.getLangOpts().CPlusPlusModules) {
     CI.getDiagnostics().Report(diag::err_module_interface_requires_cpp_modules);
     return false;
   }
 
   CI.getLangOpts().setCompilingModule(LangOptions::CMK_ModuleInterface);
 
   return GenerateModuleAction::BeginSourceFileAction(CI);
 }
 
 std::unique_ptr<raw_pwrite_stream>
 GenerateModuleInterfaceAction::CreateOutputFile(CompilerInstance &CI,
                                                 StringRef InFile) {
-  return CI.createDefaultOutputFile(/*Binary=*/true, InFile, "pcm");
+  return CI.createDefaultOutputFile(llvm::sys::fs::OF_None, InFile, "pcm");
 }
 
 bool GenerateHeaderModuleAction::PrepareToExecuteAction(
     CompilerInstance &CI) {
   if (!CI.getLangOpts().Modules) {
     CI.getDiagnostics().Report(diag::err_header_module_requires_modules);
     return false;
   }
bool GenerateHeaderModuleAction::BeginSourceFileAction(
   HS.getModuleMap().createHeaderModule(CI.getLangOpts().CurrentModule, Headers);
 
   return GenerateModuleAction::BeginSourceFileAction(CI);
 }
 
 std::unique_ptr<raw_pwrite_stream>
 GenerateHeaderModuleAction::CreateOutputFile(CompilerInstance &CI,
                                              StringRef InFile) {
-  return CI.createDefaultOutputFile(/*Binary=*/true, InFile, "pcm");
+  return CI.createDefaultOutputFile(llvm::sys::fs::OF_None, InFile, "pcm");
 }
 
 SyntaxOnlyAction::~SyntaxOnlyAction() {
 }
 
 std::unique_ptr<ASTConsumer>
 SyntaxOnlyAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) {
   return std::make_unique<ASTConsumer>();
void PrintPreprocessedAction::ExecuteAction() {
   // In this fashion, the output format should match the input format, unless
   // the input format has inconsistent line endings.
   //
   // This should be a relatively fast operation since most files won't have
   // all of their source code on a single line. However, that is still a
   // concern, so if we scan for too long, we'll just assume the file should
   // be opened in binary mode.
 
-  bool BinaryMode = false;
+  llvm::sys::fs::OpenFlags Flags = llvm::sys::fs::OF_Text;
   if (llvm::Triple(LLVM_HOST_TRIPLE).isOSWindows()) {
-    BinaryMode = true;
+    Flags = llvm::sys::fs::OF_None;
     const SourceManager &SM = CI.getSourceManager();
     if (llvm::Optional<llvm::MemoryBufferRef> Buffer =
             SM.getBufferOrNone(SM.getMainFileID())) {
       const char *cur = Buffer->getBufferStart();
       const char *end = Buffer->getBufferEnd();
       const char *next = (cur != end) ? cur + 1 : end;
 
       // Limit ourselves to only scanning 256 characters into the source
       // file.  This is mostly a sanity check in case the file has no
       // newlines whatsoever.
       if (end - cur > 256)
         end = cur + 256;
 
       while (next < end) {
         if (*cur == 0x0D) {  // CR
           if (*next == 0x0A) // CRLF
-            BinaryMode = false;
+            Flags = llvm::sys::fs::OF_TextWithCRLF;
 
           break;
         } else if (*cur == 0x0A) // LF
           break;
 
         ++cur;
         ++next;
       }
     }
   }
 
   std::unique_ptr<raw_ostream> OS =
-      CI.createDefaultOutputFile(BinaryMode, getCurrentFileOrBufferName());
+      CI.createDefaultOutputFile(Flags, getCurrentFileOrBufferName());
   if (!OS) return;
 
   // If we're preprocessing a module map, start by dumping the contents of the
   // module itself before switching to the input buffer.
   auto &Input = getCurrentInput();
   if (Input.getKind().getFormat() == InputKind::ModuleMap) {
     if (Input.isFile()) {
       (*OS) << "# 1 \"";
if (Buffer) {
     unsigned Preamble =
         Lexer::ComputePreamble((*Buffer)->getBuffer(), CI.getLangOpts()).Size;
     llvm::outs().write((*Buffer)->getBufferStart(), Preamble);
   }
 }
 
 void DumpCompilerOptionsAction::ExecuteAction() {
   CompilerInstance &CI = getCompilerInstance();
-  std::unique_ptr<raw_ostream> OSP =
-      CI.createDefaultOutputFile(false, getCurrentFile());
+  std::unique_ptr<raw_ostream> OSP = CI.createDefaultOutputFile(
+      llvm::sys::fs::OF_TextWithCRLF, getCurrentFile());
   if (!OSP)
     return;
 
   raw_ostream &OS = *OSP;
   const Preprocessor &PP = CI.getPreprocessor();
   const LangOptions &LangOpts = PP.getLangOpts();
 
   // FIXME: Rather than manually format the JSON (which is awkward due to

clang/lib/Frontend/InterfaceStubFunctionsConsumer.cpp

struct Visitor : public RecursiveASTVisitor<Visitor> {
       std::set<const NamedDecl *> LateParsedDecls;
       std::set<NamedDecl *> NamedDecls;
       std::set<const ValueDecl *> ValueDecls;
     } v;
 
     v.TraverseDecl(context.getTranslationUnitDecl());
 
     MangledSymbols Symbols;
-    auto OS = Instance.createDefaultOutputFile(/*Binary=*/false, InFile, "ifs");
+    auto OS = Instance.createDefaultOutputFile(llvm::sys::fs::OF_TextWithCRLF,
+                                               InFile, "ifs");
     if (!OS)
       return;
 
     if (Instance.getLangOpts().DelayedTemplateParsing) {
       clang::Sema &S = Instance.getSema();
       for (const auto *FD : v.LateParsedDecls) {
         clang::LateParsedTemplate &LPT =
             *S.LateParsedTemplateMap.find(cast<FunctionDecl>(FD))->second;

clang/lib/Frontend/Rewrite/FrontendActions.cpp

 
 //===----------------------------------------------------------------------===//
 // AST Consumer Actions
 //===----------------------------------------------------------------------===//
 
 std::unique_ptr<ASTConsumer>
 HTMLPrintAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) {
   if (std::unique_ptr<raw_ostream> OS =
-          CI.createDefaultOutputFile(false, InFile))
+          CI.createDefaultOutputFile(llvm::sys::fs::OF_TextWithCRLF, InFile))
     return CreateHTMLPrinter(std::move(OS), CI.getPreprocessor());
   return nullptr;
 }
 
 FixItAction::FixItAction() {}
 FixItAction::~FixItAction() {}
 
 std::unique_ptr<ASTConsumer>
bool FixItRecompile::BeginInvocation(CompilerInstance &CI) {
 
   return true;
 }
 
 #if CLANG_ENABLE_OBJC_REWRITER
 
 std::unique_ptr<ASTConsumer>
 RewriteObjCAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) {
-  if (std::unique_ptr<raw_ostream> OS =
-          CI.createDefaultOutputFile(false, InFile, "cpp")) {
+  if (std::unique_ptr<raw_ostream> OS = CI.createDefaultOutputFile(
+          llvm::sys::fs::OF_TextWithCRLF, InFile, "cpp")) {
     if (CI.getLangOpts().ObjCRuntime.isNonFragile())
       return CreateModernObjCRewriter(
           std::string(InFile), std::move(OS), CI.getDiagnostics(),
           CI.getLangOpts(), CI.getDiagnosticOpts().NoRewriteMacros,
           (CI.getCodeGenOpts().getDebugInfo() != codegenoptions::NoDebugInfo));
     return CreateObjCRewriter(std::string(InFile), std::move(OS),
                               CI.getDiagnostics(), CI.getLangOpts(),
                               CI.getDiagnosticOpts().NoRewriteMacros);
   }
   return nullptr;
 }
 
 #endif
 
 //===----------------------------------------------------------------------===//
 // Preprocessor Actions
 //===----------------------------------------------------------------------===//
 
 void RewriteMacrosAction::ExecuteAction() {
   CompilerInstance &CI = getCompilerInstance();
-  std::unique_ptr<raw_ostream> OS =
-      CI.createDefaultOutputFile(/*Binary=*/true, getCurrentFileOrBufferName());
+  std::unique_ptr<raw_ostream> OS = CI.createDefaultOutputFile(
+      llvm::sys::fs::OF_None, getCurrentFileOrBufferName());
   if (!OS) return;
 
   RewriteMacrosInInput(CI.getPreprocessor(), OS.get());
 }
 
 void RewriteTestAction::ExecuteAction() {
   CompilerInstance &CI = getCompilerInstance();
-  std::unique_ptr<raw_ostream> OS =
-      CI.createDefaultOutputFile(/*Binary=*/false, getCurrentFileOrBufferName());
+  std::unique_ptr<raw_ostream> OS = CI.createDefaultOutputFile(
+      llvm::sys::fs::OF_TextWithCRLF, getCurrentFileOrBufferName());
   if (!OS) return;
 
   DoRewriteTest(CI.getPreprocessor(), OS.get());
 }
 
 class RewriteIncludesAction::RewriteImportsListener : public ASTReaderListener {
   CompilerInstance &CI;
   std::weak_ptr<raw_ostream> Out;
void visitModuleFile(StringRef Filename,
     });
 
     (*OS) << "#pragma clang module endbuild /*" << MF->ModuleName << "*/\n";
   }
 };
 
 bool RewriteIncludesAction::BeginSourceFileAction(CompilerInstance &CI) {
   if (!OutputStream) {
-    OutputStream =
-        CI.createDefaultOutputFile(/*Binary=*/true, getCurrentFileOrBufferName());
+    OutputStream = CI.createDefaultOutputFile(llvm::sys::fs::OF_None,
+                                              getCurrentFileOrBufferName());
     if (!OutputStream)
       return false;
   }
 
   auto &OS = *OutputStream;
 
   // If we're preprocessing a module map, start by dumping the contents of the
   // module itself before switching to the input buffer.

clang/tools/driver/cc1_main.cpp

int cc1_main(ArrayRef<const char *> Argv, const char *Argv0, void *MainAddr) {
   // If any timers were active but haven't been destroyed yet, print their
   // results now.  This happens in -disable-free mode.
   llvm::TimerGroup::printAll(llvm::errs());
   llvm::TimerGroup::clearAll();
 
   if (llvm::timeTraceProfilerEnabled()) {
     SmallString<128> Path(Clang->getFrontendOpts().OutputFile);
     llvm::sys::path::replace_extension(Path, "json");
-    if (auto profilerOutput = Clang->createOutputFile(
-            Path.str(), /*Binary=*/false, /*RemoveFileOnSignal=*/false,
+    if (auto profilerOutput =
+            Clang->createOutputFile(Path.str(), llvm::sys::fs::OF_TextWithCRLF,
+                                    /*RemoveFileOnSignal=*/false,
                                     /*useTemporary=*/false)) {
       llvm::timeTraceProfilerWrite(*profilerOutput);
       // FIXME(ibiryukov): make profilerOutput flush in destructor instead.
       profilerOutput->flush();
       llvm::timeTraceProfilerCleanup();
       Clang->clearOutputFiles(false);
     }
   }