Rename openFileForRead/Write to openFileDescriptorForRead/Write

[zturner]

Summary

The motivation here is that the file_t based functions should
be preferred whenever possible and that should be "the one true
way" going forward to do file I/O.  That isn't quite possible
yet, so descriptor versions are still provided.  Subsequent
patches will try to convert the descriptor versions of the
functions over to the file_t based versions, improving Support
along the way as needed.  Eventually the ultimate goal is to
be able to remove the descriptor based functions.

[rnk]

lgtm

llvm/unittests/Support/raw_pwrite_stream_test.cpp

86–87

Oh dear, I'd forgotten about these old non Expected APIs. =(

clang-tools-extra/clang-move/tool/ClangMoveMain.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::F_Text))
+  if (std::error_code ec = llvm::sys::fs::openFileDescriptorForWrite(
+          path, fd, llvm::sys::fs::F_Text))
     return ec;
 
   return llvm::sys::Process::SafelyCloseFileDescriptor(fd);
 }
 
 cl::OptionCategory ClangMoveCategory("clang-move options");
 
 cl::list<std::string> Names("names", cl::CommaSeparated,

clang/lib/Basic/VirtualFileSystem.cpp

if (std::error_code EC = sys::fs::status(Path, RealStatus))
     return EC;
   return Status::copyWithNewName(RealStatus, Path.str());
 }
 
 ErrorOr<std::unique_ptr<File>>
 RealFileSystem::openFileForRead(const Twine &Name) {
   int FD;
   SmallString<256> RealName;
-  if (std::error_code EC = sys::fs::openFileForRead(Name, FD, &RealName))
+  if (std::error_code EC =
+          sys::fs::openFileDescriptorForRead(Name, FD, &RealName))
     return EC;
   return std::unique_ptr<File>(new RealFile(FD, Name.str(), RealName.str()));
 }
 
 llvm::ErrorOr<std::string> RealFileSystem::getCurrentWorkingDirectory() const {
   SmallString<256> Dir;
   if (std::error_code EC = llvm::sys::fs::current_path(Dir))
     return EC;

clang/lib/StaticAnalyzer/Core/HTMLDiagnostics.cpp

if (!AnalyzerOpts.shouldWriteStableReportFilename()) {
           Model = "";
           filename << "report-"
                    << llvm::sys::path::filename(Entry->getName()).str()
                    << "-" << declName.c_str()
                    << "-" << offsetDecl
                    << "-" << i << ".html";
           llvm::sys::path::append(Model, Directory,
                                   filename.str());
-          EC = llvm::sys::fs::openFileForWrite(Model,
-                                               FD,
-                                               llvm::sys::fs::F_RW |
-                                               llvm::sys::fs::F_Excl);
+          EC = llvm::sys::fs::openFileDescriptorForWrite(
+              Model, FD, llvm::sys::fs::F_RW | llvm::sys::fs::F_Excl);
           if (EC && EC != llvm::errc::file_exists) {
               llvm::errs() << "warning: could not create file '" << Model
                            << "': " << EC.message() << '\n';
               return;
           }
           i++;
       } while (EC);
   }

lld/ELF/Filesystem.cpp

if (!ThreadsEnabled || !sys::fs::exists(Path) ||
       !sys::fs::is_regular_file(Path))
     return;
 
   // We cannot just remove path from a different thread because we are now going
   // to create path as a new file.
   // Instead we open the file and unlink it on this thread. The unlink is fast
   // since the open fd guarantees that it is not removing the last reference.
   int FD;
-  std::error_code EC = sys::fs::openFileForRead(Path, FD);
+  std::error_code EC = sys::fs::openFileDescriptorForRead(Path, FD);
   sys::fs::remove(Path);
 
   // close and therefore remove TempPath in background.
   if (!EC)
     std::thread([=] { ::close(FD); }).detach();
 #endif
 }
 

lldb/source/Core/Debugger.cpp

if (m_log_callback_stream_sp) {
     if (pos != m_log_streams.end())
       log_stream_sp = pos->second.lock();
     if (!log_stream_sp) {
       llvm::sys::fs::OpenFlags flags = llvm::sys::fs::F_Text;
       if (log_options & LLDB_LOG_OPTION_APPEND)
         flags |= llvm::sys::fs::F_Append;
       int FD;
       if (std::error_code ec =
-              llvm::sys::fs::openFileForWrite(log_file, FD, flags)) {
+              llvm::sys::fs::openFileDescriptorForWrite(log_file, FD, flags)) {
         error_stream << "Unable to open log file: " << ec.message();
         return false;
       }
       log_stream_sp =
           std::make_shared<llvm::raw_fd_ostream>(FD, should_close, unbuffered);
       m_log_streams[log_file] = log_stream_sp;
     }
   }

llvm/include/llvm/Support/FileSystem.h

 /// @param Name The path of the file to open, relative or absolute.
 /// @param ResultFD If the file could be opened successfully, its descriptor
 ///                 is stored in this location. Otherwise, this is set to -1.
 /// @param Flags Additional flags used to determine whether the file should be
 ///              opened in, for example, read-write or in write-only mode.
 /// @param Mode The access permissions of the file, represented in octal.
 /// @returns errc::success if \a Name has been opened, otherwise a
 ///          platform-specific error_code.
-std::error_code openFileForWrite(const Twine &Name, int &ResultFD,
-                                 OpenFlags Flags, unsigned Mode = 0666);
+std::error_code openFileDescriptorForWrite(const Twine &Name, int &ResultFD,
+                                           OpenFlags Flags,
+                                           unsigned Mode = 0666);
 
 /// @brief Opens the file with the given name in a write-only or read-write
-/// mode, returning its open file descriptor. If the file does not exist, it
-/// is created.
+/// mode, returning either a native file object, or an error. If the file does
+/// not exist, it is created.
 ///
 /// The caller is responsible for closing the freeing the file once they are
-/// finished with it.
+/// finished with it by using the `closeFile` function.
 ///
 /// @param Name The path of the file to open, relative or absolute.
 /// @param Flags Additional flags used to determine whether the file should be
 ///              opened in, for example, read-write or in write-only mode.
 /// @param Mode The access permissions of the file, represented in octal.
 /// @returns a platform-specific file descriptor if \a Name has been opened,
 ///          otherwise an error object.
-Expected<file_t> openNativeFileForWrite(const Twine &Name, OpenFlags Flags,
-                                        unsigned Mode = 0666);
+Expected<file_t> openFileForWrite(const Twine &Name, OpenFlags Flags,
 
 /// @brief Opens the file with the given name in a read-only mode, returning
 /// its open file descriptor.
 ///
 /// The caller is responsible for closing the file descriptor once they are
 /// finished with it.
 ///
 /// @param Name The path of the file to open, relative or absolute.
 /// @param ResultFD If the file could be opened successfully, its descriptor
 ///                 is stored in this location. Otherwise, this is set to -1.
 /// @param RealPath If nonnull, extra work is done to determine the real path
 ///                 of the opened file, and that path is stored in this
 ///                 location.
 /// @returns errc::success if \a Name has been opened, otherwise a
 ///          platform-specific error_code.
-std::error_code openFileForRead(const Twine &Name, int &ResultFD,
-                                SmallVectorImpl<char> *RealPath = nullptr);
+std::error_code
+openFileDescriptorForRead(const Twine &Name, int &ResultFD,
 
 /// @brief Opens the file with the given name in a read-only mode, returning
-/// its open file descriptor.
+/// either a native file object, or an error.
 ///
 /// The caller is responsible for closing the freeing the file once they are
-/// finished with it.
+/// finished with it by using the `closeFile` function.
 ///
 /// @param Name The path of the file to open, relative or absolute.
 /// @param RealPath If nonnull, extra work is done to determine the real path
 ///                 of the opened file, and that path is stored in this
 ///                 location.
 /// @returns a platform-specific file descriptor if \a Name has been opened,
 ///          otherwise an error object.
-Expected<file_t>
-openNativeFileForRead(const Twine &Name,
+Expected<file_t> openFileForRead(const Twine &Name,
                                  SmallVectorImpl<char> *RealPath = nullptr);
 
 /// @brief Close the file object.  This should be used instead of ::close for
 /// portability.
 ///
 /// @param F On input, this is the file to close.  On output, the file is
 /// set to kInvalidFile.
 void closeFile(file_t &F);
 

llvm/lib/Object/ArchiveWriter.cpp

NewArchiveMember::getOldMember(const object::Archive::Child &OldMember,
   }
   return std::move(M);
 }
 
 Expected<NewArchiveMember> NewArchiveMember::getFile(StringRef FileName,
                                                      bool Deterministic) {
   sys::fs::file_status Status;
   int FD;
-  if (auto EC = sys::fs::openFileForRead(FileName, FD))
+  if (auto EC = sys::fs::openFileDescriptorForRead(FileName, FD))
     return errorCodeToError(EC);
   assert(FD != -1);
 
   if (auto EC = sys::fs::status(FD, Status))
     return errorCodeToError(EC);
 
   // Opening a directory doesn't make sense. Let it fail.
   // Linux cannot open directories with open(2), although

llvm/lib/Support/FileOutputBuffer.cpp

uint8_t *getBufferEnd() const override {
     return (uint8_t *)Buffer.base() + Buffer.size();
   }
 
   size_t getBufferSize() const override { return Buffer.size(); }
 
   Error commit() override {
     int FD;
     std::error_code EC;
-    if (auto EC = openFileForWrite(FinalPath, FD, fs::F_None, Mode))
+    if (auto EC = openFileDescriptorForWrite(FinalPath, FD, fs::F_None, Mode))
       return errorCodeToError(EC);
     raw_fd_ostream OS(FD, /*shouldClose=*/true, /*unbuffered=*/true);
     OS << StringRef((const char *)Buffer.base(), Buffer.size());
     return Error::success();
   }
 
 private:
   OwningMemoryBlock Buffer;

llvm/lib/Support/MemoryBuffer.cpp

getOpenFileImpl(int 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, int64_t FileSize, uint64_t MapSize,
            uint64_t Offset, bool RequiresNullTerminator, bool IsVolatile) {
   int FD;
-  std::error_code EC = sys::fs::openFileForRead(Filename, FD);
+  std::error_code EC = sys::fs::openFileDescriptorForRead(Filename, FD);
 
   if (EC)
     return EC;
 
   auto Ret = getOpenFileImpl<MB>(FD, Filename, FileSize, MapSize, Offset,
                                  RequiresNullTerminator, IsVolatile);
   close(FD);
   return Ret;
#endif
 
   return true;
 }
 
 static ErrorOr<std::unique_ptr<WriteThroughMemoryBuffer>>
 getReadWriteFile(const Twine &Filename, uint64_t FileSize, uint64_t MapSize,
                  uint64_t Offset) {
   int FD;
-  std::error_code EC = sys::fs::openFileForWrite(
+  std::error_code EC = sys::fs::openFileDescriptorForWrite(
       Filename, FD, sys::fs::F_RW | sys::fs::F_NoTrunc);
 
   if (EC)
     return EC;
 
   // Default is to map the full file.
   if (MapSize == uint64_t(-1)) {
     // If we don't know the file size, use fstat to find out.  fstat on an open
ErrorOr<std::unique_ptr<MemoryBuffer>> MemoryBuffer::getSTDIN() {
   sys::ChangeStdinToBinary();
 
   return getMemoryBufferForStream(0, "<stdin>");
 }
 
 ErrorOr<std::unique_ptr<MemoryBuffer>>
 MemoryBuffer::getFileAsStream(const Twine &Filename) {
   int FD;
-  std::error_code EC = sys::fs::openFileForRead(Filename, FD);
+  std::error_code EC = sys::fs::openFileDescriptorForRead(Filename, FD);
   if (EC)
     return EC;
   ErrorOr<std::unique_ptr<MemoryBuffer>> Ret =
       getMemoryBufferForStream(FD, Filename);
   close(FD);
   return Ret;
 }
 
 MemoryBufferRef MemoryBuffer::getMemBufferRef() const {
   StringRef Data = getBuffer();
   StringRef Identifier = getBufferIdentifier();
   return MemoryBufferRef(Data, Identifier);
 }
 
 void MemoryBuffer::anchor() {}
 void SmallVectorMemoryBuffer::anchor() {}

llvm/lib/Support/Path.cpp

retry_random_path:
   for (unsigned i = 0, e = ModelStorage.size(); i != e; ++i) {
     if (ModelStorage[i] == '%')
       ResultPath[i] = "0123456789abcdef"[sys::Process::GetRandomNumber() & 15];
   }
 
   // Try to open + create the file.
   switch (Type) {
   case FS_File: {
-    if (std::error_code EC =
-            sys::fs::openFileForWrite(Twine(ResultPath.begin()), ResultFD,
-                                      Flags | sys::fs::F_Excl, Mode)) {
+    if (std::error_code EC = sys::fs::openFileDescriptorForWrite(
+            Twine(ResultPath.begin()), ResultFD, Flags | sys::fs::F_Excl,
+            Mode)) {
       if (EC == errc::file_exists)
         goto retry_random_path;
       return EC;
     }
 
     return std::error_code();
   }
 
std::error_code create_directories(const Twine &Path, bool IgnoreExisting,
   if ((EC = create_directories(Parent, IgnoreExisting, Perms)))
       return EC;
 
   return create_directory(P, IgnoreExisting, Perms);
 }
 
 std::error_code copy_file(const Twine &From, const Twine &To) {
   int ReadFD, WriteFD;
-  if (std::error_code EC = openFileForRead(From, ReadFD))
+  if (std::error_code EC = openFileDescriptorForRead(From, ReadFD))
     return EC;
-  if (std::error_code EC = openFileForWrite(To, WriteFD, F_None)) {
+  if (std::error_code EC = openFileDescriptorForWrite(To, WriteFD, F_None)) {
     close(ReadFD);
     return EC;
   }
 
   const size_t BufSize = 4096;
   char *Buf = new char[BufSize];
   int BytesRead = 0, BytesWritten = 0;
   for (;;) {
if (BytesRead < 0)
     return std::error_code(errno, std::generic_category());
   MD5::MD5Result Result;
   Hash.final(Result);
   return Result;
 }
 
 ErrorOr<MD5::MD5Result> md5_contents(const Twine &Path) {
   int FD;
-  if (auto EC = openFileForRead(Path, FD))
+  if (auto EC = openFileDescriptorForRead(Path, FD))
     return EC;
 
   auto Result = md5_contents(FD);
   close(FD);
   return Result;
 }
 
 bool exists(const basic_file_status &status) {

llvm/lib/Support/TarWriter.cpp

static void writeUstarHeader(raw_fd_ostream &OS, StringRef Prefix,
   computeChecksum(Hdr);
   OS << StringRef(reinterpret_cast<char *>(&Hdr), sizeof(Hdr));
 }
 
 // Creates a TarWriter instance and returns it.
 Expected<std::unique_ptr<TarWriter>> TarWriter::create(StringRef OutputPath,
                                                        StringRef BaseDir) {
   int FD;
-  if (std::error_code EC = openFileForWrite(OutputPath, FD, sys::fs::F_None))
+  if (std::error_code EC =
+          openFileDescriptorForWrite(OutputPath, FD, sys::fs::F_None))
     return make_error<StringError>("cannot open " + OutputPath, EC);
   return std::unique_ptr<TarWriter>(new TarWriter(FD, BaseDir));
 }
 
 TarWriter::TarWriter(int FD, StringRef BaseDir)
     : OS(FD, /*shouldClose=*/true, /*unbuffered=*/false), BaseDir(BaseDir) {}
 
 // Append a given file to an archive.

llvm/lib/Support/Unix/Path.inc

 static bool hasProcSelfFD() {
   // If we have a /proc filesystem mounted, we can quickly establish the
   // real name of the file with readlink
   static const bool Result = (::access("/proc/self/fd", R_OK) == 0);
   return Result;
 }
 #endif
 
-std::error_code openFileForRead(const Twine &Name, int &ResultFD,
+std::error_code openFileDescriptorForRead(const Twine &Name, int &ResultFD,
                                           SmallVectorImpl<char> *RealPath) {
   SmallString<128> Storage;
   StringRef P = Name.toNullTerminatedStringRef(Storage);
   int OpenFlags = O_RDONLY;
 #ifdef O_CLOEXEC
   OpenFlags |= O_CLOEXEC;
 #endif
   if ((ResultFD = sys::RetryAfterSignal(-1, open, P.begin(), OpenFlags)) < 0)
     return std::error_code(errno, std::generic_category());
if (hasProcSelfFD()) {
     // Use ::realpath to get the real path name
     if (::realpath(P.begin(), Buffer) != nullptr)
       RealPath->append(Buffer, Buffer + strlen(Buffer));
   }
 #endif
   return std::error_code();
 }
 
-Expected<file_t> openNativeFileForRead(const Twine &Name,
-                                       SmallVectorImpl<char> *RealPath) {
+Expected<file_t> openFileForRead(const Twine &Name,
   file_t ResultFD;
-  std::error_code EC = openFileForRead(Name, ResultFD, RealPath);
+  std::error_code EC = openFileDescriptorForRead(Name, ResultFD, RealPath);
   if (EC)
     return errorCodeToError(EC);
   return ResultFD;
 }
 
-std::error_code openFileForWrite(const Twine &Name, int &ResultFD,
-                            sys::fs::OpenFlags Flags, unsigned Mode) {
+std::error_code openFileDescriptorForWrite(const Twine &Name, int &ResultFD,
+                                           sys::fs::OpenFlags Flags,
+                                           unsigned Mode) {
   // Verify that we don't have both "append" and "excl".
   assert((!(Flags & sys::fs::F_Excl) || !(Flags & sys::fs::F_Append)) &&
          "Cannot specify both 'excl' and 'append' file creation flags!");
 
   int OpenFlags = O_CREAT;
 
 #ifdef O_CLOEXEC
   OpenFlags |= O_CLOEXEC;

 #ifndef O_CLOEXEC
   int r = fcntl(ResultFD, F_SETFD, FD_CLOEXEC);
   (void)r;
   assert(r == 0 && "fcntl(F_SETFD, FD_CLOEXEC) failed");
 #endif
   return std::error_code();
 }
 
-Expected<file_t> openNativeFileForWrite(const Twine &Name, OpenFlags Flags,
-                                        unsigned Mode) {
+Expected<file_t> openFileForWrite(const Twine &Name, OpenFlags Flags,
   file_t ResultFD;
-  std::error_code EC = openFileForWrite(Name, ResultFD, Flags, Mode);
+  std::error_code EC = openFileDescriptorForWrite(Name, ResultFD, Flags, Mode);
   if (EC)
     return errorCodeToError(EC);
   return ResultFD;
 }
 
 void closeFile(file_t &F) {
   ::close(F);
   F = kInvalidFile;

llvm/lib/Support/Windows/Path.inc

static std::error_code nativeFileToFd(Expected<HANDLE> H, int &ResultFD,
   ResultFD = ::_open_osfhandle(intptr_t(*H), OpenFlags);
   if (ResultFD == -1) {
     ::CloseHandle(*H);
     return mapWindowsError(ERROR_INVALID_HANDLE);
   }
   return std::error_code();
 }
 
-std::error_code openFileForRead(const Twine &Name, int &ResultFD,
+std::error_code openFileDescriptorForRead(const Twine &Name, int &ResultFD,
                                           SmallVectorImpl<char> *RealPath) {
-  Expected<HANDLE> NativeFile = openNativeFileForRead(Name, RealPath);
+  Expected<HANDLE> NativeFile = openFileForRead(Name, RealPath);
   return nativeFileToFd(std::move(NativeFile), ResultFD, 0);
 }
 
-Expected<file_t> openNativeFileForRead(const Twine &Name,
-                                       SmallVectorImpl<char> *RealPath) {
+Expected<file_t> openFileForRead(const Twine &Name,
   SmallVector<wchar_t, 128> PathUTF16;
 
   if (std::error_code EC = widenPath(Name, PathUTF16))
     return errorCodeToError(EC);
 
   HANDLE H =
       ::CreateFileW(PathUTF16.begin(), GENERIC_READ,
                     FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
Expected<file_t> openFileForRead(const Twine &Name,
 
   // Fetch the real name of the file, if the user asked
   if (RealPath)
     realPathFromHandle(H, *RealPath);
 
   return H;
 }
 
-std::error_code openFileForWrite(const Twine &Name, int &ResultFD,
-                            sys::fs::OpenFlags Flags, unsigned Mode) {
+std::error_code openFileDescriptorForWrite(const Twine &Name, int &ResultFD,
+                                           sys::fs::OpenFlags Flags,
+                                           unsigned Mode) {
   int OpenFlags = 0;
   if (Flags & F_Append)
     OpenFlags |= _O_APPEND;
 
   if (Flags & F_Text)
     OpenFlags |= _O_TEXT;
 
-  Expected<HANDLE> NativeFile = openNativeFileForWrite(Name, Flags, Mode);
+  Expected<HANDLE> NativeFile = openFileForWrite(Name, Flags, Mode);
   return nativeFileToFd(std::move(NativeFile), ResultFD, OpenFlags);
 }
 
-Expected<file_t> openNativeFileForWrite(const Twine &Name, OpenFlags Flags,
-                                        unsigned Mode) {
+Expected<file_t> openFileForWrite(const Twine &Name, OpenFlags Flags,
   // Verify that we don't have both "append" and "excl".
   assert((!(Flags & sys::fs::F_Excl) || !(Flags & sys::fs::F_Append)) &&
          "Cannot specify both 'excl' and 'append' file creation flags!");
 
   SmallVector<wchar_t, 128> PathUTF16;
 
   if (std::error_code EC = widenPath(Name, PathUTF16))
     return errorCodeToError(EC);
if (expand_tilde) {
     expandTildeExpr(Storage);
     return real_path(Storage, dest, false);
   }
 
   if (is_directory(path))
     return directoryRealPath(path, dest);
 
   int fd;
-  if (std::error_code EC = llvm::sys::fs::openFileForRead(path, fd, &dest))
+  if (std::error_code EC =
+          llvm::sys::fs::openFileDescriptorForRead(path, fd, &dest))
     return EC;
   ::close(fd);
   return std::error_code();
 }
 
 } // end namespace fs
 
 namespace path {

llvm/lib/Support/raw_ostream.cpp

if (Filename == "-") {
     // If user requested binary then put stdout into binary mode if
     // possible.
     if (!(Flags & sys::fs::F_Text))
       sys::ChangeStdoutToBinary();
     return STDOUT_FILENO;
   }
 
   int FD;
-  EC = sys::fs::openFileForWrite(Filename, FD, Flags);
+  EC = sys::fs::openFileDescriptorForWrite(Filename, FD, Flags);
   if (EC)
     return -1;
 
   return FD;
 }
 
 raw_fd_ostream::raw_fd_ostream(StringRef Filename, std::error_code &EC,
                                sys::fs::OpenFlags Flags)

llvm/lib/XRay/InstrumentationMap.cpp

llvm::xray::loadInstrumentationMap(StringRef Filename) {
   // FIXME: Extend to support non-ELF and non-x86_64 binaries.
 
   InstrumentationMap Map;
   auto ObjectFileOrError = object::ObjectFile::createObjectFile(Filename);
   if (!ObjectFileOrError) {
     auto E = ObjectFileOrError.takeError();
     // We try to load it as YAML if the ELF load didn't work.
     int Fd;
-    if (sys::fs::openFileForRead(Filename, Fd))
+    if (sys::fs::openFileDescriptorForRead(Filename, Fd))
       return std::move(E);
 
     uint64_t FileSize;
     if (sys::fs::file_size(Filename, FileSize))
       return std::move(E);
 
     // If the file is empty, we return the original error.
     if (FileSize == 0)

llvm/lib/XRay/Trace.cpp

std::transform(Trace.Records.begin(), Trace.Records.end(),
                                      R.TSC,        R.TId, R.CallArgs};
                  });
   return Error::success();
 }
 } // namespace
 
 Expected<Trace> llvm::xray::loadTraceFile(StringRef Filename, bool Sort) {
   int Fd;
-  if (auto EC = sys::fs::openFileForRead(Filename, Fd)) {
+  if (auto EC = sys::fs::openFileDescriptorForRead(Filename, Fd)) {
     return make_error<StringError>(
         Twine("Cannot read log from '") + Filename + "'", EC);
   }
 
   uint64_t FileSize;
   if (auto EC = sys::fs::file_size(Filename, FileSize)) {
     return make_error<StringError>(
         Twine("Cannot read log from '") + Filename + "'", EC);

llvm/tools/gold/gold-plugin.cpp

if (TempOutFile) {
     if (EC)
       message(LDPL_FATAL, "Could not create temporary file: %s",
               EC.message().c_str());
   } else {
     NewFilename = InFilename;
     if (TaskID > 0)
       NewFilename += utostr(TaskID);
     std::error_code EC =
-        sys::fs::openFileForWrite(NewFilename, FD, sys::fs::F_None);
+        sys::fs::openFileDescriptorForWrite(NewFilename, FD, sys::fs::F_None);
     if (EC)
       message(LDPL_FATAL, "Could not open file %s: %s", NewFilename.c_str(),
               EC.message().c_str());
   }
   return FD;
 }
 
 static CodeGenOpt::Level getCGOptLevel() {

llvm/tools/llvm-ar/llvm-ar.cpp

 // system.
 static void doExtract(StringRef Name, const object::Archive::Child &C) {
   // Retain the original mode.
   Expected<sys::fs::perms> ModeOrErr = C.getAccessMode();
   failIfError(ModeOrErr.takeError());
   sys::fs::perms Mode = ModeOrErr.get();
 
   int FD;
-  failIfError(sys::fs::openFileForWrite(sys::path::filename(Name), FD,
+  failIfError(sys::fs::openFileDescriptorForWrite(sys::path::filename(Name), FD,
                                                   sys::fs::F_None, Mode),
               Name);
 
   {
     raw_fd_ostream file(FD, false);
 
     // Get the data and its length
     Expected<StringRef> BufOrErr = C.getBuffer();
     failIfError(BufOrErr.takeError());

llvm/tools/llvm-cov/TestingSupport.cpp

int convertForTestingMain(int argc, const char *argv[]) {
   uint64_t ProfileNamesAddress = ProfileNames.getAddress();
   StringRef CoverageMappingData;
   StringRef ProfileNamesData;
   if (CoverageMapping.getContents(CoverageMappingData) ||
       ProfileNames.getContents(ProfileNamesData))
     return 1;
 
   int FD;
-  if (auto Err =
-          sys::fs::openFileForWrite(OutputFilename, FD, sys::fs::F_None)) {
+  if (auto Err = sys::fs::openFileDescriptorForWrite(OutputFilename, FD,
+                                                     sys::fs::F_None)) {
     errs() << "error: " << Err.message() << "\n";
     return 1;
   }
 
   raw_fd_ostream OS(FD, true);
   OS << "llvmcovmtestdata";
   encodeULEB128(ProfileNamesData.size(), OS);
   encodeULEB128(ProfileNamesAddress, OS);
   OS << ProfileNamesData;
   // Coverage mapping data is expected to have an alignment of 8.
   for (unsigned Pad = OffsetToAlignment(OS.tell(), 8); Pad; --Pad)
     OS.write(uint8_t(0));
   OS << CoverageMappingData;
 
   return 0;
 }

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

 
 // FIXME: Change the API to let the caller handle errors.
 void InstructionBenchmark::writeYamlOrDie(const llvm::StringRef Filename) {
   if (Filename == "-") {
     writeYamlTo(llvm::outs());
   } else {
     int ResultFD = 0;
     llvm::cantFail(llvm::errorCodeToError(
-        openFileForWrite(Filename, ResultFD, llvm::sys::fs::F_Text)));
+        openFileDescriptorForWrite(Filename, ResultFD, llvm::sys::fs::F_Text)));
     llvm::raw_fd_ostream Ostr(ResultFD, true /*shouldClose*/);
     writeYamlTo(Ostr);
   }
 }
 
 void BenchmarkMeasureStats::push(const BenchmarkMeasure &BM) {
   if (Key.empty())
     Key = BM.Key;
   assert(Key == BM.Key);
   ++NumValues;
   SumValues += BM.Value;
   MaxValue = std::max(MaxValue, BM.Value);
   MinValue = std::min(MinValue, BM.Value);
 }
 
 } // namespace exegesis

llvm/unittests/Support/Host.cpp

TEST_F(HostTest, getMacOSHostVersion) {
   StringRef OutputPath = OutputFile.str();
   const Optional<StringRef> Redirects[] = {/*STDIN=*/None,
                                            /*STDOUT=*/OutputPath,
                                            /*STDERR=*/None};
   int RetCode = ExecuteAndWait(SwVersPath, argv, /*env=*/nullptr, Redirects);
   ASSERT_EQ(0, RetCode);
 
   int FD = 0;
-  ASSERT_NO_ERROR(fs::openFileForRead(OutputPath, FD));
+  ASSERT_NO_ERROR(fs::openFileDescriptorForRead(OutputPath, FD));
   off_t Size = ::lseek(FD, 0, SEEK_END);
   ASSERT_NE(-1, Size);
   ::lseek(FD, 0, SEEK_SET);
   std::unique_ptr<char[]> Buffer = llvm::make_unique<char[]>(Size);
   ASSERT_EQ(::read(FD, Buffer.get(), Size), Size);
   ::close(FD);
 
   // Ensure that the two versions match.

llvm/unittests/Support/LockFileManagerTest.cpp

TEST(LockFileManagerTest, LinkLockExists) {
 
   SmallString<64> FileLocK(TmpDir);
   sys::path::append(FileLocK, "file.lock");
 
   SmallString<64> TmpFileLock(TmpDir);
   sys::path::append(TmpFileLock, "file.lock-000");
 
   int FD;
-  EC = sys::fs::openFileForWrite(StringRef(TmpFileLock), FD, sys::fs::F_None);
+  EC = sys::fs::openFileDescriptorForWrite(StringRef(TmpFileLock), FD,
+                                           sys::fs::F_None);
   ASSERT_FALSE(EC);
 
   int Ret = close(FD);
   ASSERT_EQ(Ret, 0);
 
   EC = sys::fs::create_link(TmpFileLock.str(), FileLocK.str());
   ASSERT_FALSE(EC);
 

llvm/unittests/Support/MemoryBufferTest.cpp

void MemoryBufferTest::testGetOpenFileSlice(bool Reopen) {
   // immediately visible through the fd.
   raw_fd_ostream OF(TestFD, true, !Reopen);
   for (int i = 0; i < 60000; ++i) {
     OF << "0123456789";
   }
 
   if (Reopen) {
     OF.close();
-    EXPECT_FALSE(sys::fs::openFileForRead(TestPath.c_str(), TestFD));
+    EXPECT_FALSE(sys::fs::openFileDescriptorForRead(TestPath.c_str(), TestFD));
   }
 
   ErrorOr<OwningBuffer> Buf =
       MemoryBuffer::getOpenFileSlice(TestFD, TestPath.c_str(),
                                      40000, // Size
                                      80000  // Offset
                                      );
 

llvm/unittests/Support/Path.cpp

StringRef Val("hello there");
     mfr.data()[Val.size()] = 0;
     // Unmap temp file
   }
   ASSERT_EQ(close(FileDescriptor), 0);
 
   // Map it back in read-only
   {
     int FD;
-    EC = fs::openFileForRead(Twine(TempPath), FD);
+    EC = fs::openFileDescriptorForRead(Twine(TempPath), FD);
     ASSERT_NO_ERROR(EC);
     fs::mapped_file_region mfr(FD, fs::mapped_file_region::readonly, Size, 0, EC);
     ASSERT_NO_ERROR(EC);
 
     // Verify content
     EXPECT_EQ(StringRef(mfr.const_data()), Val);
 
     // Unmap temp file
TEST_F(FileSystemTest, OpenFileForRead) {
   FileRemover Cleanup(TempPath);
 
   // Make sure it exists.
   ASSERT_TRUE(sys::fs::exists(Twine(TempPath)));
 
   // Open the file for read
   int FileDescriptor2;
   SmallString<64> ResultPath;
-  ASSERT_NO_ERROR(
-      fs::openFileForRead(Twine(TempPath), FileDescriptor2, &ResultPath))
+  ASSERT_NO_ERROR(fs::openFileDescriptorForRead(Twine(TempPath),
+                                                FileDescriptor2, &ResultPath))
 
   // If we succeeded, check that the paths are the same (modulo case):
   if (!ResultPath.empty()) {
     // The paths returned by createTemporaryFile and getPathFromOpenFD
     // should reference the same file on disk.
     fs::UniqueID D1, D2;
     ASSERT_NO_ERROR(fs::getUniqueID(Twine(TempPath), D1));
     ASSERT_NO_ERROR(fs::getUniqueID(Twine(ResultPath), D2));

llvm/unittests/Support/ProgramTest.cpp

TEST(ProgramTest, TestWriteWithSystemEncoding) {
   errs() << "Test Directory: " << TestDirectory << '\n';
   errs().flush();
   SmallString<128> file_pathname(TestDirectory);
   path::append(file_pathname, "international-file.txt");
   // Only on Windows we should encode in UTF16. For other systems, use UTF8
   ASSERT_NO_ERROR(sys::writeFileWithEncoding(file_pathname.c_str(), utf8_text,
                                              sys::WEM_UTF16));
   int fd = 0;
-  ASSERT_NO_ERROR(fs::openFileForRead(file_pathname.c_str(), fd));
+  ASSERT_NO_ERROR(fs::openFileDescriptorForRead(file_pathname.c_str(), fd));
 #if defined(_WIN32)
   char buf[18];
   ASSERT_EQ(::read(fd, buf, 18), 18);
   if (strncmp(buf, "\xfe\xff", 2) == 0) { // UTF16-BE
     ASSERT_EQ(strncmp(&buf[2], utf16be_text, 16), 0);
   } else if (strncmp(buf, "\xff\xfe", 2) == 0) { // UTF16-LE
     ASSERT_EQ(strncmp(&buf[2], utf16le_text, 16), 0);
   } else {

llvm/unittests/Support/ReplaceFileTest.cpp

if (std::error_code ASSERT_NO_ERROR_ec = x) {                          \
              << "error message: " << ASSERT_NO_ERROR_ec.message() << "\n"; \
     }                                                                      \
   } while (false)
 
 namespace {
 std::error_code CreateFileWithContent(const SmallString<128> &FilePath,
                                       const StringRef &content) {
   int FD = 0;
-  if (std::error_code ec = fs::openFileForWrite(FilePath, FD, fs::F_None))
+  if (std::error_code ec =
+          fs::openFileDescriptorForWrite(FilePath, FD, fs::F_None))
     return ec;
 
   const bool ShouldClose = true;
   raw_fd_ostream OS(FD, ShouldClose);
   OS << content;
 
   return std::error_code();
 }

 bool FDHasContent(int FD, StringRef Content) {
   auto Buffer = MemoryBuffer::getOpenFile(FD, "", -1);
   assert(Buffer);
   return Buffer.get()->getBuffer() == Content;
 }
 
 bool FileHasContent(StringRef File, StringRef Content) {
   int FD = 0;
-  auto EC = fs::openFileForRead(File, FD);
+  auto EC = fs::openFileDescriptorForRead(File, FD);
   (void)EC;
   assert(!EC);
   ScopedFD EventuallyCloseIt(FD);
   return FDHasContent(FD, Content);
 }
 
 TEST(rename, FileOpenedForReadingCanBeReplaced) {
   // Create unique temporary directory for this test.
TEST(rename, FileOpenedForReadingCanBeReplaced) {
   path::append(TargetFileName, "target");
 
   ASSERT_NO_ERROR(CreateFileWithContent(SourceFileName, "!!source!!"));
   ASSERT_NO_ERROR(CreateFileWithContent(TargetFileName, "!!target!!"));
 
   {
     // Open the target file for reading.
     int ReadFD = 0;
-    ASSERT_NO_ERROR(fs::openFileForRead(TargetFileName, ReadFD));
+    ASSERT_NO_ERROR(fs::openFileDescriptorForRead(TargetFileName, ReadFD));
     ScopedFD EventuallyCloseIt(ReadFD);
 
     // Confirm we can replace the file while it is open.
     EXPECT_TRUE(!fs::rename(SourceFileName, TargetFileName));
 
     // We should still be able to read the old data through the existing
     // descriptor.
     EXPECT_TRUE(FDHasContent(ReadFD, "!!target!!"));
TEST(rename, ExistingTemp) {
 
   {
     // Use mapped_file_region to make sure that the destination file is mmap'ed.
     // This will cause SetInformationByHandle to fail when renaming to the
     // destination, and we will follow the code path that tries to give target
     // a temporary name.
     int TargetFD;
     std::error_code EC;
-    ASSERT_NO_ERROR(fs::openFileForRead(TargetFileName, TargetFD));
+    ASSERT_NO_ERROR(fs::openFileDescriptorForRead(TargetFileName, TargetFD));
     ScopedFD X(TargetFD);
     sys::fs::mapped_file_region MFR(
         TargetFD, sys::fs::mapped_file_region::readonly, 10, 0, EC);
     ASSERT_FALSE(EC);
 
     ASSERT_NO_ERROR(fs::rename(SourceFileName, TargetFileName));
 
 #ifdef _WIN32
     // Make sure that target was temporarily renamed to target.tmp1 on Windows.
     // This is signified by a permission denied error as opposed to no such file
     // or directory when trying to open it.
     int Tmp1FD;
     EXPECT_EQ(errc::permission_denied,
-              fs::openFileForRead(TargetTmp1FileName, Tmp1FD));
+              fs::openFileDescriptorForRead(TargetTmp1FileName, Tmp1FD));
 #endif
   }
 
   EXPECT_TRUE(FileHasContent(TargetTmp0FileName, "!!target.tmp0!!"));
 
   ASSERT_NO_ERROR(fs::remove(TargetFileName));
   ASSERT_NO_ERROR(fs::remove(TargetTmp0FileName));
   ASSERT_NO_ERROR(fs::remove(TestDirectory.str()));
 }
 
 }  // anonymous namespace

llvm/unittests/Support/raw_pwrite_stream_test.cpp

TEST(raw_pwrite_ostreamTest, TestFD) {
 
   // If we want to clean up from a death test, we have to remove the file from
   // the parent process. Have the parent create the file, pass it via
   // environment variable to the child, let the child crash, and then remove it
   // in the parent.
   const char *ParentPath = getenv("RAW_PWRITE_TEST_FILE");
   if (ParentPath) {
     Path = ParentPath;
-    ASSERT_NO_ERROR(sys::fs::openFileForRead(Path, FD));
+    ASSERT_NO_ERROR(sys::fs::openFileDescriptorForRead(Path, FD));
   } else {
     ASSERT_NO_ERROR(sys::fs::createTemporaryFile("foo", "bar", FD, Path));
     setenv("RAW_PWRITE_TEST_FILE", Path.c_str(), true);
   }
   FileRemover Cleanup(Path);
 
   raw_fd_ostream OS(FD, true);
   OS << "abcd";
   StringRef Test = "test";
   OS.pwrite(Test.data(), Test.size(), 0);
   OS.pwrite(Test.data(), Test.size(), 0);
 
 #ifdef GTEST_HAS_DEATH_TEST
 #ifndef NDEBUG
   EXPECT_DEATH(OS.pwrite("12345", 5, 0),
                "We don't support extending the stream");
 #endif
 #endif
 }
 
 #ifdef LLVM_ON_UNIX
 TEST(raw_pwrite_ostreamTest, TestDevNull) {
   int FD;
-  sys::fs::openFileForWrite("/dev/null", FD, sys::fs::F_None);
+  sys::fs::openFileDescriptorForWrite("/dev/null", FD, sys::fs::F_None);
   raw_fd_ostream OS(FD, true);
   OS << "abcd";
   StringRef Test = "test";
   OS.pwrite(Test.data(), Test.size(), 0);
   OS.pwrite(Test.data(), Test.size(), 0);
 }
 #endif
 }