Delete various FileSystem functions that are either dead or have direct LLVM equivalents.

[zturner]

Forgot to remove Stat declaration from header file.

[labath]

cool

lldb/include/lldb/Host/FileSystem.h

 #include <sys/stat.h>
 
 namespace lldb_private {
 class FileSystem {
 public:
   static const char *DEV_NULL;
   static const char *PATH_CONVERSION_ERROR;
 
-  static FileSpec::PathSyntax GetNativePathSyntax();
-
-  static lldb::user_id_t GetFileSize(const FileSpec &file_spec);
-  static bool GetFileExists(const FileSpec &file_spec);
-
-  static Error Hardlink(const FileSpec &src, const FileSpec &dst);
-  static int GetHardlinkCount(const FileSpec &file_spec);
   static Error Symlink(const FileSpec &src, const FileSpec &dst);
   static Error Readlink(const FileSpec &src, FileSpec &dst);
-  static Error Unlink(const FileSpec &file_spec);
 
   static Error ResolveSymbolicLink(const FileSpec &src, FileSpec &dst);
 
-  /// Return \b true if \a spec is on a locally mounted file system, \b false
-  /// otherwise.
-  static bool IsLocal(const FileSpec &spec);
-
   /// Wraps ::fopen in a platform-independent way. Once opened, FILEs can be
   /// manipulated and closed with the normal ::fread, ::fclose, etc. functions.
   static FILE *Fopen(const char *path, const char *mode);
 
   /// Wraps ::stat in a platform-independent way.
   static int Stat(const char *path, struct stat *stats);
 
   static llvm::sys::TimePoint<> GetModificationTime(const FileSpec &file_spec);
 };
 }
 
 #endif

lldb/source/Host/common/File.cpp

 #ifdef _WIN32
 #include "lldb/Host/windows/windows.h"
 #else
 #include <sys/ioctl.h>
 #include <termios.h>
 #endif
 
 #include "llvm/Support/ConvertUTF.h"
+#include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Process.h" // for llvm::sys::Process::FileDescriptorHasColors()
 
 #include "lldb/Host/Config.h"
 #include "lldb/Host/FileSpec.h"
-#include "lldb/Host/FileSystem.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/Error.h"
 #include "lldb/Utility/Log.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 static const char *GetStreamOpenModeFromOptions(uint32_t options) {
else {
     m_options = options;
   }
 
   return error;
 }
 
 uint32_t File::GetPermissions(const FileSpec &file_spec, Error &error) {
   if (file_spec) {
-    struct stat file_stats;
-    int stat_result = FileSystem::Stat(file_spec.GetCString(), &file_stats);
-    if (stat_result == -1)
-      error.SetErrorToErrno();
-    else {
-      error.Clear();
-      return file_stats.st_mode & (S_IRWXU | S_IRWXG | S_IRWXO);
-    }
+    auto Perms = llvm::sys::fs::getPermissions(file_spec.GetPath());
+    if (Perms)
+      return *Perms;
+    error = Error(Perms.getError());
+    return 0;
   } else
     error.SetErrorString("empty file spec");
   return 0;
 }
 
 uint32_t File::GetPermissions(Error &error) const {
   int fd = GetDescriptor();
   if (fd != kInvalidDescriptor) {

lldb/source/Host/common/Host.cpp

 
 // C++ Includes
 
 // Other libraries and framework includes
 // Project includes
 
 #include "lldb/Core/ArchSpec.h"
 #include "lldb/Host/FileSpec.h"
-#include "lldb/Host/FileSystem.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Host/HostInfo.h"
 #include "lldb/Host/HostProcess.h"
 #include "lldb/Host/MonitoringProcessLauncher.h"
 #include "lldb/Host/Predicate.h"
 #include "lldb/Host/ProcessLauncher.h"
 #include "lldb/Host/ThreadLauncher.h"
 #include "lldb/Target/FileAction.h"
if (timed_out) {
               command_output_ptr->assign(Buffer->GetChars(),
                                          Buffer->GetByteSize());
           }
         }
       }
     }
   }
 
-  if (FileSystem::GetFileExists(output_file_spec))
-    FileSystem::Unlink(output_file_spec);
+  llvm::sys::fs::remove(output_file_spec.GetPath());
   return error;
 }
 
 // LaunchProcessPosixSpawn for Apple, Linux, FreeBSD, NetBSD and other GLIBC
 // systems
 
 #if defined(__APPLE__) || defined(__linux__) || defined(__FreeBSD__) ||        \
     defined(__GLIBC__) || defined(__NetBSD__)

lldb/source/Host/macosx/Host.mm

 #include "lldb/Core/ArchSpec.h"
 #include "lldb/Core/Communication.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/StreamFile.h"
 #include "lldb/Core/StructuredData.h"
 #include "lldb/Host/ConnectionFileDescriptor.h"
 #include "lldb/Host/FileSpec.h"
-#include "lldb/Host/FileSystem.h"
 #include "lldb/Host/HostInfo.h"
 #include "lldb/Host/ThreadLauncher.h"
 #include "lldb/Target/Platform.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Utility/CleanUp.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/DataExtractor.h"
 #include "lldb/Utility/Endian.h"
if (lldb_error.Success() && accept_thread_result) {
     pid = (intptr_t)accept_thread_result;
 
     // Wait for process to be stopped at the entry point by watching
     // for the process status to be set to SSTOP which indicates it it
     // SIGSTOP'ed at the entry point
     WaitForProcessToSIGSTOP(pid, 5);
   }
 
-  FileSystem::Unlink(FileSpec{unix_socket_name, false});
+  llvm::sys::fs::remove(unix_socket_name.GetPath());
   [applescript release];
   if (pid != LLDB_INVALID_PROCESS_ID)
     launch_info.SetProcessID(pid);
   return error;
 }
 
 #endif // #if !defined(__arm__) && !defined(__arm64__) && !defined(__aarch64__)
 

lldb/source/Host/posix/DomainSocket.cpp

 //===-- DomainSocket.cpp ----------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Host/posix/DomainSocket.h"
 
-#include "lldb/Host/FileSystem.h"
+#include "llvm/Support/FileSystem.h"
 
 #include <stddef.h>
 #include <sys/socket.h>
 #include <sys/un.h>
 
 using namespace lldb;
 using namespace lldb_private;
 
if (error.Success())
     socket = new DomainSocket(conn_fd);
 
   return error;
 }
 
 size_t DomainSocket::GetNameOffset() const { return 0; }
 
 void DomainSocket::DeleteSocketFile(llvm::StringRef name) {
-  FileSystem::Unlink(FileSpec{name, true});
+  llvm::sys::fs::remove(name);
 }

lldb/source/Host/posix/FileSystem.cpp

 
 #include "llvm/Support/FileSystem.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 const char *FileSystem::DEV_NULL = "/dev/null";
 
-FileSpec::PathSyntax FileSystem::GetNativePathSyntax() {
-  return FileSpec::ePathSyntaxPosix;
-}
-
-lldb::user_id_t FileSystem::GetFileSize(const FileSpec &file_spec) {
-  return file_spec.GetByteSize();
-}
-
-bool FileSystem::GetFileExists(const FileSpec &file_spec) {
-  return file_spec.Exists();
-}
-
-Error FileSystem::Hardlink(const FileSpec &src, const FileSpec &dst) {
-  Error error;
-  if (::link(dst.GetCString(), src.GetCString()) == -1)
-    error.SetErrorToErrno();
-  return error;
-}
-
-int FileSystem::GetHardlinkCount(const FileSpec &file_spec) {
-  struct stat file_stat;
-  if (::stat(file_spec.GetCString(), &file_stat) == 0)
-    return file_stat.st_nlink;
-
-  return -1;
-}
-
 Error FileSystem::Symlink(const FileSpec &src, const FileSpec &dst) {
   Error error;
   if (::symlink(dst.GetCString(), src.GetCString()) == -1)
     error.SetErrorToErrno();
   return error;
 }
 
-Error FileSystem::Unlink(const FileSpec &file_spec) {
-  Error error;
-  if (::unlink(file_spec.GetCString()) == -1)
-    error.SetErrorToErrno();
-  return error;
-}
-
 Error FileSystem::Readlink(const FileSpec &src, FileSpec &dst) {
   Error error;
   char buf[PATH_MAX];
   ssize_t count = ::readlink(src.GetCString(), buf, sizeof(buf) - 1);
   if (count < 0)
     error.SetErrorToErrno();
   else {
     buf[count] = '\0'; // Success
if (realpath(resolved_path, real_path) == nullptr) {
     return err;
   }
 
   dst = FileSpec(real_path, false);
 
   return Error();
 }
 
-#if defined(__NetBSD__)
-static bool IsLocal(const struct statvfs &info) {
-  return (info.f_flag & MNT_LOCAL) != 0;
-}
-#else
-static bool IsLocal(const struct statfs &info) {
-#ifdef __linux__
-#define CIFS_MAGIC_NUMBER 0xFF534D42
-  switch ((uint32_t)info.f_type) {
-  case NFS_SUPER_MAGIC:
-  case SMB_SUPER_MAGIC:
-  case CIFS_MAGIC_NUMBER:
-    return false;
-  default:
-    return true;
-  }
-#else
-  return (info.f_flags & MNT_LOCAL) != 0;
-#endif
-}
-#endif
-
-#if defined(__NetBSD__)
-bool FileSystem::IsLocal(const FileSpec &spec) {
-  struct statvfs statfs_info;
-  std::string path(spec.GetPath());
-  if (statvfs(path.c_str(), &statfs_info) == 0)
-    return ::IsLocal(statfs_info);
-  return false;
-}
-#else
-bool FileSystem::IsLocal(const FileSpec &spec) {
-  struct statfs statfs_info;
-  std::string path(spec.GetPath());
-  if (statfs(path.c_str(), &statfs_info) == 0)
-    return ::IsLocal(statfs_info);
-  return false;
-}
-#endif
-
 FILE *FileSystem::Fopen(const char *path, const char *mode) {
   return ::fopen(path, mode);
 }
-
-int FileSystem::Stat(const char *path, struct stat *stats) {
-  return ::stat(path, stats);
-}

lldb/source/Host/posix/PipePosix.cpp

 //===-- PipePosix.cpp -------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Host/posix/PipePosix.h"
-#include "lldb/Host/FileSystem.h"
 #include "lldb/Host/HostInfo.h"
 #include "lldb/Utility/SelectHelper.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/Support/FileSystem.h"
 
 #if defined(__GNUC__) && (__GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 8))
 #ifndef _GLIBCXX_USE_NANOSLEEP
 #define _GLIBCXX_USE_NANOSLEEP

 }
 
 void PipePosix::Close() {
   CloseReadFileDescriptor();
   CloseWriteFileDescriptor();
 }
 
 Error PipePosix::Delete(llvm::StringRef name) {
-  return FileSystem::Unlink(FileSpec{name.data(), true});
+  return llvm::sys::fs::remove(name);
 }
 
 bool PipePosix::CanRead() const {
   return m_fds[READ] != PipePosix::kInvalidDescriptor;
 }
 
 bool PipePosix::CanWrite() const {
   return m_fds[WRITE] != PipePosix::kInvalidDescriptor;

lldb/source/Host/windows/FileSystem.cpp

 
 using namespace lldb_private;
 
 const char *FileSystem::DEV_NULL = "nul";
 
 const char *FileSystem::PATH_CONVERSION_ERROR =
     "Error converting path between UTF-8 and native encoding";
 
-FileSpec::PathSyntax FileSystem::GetNativePathSyntax() {
-  return FileSpec::ePathSyntaxWindows;
-}
-
-lldb::user_id_t FileSystem::GetFileSize(const FileSpec &file_spec) {
-  return file_spec.GetByteSize();
-}
-
-bool FileSystem::GetFileExists(const FileSpec &file_spec) {
-  return file_spec.Exists();
-}
-
-Error FileSystem::Hardlink(const FileSpec &src, const FileSpec &dst) {
-  Error error;
-  std::wstring wsrc, wdst;
-  if (!llvm::ConvertUTF8toWide(src.GetCString(), wsrc) ||
-      !llvm::ConvertUTF8toWide(dst.GetCString(), wdst))
-    error.SetErrorString(PATH_CONVERSION_ERROR);
-  else if (!::CreateHardLinkW(wsrc.c_str(), wdst.c_str(), nullptr))
-    error.SetError(::GetLastError(), lldb::eErrorTypeWin32);
-  return error;
-}
-
-int FileSystem::GetHardlinkCount(const FileSpec &file_spec) {
-  std::wstring path;
-  if (!llvm::ConvertUTF8toWide(file_spec.GetCString(), path))
-    return -1;
-
-  HANDLE file_handle =
-      ::CreateFileW(path.c_str(), FILE_READ_ATTRIBUTES, FILE_SHARE_READ,
-                    nullptr, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, nullptr);
-
-  if (file_handle == INVALID_HANDLE_VALUE)
-    return -1;
-
-  AutoHandle auto_file_handle(file_handle);
-  BY_HANDLE_FILE_INFORMATION file_info;
-  if (::GetFileInformationByHandle(file_handle, &file_info))
-    return file_info.nNumberOfLinks;
-
-  return -1;
-}
-
 Error FileSystem::Symlink(const FileSpec &src, const FileSpec &dst) {
   Error error;
   std::wstring wsrc, wdst;
   if (!llvm::ConvertUTF8toWide(src.GetCString(), wsrc) ||
       !llvm::ConvertUTF8toWide(dst.GetCString(), wdst))
     error.SetErrorString(PATH_CONVERSION_ERROR);
   if (error.Fail())
     return error;
   DWORD attrib = ::GetFileAttributesW(wdst.c_str());
   if (attrib == INVALID_FILE_ATTRIBUTES) {
     error.SetError(::GetLastError(), lldb::eErrorTypeWin32);
     return error;
   }
   bool is_directory = !!(attrib & FILE_ATTRIBUTE_DIRECTORY);
   DWORD flag = is_directory ? SYMBOLIC_LINK_FLAG_DIRECTORY : 0;
   BOOL result = ::CreateSymbolicLinkW(wsrc.c_str(), wdst.c_str(), flag);
   if (!result)
     error.SetError(::GetLastError(), lldb::eErrorTypeWin32);
   return error;
 }
 
-Error FileSystem::Unlink(const FileSpec &file_spec) {
-  Error error;
-  std::wstring path;
-  if (!llvm::ConvertUTF8toWide(file_spec.GetCString(), path)) {
-    error.SetErrorString(PATH_CONVERSION_ERROR);
-    return error;
-  }
-  BOOL result = ::DeleteFileW(path.c_str());
-  if (!result)
-    error.SetError(::GetLastError(), lldb::eErrorTypeWin32);
-  return error;
-}
-
 Error FileSystem::Readlink(const FileSpec &src, FileSpec &dst) {
   Error error;
   std::wstring wsrc;
   if (!llvm::ConvertUTF8toWide(src.GetCString(), wsrc)) {
     error.SetErrorString(PATH_CONVERSION_ERROR);
     return error;
   }
 
Error FileSystem::Readlink(const FileSpec &src, FileSpec &dst) {
   ::CloseHandle(h);
   return error;
 }
 
 Error FileSystem::ResolveSymbolicLink(const FileSpec &src, FileSpec &dst) {
   return Error("ResolveSymbolicLink() isn't implemented on Windows");
 }
 
-bool FileSystem::IsLocal(const FileSpec &spec) {
-  if (spec) {
-    // TODO: return true if the file is on a locally mounted file system
-    return true;
-  }
-
-  return false;
-}
-
 FILE *FileSystem::Fopen(const char *path, const char *mode) {
   std::wstring wpath, wmode;
   if (!llvm::ConvertUTF8toWide(path, wpath))
     return nullptr;
   if (!llvm::ConvertUTF8toWide(mode, wmode))
     return nullptr;
   FILE *file;
   if (_wfopen_s(&file, wpath.c_str(), wmode.c_str()) != 0)
     return nullptr;
   return file;
 }
-
-int FileSystem::Stat(const char *path, struct stat *stats) {
-  std::wstring wpath;
-  if (!llvm::ConvertUTF8toWide(path, wpath)) {
-    errno = EINVAL;
-    return -EINVAL;
-  }
-  int stat_result;
-#ifdef _USE_32BIT_TIME_T
-  struct _stat32 file_stats;
-  stat_result = ::_wstat32(wpath.c_str(), &file_stats);
-#else
-  struct _stat64i32 file_stats;
-  stat_result = ::_wstat64i32(wpath.c_str(), &file_stats);
-#endif
-  if (stat_result == 0) {
-    static_assert(sizeof(struct stat) == sizeof(file_stats),
-                  "stat and _stat32/_stat64i32 must have the same layout");
-    *stats = *reinterpret_cast<struct stat *>(&file_stats);
-  }
-  return stat_result;
-}

lldb/source/Plugins/Platform/POSIX/PlatformPOSIX.cpp

if (GetSupportsRSync()) {
       // if we are still here rsync has failed - let's try the slow way before
       // giving up
     }
   }
   return Platform::PutFile(source, destination, uid, gid);
 }
 
 lldb::user_id_t PlatformPOSIX::GetFileSize(const FileSpec &file_spec) {
-  if (IsHost())
-    return FileSystem::GetFileSize(file_spec);
-  else if (m_remote_platform_sp)
+  if (IsHost()) {
+    uint64_t Size;
+    if (llvm::sys::fs::file_size(file_spec.GetPath(), Size))
+      return 0;
+    return Size;
+  } else if (m_remote_platform_sp)
     return m_remote_platform_sp->GetFileSize(file_spec);
   else
     return Platform::GetFileSize(file_spec);
 }
 
 Error PlatformPOSIX::CreateSymlink(const FileSpec &src, const FileSpec &dst) {
   if (IsHost())
     return FileSystem::Symlink(src, dst);
bool PlatformPOSIX::GetFileExists(const FileSpec &file_spec) {
   else if (m_remote_platform_sp)
     return m_remote_platform_sp->GetFileExists(file_spec);
   else
     return Platform::GetFileExists(file_spec);
 }
 
 Error PlatformPOSIX::Unlink(const FileSpec &file_spec) {
   if (IsHost())
-    return FileSystem::Unlink(file_spec);
+    return llvm::sys::fs::remove(file_spec.GetPath());
   else if (m_remote_platform_sp)
     return m_remote_platform_sp->Unlink(file_spec);
   else
     return Platform::Unlink(file_spec);
 }
 
 lldb_private::Error PlatformPOSIX::GetFile(
     const lldb_private::FileSpec &source,      // remote file path

lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerCommon.cpp

 
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServerCommon::Handle_vFile_Size(
     StringExtractorGDBRemote &packet) {
   packet.SetFilePos(::strlen("vFile:size:"));
   std::string path;
   packet.GetHexByteString(path);
   if (!path.empty()) {
-    lldb::user_id_t retcode = FileSystem::GetFileSize(FileSpec(path, false));
+    uint64_t Size;
+    if (llvm::sys::fs::file_size(path, Size))
+      return SendErrorResponse(5);
     StreamString response;
     response.PutChar('F');
-    response.PutHex64(retcode);
-    if (retcode == UINT64_MAX) {
+    response.PutHex64(Size);
+    if (Size == UINT64_MAX) {
       response.PutChar(',');
-      response.PutHex64(
-          retcode); // TODO: replace with Host::GetSyswideErrorCode()
+      response.PutHex64(Size); // TODO: replace with Host::GetSyswideErrorCode()
     }
     return SendPacketNoLock(response.GetString());
   }
   return SendErrorResponse(22);
 }
 
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServerCommon::Handle_vFile_Mode(

 
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServerCommon::Handle_vFile_Exists(
     StringExtractorGDBRemote &packet) {
   packet.SetFilePos(::strlen("vFile:exists:"));
   std::string path;
   packet.GetHexByteString(path);
   if (!path.empty()) {
-    bool retcode = FileSystem::GetFileExists(FileSpec(path, false));
+    bool retcode = llvm::sys::fs::exists(path);
     StreamString response;
     response.PutChar('F');
     response.PutChar(',');
     if (retcode)
       response.PutChar('1');
     else
       response.PutChar('0');
     return SendPacketNoLock(response.GetString());

 }
 
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServerCommon::Handle_vFile_unlink(
     StringExtractorGDBRemote &packet) {
   packet.SetFilePos(::strlen("vFile:unlink:"));
   std::string path;
   packet.GetHexByteString(path);
-  Error error = FileSystem::Unlink(FileSpec{path, true});
+  Error error(llvm::sys::fs::remove(path));
   StreamString response;
   response.Printf("F%u,%u", error.GetError(), error.GetError());
   return SendPacketNoLock(response.GetString());
 }
 
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServerCommon::Handle_qPlatform_shell(
     StringExtractorGDBRemote &packet) {

lldb/source/Target/ModuleCache.cpp

 //===--------------------- ModuleCache.cpp ----------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Target/ModuleCache.h"
 
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleList.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Host/File.h"
-#include "lldb/Host/FileSystem.h"
 #include "lldb/Host/LockFile.h"
 #include "lldb/Utility/Log.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/FileUtilities.h"
 
 #include <assert.h>
 
 #include <cstdio>
void DeleteExistingModule(const FileSpec &root_dir_spec,
   Error error;
   ModuleLock lock(root_dir_spec, module_uuid, error);
   if (error.Fail()) {
     if (log)
       log->Printf("Failed to lock module %s: %s",
                   module_uuid.GetAsString().c_str(), error.AsCString());
   }
 
-  auto link_count = FileSystem::GetHardlinkCount(sysroot_module_path_spec);
-  if (link_count == -1)
+  namespace fs = llvm::sys::fs;
+  fs::file_status st;
+  if (status(sysroot_module_path_spec.GetPath(), st))
     return;
 
-  if (link_count > 2) // module is referred by other hosts.
+  if (st.getLinkCount() > 2) // module is referred by other hosts.
     return;
 
   const auto module_spec_dir = GetModuleDirectory(root_dir_spec, module_uuid);
   llvm::sys::fs::remove_directories(module_spec_dir.GetPath());
   lock.Delete();
 }
 
 void DecrementRefExistingModule(const FileSpec &root_dir_spec,
                                 const FileSpec &sysroot_module_path_spec) {
   // Remove $platform/.cache/$uuid folder if nobody else references it.
   DeleteExistingModule(root_dir_spec, sysroot_module_path_spec);
 
   // Remove sysroot link.
-  FileSystem::Unlink(sysroot_module_path_spec);
+  llvm::sys::fs::remove(sysroot_module_path_spec.GetPath());
 
   FileSpec symfile_spec = GetSymbolFileSpec(sysroot_module_path_spec);
-  if (symfile_spec.Exists()) // delete module's symbol file if exists.
-    FileSystem::Unlink(symfile_spec);
+  llvm::sys::fs::remove(symfile_spec.GetPath());
 }
 
 Error CreateHostSysRootModuleLink(const FileSpec &root_dir_spec,
                                   const char *hostname,
                                   const FileSpec &platform_module_spec,
                                   const FileSpec &local_module_spec,
                                   bool delete_existing) {
   const auto sysroot_module_path_spec =
       JoinPath(JoinPath(root_dir_spec, hostname),
                platform_module_spec.GetPath().c_str());
   if (sysroot_module_path_spec.Exists()) {
     if (!delete_existing)
       return Error();
 
     DecrementRefExistingModule(root_dir_spec, sysroot_module_path_spec);
   }
 
   const auto error = MakeDirectory(
       FileSpec(sysroot_module_path_spec.GetDirectory().AsCString(), false));
   if (error.Fail())
     return error;
 
-  return FileSystem::Hardlink(sysroot_module_path_spec, local_module_spec);
+  return llvm::sys::fs::create_hard_link(sysroot_module_path_spec.GetPath(),
+                                         local_module_spec.GetPath());
 }
 
 } // namespace
 
 ModuleLock::ModuleLock(const FileSpec &root_dir_spec, const UUID &uuid,
                        Error &error) {
   const auto lock_dir_spec = JoinPath(root_dir_spec, kLockDirName);
   error = MakeDirectory(lock_dir_spec);
error.SetErrorStringWithFormat("Failed to lock file: %s",
                                    error.AsCString());
 }
 
 void ModuleLock::Delete() {
   if (!m_file)
     return;
 
   m_file.Close();
-  FileSystem::Unlink(m_file_spec);
+  llvm::sys::fs::remove(m_file_spec.GetPath());
 }
 
 /////////////////////////////////////////////////////////////////////////
 
 Error ModuleCache::Put(const FileSpec &root_dir_spec, const char *hostname,
                        const ModuleSpec &module_spec, const FileSpec &tmp_file,
                        const FileSpec &target_file) {
   const auto module_spec_dir =

lldb/source/Target/Platform.cpp

log->Printf("Platform::Install (src='%s', dst='%s') fixed_dst='%s'",
                 fixed_dst.GetPath().c_str());
 
   if (GetSupportsRSync()) {
     error = PutFile(src, dst);
   } else {
     namespace fs = llvm::sys::fs;
     switch (fs::get_file_type(src.GetPath(), false)) {
     case fs::file_type::directory_file: {
-      if (GetFileExists(fixed_dst))
-        Unlink(fixed_dst);
+      llvm::sys::fs::remove(fixed_dst.GetPath());
       uint32_t permissions = src.GetPermissions();
       if (permissions == 0)
         permissions = eFilePermissionsDirectoryDefault;
       error = MakeDirectory(fixed_dst, permissions);
       if (error.Success()) {
         // Make a filespec that only fills in the directory of a FileSpec so
         // when we enumerate we can quickly fill in the filename for dst copies
         FileSpec recurse_dst;
         recurse_dst.GetDirectory().SetCString(fixed_dst.GetCString());
         std::string src_dir_path(src.GetPath());
         RecurseCopyBaton baton = {recurse_dst, this, Error()};
         FileSpec::EnumerateDirectory(src_dir_path, true, true, true,
                                      RecurseCopy_Callback, &baton);
         return baton.error;
       }
     } break;
 
     case fs::file_type::regular_file:
-      if (GetFileExists(fixed_dst))
-        Unlink(fixed_dst);
+      llvm::sys::fs::remove(fixed_dst.GetPath());
       error = PutFile(src, fixed_dst);
       break;
 
     case fs::file_type::symlink_file: {
-      if (GetFileExists(fixed_dst))
-        Unlink(fixed_dst);
+      llvm::sys::fs::remove(fixed_dst.GetPath());
       FileSpec src_resolved;
       error = FileSystem::Readlink(src, src_resolved);
       if (error.Success())
         error = CreateSymlink(dst, src_resolved);
     } break;
     case fs::file_type::fifo_file:
       error.SetErrorString("platform install doesn't handle pipes");
       break;