Resubmit "Use LLVM for all stat related calls"

[zturner]

Summary

This was broken due to LLVM's stat code following symlinks. I've added an option on the LLVM side to not follow symlinks and updated this patch to use it everywhere possible. The cases I couldn't get were where LLDB calls is_directory / is_regular_file / exists, etc. Those would return false on symlinks before, but now return true if the target is a directory / file / exists. I don't think that should be an issue, as I think generally that's what'e expected.

I can test this on Linux in a couple of hours unless someone beats me to it.

[labath]

Unfortunately, this does not seem to help. I'll try to debug today if I can find the time.

lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

197

This still breaks TestCompDirSymLink.py. I haven't yet dug into why, but it looks like some problem in the get_file_type implementation.

lldb/source/Target/ModuleCache.cpp

70

This changes behavior (and breaks ModuleCache unit tests). The point of this was to check whether path is a directory, so if we cannot stat it, we should still try to create it.

[labath]

lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

197

ok, so the problem is in llvm::sys::fs::fillStatus implementation. It is missing the call to S_ISLNK to decode the symlink bit (probably because it was not necessary until now).

[zturner]

lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

197

I literally just came to the same conclusion. Glad we agree on the fix! I'll also do a full audit of all the changes in regards to your other comment about the functionality change, and make sure that same mistake does not appear anywhere else.

[zturner]

Fixed all the outstanding issues. I simplified the logic in ModuleCache, but I think it makes more sense this way, and the unit tests still pass. If we really care about the case where we want to create a directory on top of an existing broken symbolic link, we can see about adding that to LLVM, but in pratcice I don't think it matters.

I also went back and audited all the existing uses of the various functions, and I think they are all correct. Will run the entire test suite in a bit.

[labath]

OK, let's give this another shot. (I haven't tried it on linux yet, so if you haven't either then let's wait until tomorrow, or maybe @eugene could try it out (?)). I don't think we need to be worried about symlink overwrite in the ModuleCache test.

llvm/include/llvm/Support/FileSystem.h

500

missing closing paren here

lldb/include/lldb/Host/FileSpec.h

 
 // Other libraries and framework includes
 // Project includes
 #include "lldb/Host/PosixApi.h"
 #include "lldb/Utility/ConstString.h"
 #include "lldb/lldb-private.h"
 
 #include "llvm/ADT/Triple.h"
+#include "llvm/Support/FileSystem.h"
 #include "llvm/Support/FormatVariadic.h"
 
 namespace lldb_private {
 
 //----------------------------------------------------------------------
 /// @class FileSpec FileSpec.h "lldb/Host/FileSpec.h"
 /// @brief A file utility class.
 ///
 /// A file specification class that divides paths up into a directory
 /// and basename. These string values of the paths are put into uniqued
 /// string pools for fast comparisons and efficient memory usage.
 ///
 /// Another reason the paths are split into the directory and basename
 /// is to allow efficient debugger searching. Often in a debugger the
 /// user types in the basename of the file, for example setting a
 /// breakpoint by file and line, or specifying a module (shared library)
 /// to limit the scope in which to execute a command. The user rarely
 /// types in a full path. When the paths are already split up, it makes
 /// it easy for us to compare only the basenames of a lot of file
 /// specifications without having to split up the file path each time
 /// to get to the basename.
 //----------------------------------------------------------------------
 class FileSpec {
 public:
-  typedef enum FileType {
-    eFileTypeInvalid = -1,
-    eFileTypeUnknown = 0,
-    eFileTypeDirectory,
-    eFileTypePipe,
-    eFileTypeRegular,
-    eFileTypeSocket,
-    eFileTypeSymbolicLink,
-    eFileTypeOther
-  } FileType;
-
   enum PathSyntax {
     ePathSyntaxPosix,
     ePathSyntaxWindows,
     ePathSyntaxHostNative
   };
 
   FileSpec();
 
public:
   /// is returned)
   ///
   /// @return
   ///     Returns the filename without extension
   ///     as a ConstString object.
   //------------------------------------------------------------------
   ConstString GetFileNameStrippingExtension() const;
 
-  FileType GetFileType() const;
-
   //------------------------------------------------------------------
   /// Return the current permissions of the path.
   ///
   /// Returns a bitmask for the current permissions of the file
   /// ( zero or more of the permission bits defined in
   /// File::Permissions).
   ///
   /// @return
   ///     Zero if the file doesn't exist or we are unable to get
   ///     information for the file, otherwise one or more permission
   ///     bits from the File::Permissions enumeration.
   //------------------------------------------------------------------
   uint32_t GetPermissions() const;
 
-  bool IsDirectory() const {
-    return GetFileType() == FileSpec::eFileTypeDirectory;
-  }
-
-  bool IsPipe() const { return GetFileType() == FileSpec::eFileTypePipe; }
-
-  bool IsRegularFile() const {
-    return GetFileType() == FileSpec::eFileTypeRegular;
-  }
-
-  bool IsSocket() const { return GetFileType() == FileSpec::eFileTypeSocket; }
-
-  bool IsSymbolicLink() const;
-
   //------------------------------------------------------------------
   /// Get the memory cost of this object.
   ///
   /// Return the size in bytes that this object takes in memory. This
   /// returns the size in bytes of this object, not any shared string
   /// values it may refer to.
   ///
   /// @return
enum EnumerateDirectoryResult {
     eEnumerateDirectoryResultEnter, // Recurse into the current entry if it is a
                                     // directory or symlink, or next if not
     eEnumerateDirectoryResultExit,  // Exit from the current directory at the
                                     // current level.
     eEnumerateDirectoryResultQuit   // Stop directory enumerations at any level
   };
 
   typedef EnumerateDirectoryResult (*EnumerateDirectoryCallbackType)(
-      void *baton, FileType file_type, const FileSpec &spec);
+      void *baton, llvm::sys::fs::file_type file_type, const FileSpec &spec);
 
   static EnumerateDirectoryResult
   EnumerateDirectory(llvm::StringRef dir_path, bool find_directories,
                      bool find_files, bool find_other,
                      EnumerateDirectoryCallbackType callback,
                      void *callback_baton);
 
-  typedef std::function<EnumerateDirectoryResult(FileType file_type,
-                                                 const FileSpec &spec)>
+  typedef std::function<EnumerateDirectoryResult(
+      llvm::sys::fs::file_type file_type, const FileSpec &spec)>
       DirectoryCallback;
 
   static EnumerateDirectoryResult
   ForEachItemInDirectory(llvm::StringRef dir_path,
                          DirectoryCallback const &callback);
 
 protected:
   //------------------------------------------------------------------

lldb/include/lldb/Utility/Error.h

public:
   ///
   /// @param[in] type
   ///     The type for \a err.
   //------------------------------------------------------------------
   Error();
 
   explicit Error(ValueType err, lldb::ErrorType type = lldb::eErrorTypeGeneric);
 
+  /* implicit */ Error(std::error_code EC);
+
   explicit Error(const char *format, ...) __attribute__((format(printf, 2, 3)));
 
   Error(const Error &rhs);
   //------------------------------------------------------------------
   /// Assignment operator.
   ///
   /// @param[in] err
   ///     An error code.

lldb/source/API/SBPlatform.cpp

 #include "lldb/API/SBUnixSignals.h"
 #include "lldb/Core/ArchSpec.h"
 #include "lldb/Host/File.h"
 #include "lldb/Interpreter/Args.h"
 #include "lldb/Target/Platform.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/Error.h"
 
+#include "llvm/Support/FileSystem.h"
+
 #include <functional>
 
 using namespace lldb;
 using namespace lldb_private;
 
 //----------------------------------------------------------------------
 // PlatformConnectOptions
 //----------------------------------------------------------------------
SBError SBPlatform::Get(SBFileSpec &src, SBFileSpec &dst) {
   return sb_error;
 }
 
 SBError SBPlatform::Put(SBFileSpec &src, SBFileSpec &dst) {
   return ExecuteConnected([&](const lldb::PlatformSP &platform_sp) {
     if (src.Exists()) {
       uint32_t permissions = src.ref().GetPermissions();
       if (permissions == 0) {
-        if (src.ref().GetFileType() == FileSpec::eFileTypeDirectory)
+        if (llvm::sys::fs::is_directory(src.ref().GetPath()))
           permissions = eFilePermissionsDirectoryDefault;
         else
           permissions = eFilePermissionsFileDefault;
       }
 
       return platform_sp->PutFile(src.ref(), dst.ref(), permissions);
     }
 

lldb/source/Commands/CommandCompletions.cpp

 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Interpreter/OptionValueProperties.h"
 #include "lldb/Symbol/CompileUnit.h"
 #include "lldb/Symbol/Variable.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/CleanUp.h"
 
 #include "llvm/ADT/SmallString.h"
+#include "llvm/Support/FileSystem.h"
 
 using namespace lldb_private;
 
 CommandCompletions::CommonCompletionElement
     CommandCompletions::g_common_completions[] = {
         {eCustomCompletion, nullptr},
         {eSourceFileCompletion, CommandCompletions::SourceFiles},
         {eDiskFileCompletion, CommandCompletions::DiskFiles},
typedef struct DiskFilesOrDirectoriesBaton {
   bool only_directories;
   bool *saw_directory;
   StringList *matches;
   char *end_ptr;
   size_t baselen;
 } DiskFilesOrDirectoriesBaton;
 
 FileSpec::EnumerateDirectoryResult
-DiskFilesOrDirectoriesCallback(void *baton, FileSpec::FileType file_type,
+DiskFilesOrDirectoriesCallback(void *baton, llvm::sys::fs::file_type file_type,
                                const FileSpec &spec) {
   const char *name = spec.GetFilename().AsCString();
 
   const DiskFilesOrDirectoriesBaton *parameters =
       (DiskFilesOrDirectoriesBaton *)baton;
   char *end_ptr = parameters->end_ptr;
   char *partial_name_copy = parameters->partial_name_copy;
   const char *remainder = parameters->remainder;
DiskFilesOrDirectoriesCallback(void *baton, llvm::sys::fs::file_type file_type,
   // If we found a directory, we put a "/" at the end of the name.
 
   if (remainder[0] == '\0' || strstr(name, remainder) == name) {
     if (strlen(name) + parameters->baselen >= PATH_MAX)
       return FileSpec::eEnumerateDirectoryResultNext;
 
     strcpy(end_ptr, name);
 
+    namespace fs = llvm::sys::fs;
     bool isa_directory = false;
-    if (file_type == FileSpec::eFileTypeDirectory)
+    if (file_type == fs::file_type::directory_file)
       isa_directory = true;
-    else if (file_type == FileSpec::eFileTypeSymbolicLink) {
-      if (FileSpec(partial_name_copy, false).IsDirectory())
-        isa_directory = true;
-    }
+    else if (file_type == fs::file_type::symlink_file)
+      isa_directory = fs::is_directory(partial_name_copy);
 
     if (isa_directory) {
       *parameters->saw_directory = true;
       size_t len = strlen(parameters->partial_name_copy);
       partial_name_copy[len] = '/';
       partial_name_copy[len + 1] = '\0';
     }
     if (parameters->only_directories && !isa_directory)

lldb/source/Commands/CommandObjectTarget.cpp

 #include "lldb/Symbol/VariableList.h"
 #include "lldb/Target/ABI.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/SectionLoadList.h"
 #include "lldb/Target/StackFrame.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Target/ThreadSpec.h"
 
+#include "llvm/Support/FileSystem.h"
+
 // C Includes
 // C++ Includes
 #include <cerrno>
 
 using namespace lldb;
 using namespace lldb_private;
 
 static void DumpTargetInfo(uint32_t target_idx, Target *target,
if (symbol_fspec) {
               return true;
             }
           }
         }
         // Clear the symbol file spec if anything went wrong
         module_sp->SetSymbolFileFileSpec(FileSpec());
       }
 
+      namespace fs = llvm::sys::fs;
       if (module_spec.GetUUID().IsValid()) {
         StreamString ss_symfile_uuid;
         module_spec.GetUUID().Dump(&ss_symfile_uuid);
         result.AppendErrorWithFormat(
             "symbol file '%s' (%s) does not match any existing module%s\n",
             symfile_path, ss_symfile_uuid.GetData(),
-            (symbol_fspec.GetFileType() != FileSpec::eFileTypeRegular)
+            !fs::is_regular_file(symbol_fspec.GetPath())
                 ? "\n       please specify the full path to the symbol file"
                 : "");
       } else {
         result.AppendErrorWithFormat(
             "symbol file '%s' does not match any existing module%s\n",
             symfile_path,
-            (symbol_fspec.GetFileType() != FileSpec::eFileTypeRegular)
+            !fs::is_regular_file(symbol_fspec.GetPath())
                 ? "\n       please specify the full path to the symbol file"
                 : "");
       }
     } else {
       result.AppendError(
           "one or more executable image paths must be specified");
     }
     result.SetStatus(eReturnStatusFailed);

lldb/source/Core/Debugger.cpp

if (g_load_plugin_callback) {
     // and if the public API layer isn't available (code is linking against
     // all of the internal LLDB static libraries), then we can't load plugins
     error.SetErrorString("Public API layer is not available");
   }
   return false;
 }
 
 static FileSpec::EnumerateDirectoryResult
-LoadPluginCallback(void *baton, FileSpec::FileType file_type,
+LoadPluginCallback(void *baton, llvm::sys::fs::file_type ft,
                    const FileSpec &file_spec) {
   Error error;
 
   static ConstString g_dylibext("dylib");
   static ConstString g_solibext("so");
 
   if (!baton)
     return FileSpec::eEnumerateDirectoryResultQuit;
 
   Debugger *debugger = (Debugger *)baton;
 
+  namespace fs = llvm::sys::fs;
   // If we have a regular file, a symbolic link or unknown file type, try
   // and process the file. We must handle unknown as sometimes the directory
   // enumeration might be enumerating a file system that doesn't have correct
   // file type information.
-  if (file_type == FileSpec::eFileTypeRegular ||
-      file_type == FileSpec::eFileTypeSymbolicLink ||
-      file_type == FileSpec::eFileTypeUnknown) {
+  if (ft == fs::file_type::regular_file || ft == fs::file_type::symlink_file ||
+      ft == fs::file_type::type_unknown) {
     FileSpec plugin_file_spec(file_spec);
     plugin_file_spec.ResolvePath();
 
     if (plugin_file_spec.GetFileNameExtension() != g_dylibext &&
         plugin_file_spec.GetFileNameExtension() != g_solibext) {
       return FileSpec::eEnumerateDirectoryResultNext;
     }
 
     Error plugin_load_error;
     debugger->LoadPlugin(plugin_file_spec, plugin_load_error);
 
     return FileSpec::eEnumerateDirectoryResultNext;
-  } else if (file_type == FileSpec::eFileTypeUnknown ||
-             file_type == FileSpec::eFileTypeDirectory ||
-             file_type == FileSpec::eFileTypeSymbolicLink) {
+  } else if (ft == fs::file_type::directory_file ||
+             ft == fs::file_type::symlink_file ||
+             ft == fs::file_type::type_unknown) {
     // Try and recurse into anything that a directory or symbolic link.
     // We must also do this for unknown as sometimes the directory enumeration
     // might be enumerating a file system that doesn't have correct file type
     // information.
     return FileSpec::eEnumerateDirectoryResultEnter;
   }
 
   return FileSpec::eEnumerateDirectoryResultNext;

lldb/source/Core/FileSpecList.cpp

 
 // C Includes
 // C++ Includes
 #include <algorithm>
 
 // Other libraries and framework includes
 // Project includes
 #include "lldb/Utility/Stream.h"
+#include "llvm/Support/FileSystem.h"
 
 using namespace lldb_private;
 using namespace std;
 
 FileSpecList::FileSpecList() : m_files() {}
 
 FileSpecList::FileSpecList(const FileSpecList &rhs) = default;
 

 //------------------------------------------------------------------
 size_t FileSpecList::GetSize() const { return m_files.size(); }
 
 size_t FileSpecList::GetFilesMatchingPartialPath(const char *path,
                                                  bool dir_okay,
                                                  FileSpecList &matches) {
 #if 0 // FIXME: Just sketching...
     matches.Clear();
-    FileSpec path_spec = FileSpec (path);
-    if (path_spec.Exists ())
-    {
-        FileSpec::FileType type = path_spec.GetFileType();
-        if (type == FileSpec::eFileTypeSymbolicLink)
-            // Shouldn't there be a Resolve on a file spec that real-path's it?
-        {
-        }
-
-        if (type == FileSpec::eFileTypeRegular
-            || (type == FileSpec::eFileTypeDirectory && dir_okay))
-        {
-            matches.Append (path_spec);
-            return 1;
-        }
-        else if (type == FileSpec::eFileTypeDirectory)
-        {
-            // Fill the match list with all the files in the directory:
-        }
-        else
-        {
-            return 0;
-        }
-    }
-    else
-    {
+    using namespace llvm::sys::fs;
+    file_status stats;
+    if (status(path, stats, false))
+      return 0;
+    if (exists(stats)) {
+      if (is_symlink_file(stats)) {
+        // Shouldn't there be a method that realpath's a file?
+      if (is_regular_file(stats) || (is_directory(stats) && dir_okay)) {
+        matches.Append(FileSpec(path));
+      } else if (is_directory(stats)) {
+      } else {
+    } else {
         ConstString dir_name = path_spec.GetDirectory();
         ConstString file_name = GetFilename();
         if (dir_name == nullptr)
         {
             // Match files in the CWD.
         }
         else
         {
             // Match files in the given directory:
         }
     }
 #endif
   return 0;
 }

lldb/source/Core/Module.cpp

 //===-- Module.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/Core/Module.h"
 
 // C Includes
 // C++ Includes
 // Other libraries and framework includes
+#include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Signals.h"
 #include "llvm/Support/raw_os_ostream.h"
 
 // Project includes
 #include "Plugins/Language/CPlusPlus/CPlusPlusLanguage.h"
 #include "Plugins/Language/ObjC/ObjCLanguage.h"
 #include "lldb/Core/AddressResolverFileLine.h"
 #include "lldb/Core/ModuleList.h"
if (section_list && symbol_file) {
         obj_file->ClearSymtab();
 
         // The symbol file might be a directory bundle ("/tmp/a.out.dSYM")
         // instead
         // of a full path to the symbol file within the bundle
         // ("/tmp/a.out.dSYM/Contents/Resources/DWARF/a.out"). So we need to
         // check this
 
-        if (file.IsDirectory()) {
+        if (llvm::sys::fs::is_directory(file.GetPath())) {
           std::string new_path(file.GetPath());
           std::string old_path(obj_file->GetFileSpec().GetPath());
           if (old_path.find(new_path) == 0) {
             // We specified the same bundle as the symbol file that we already
             // have
             return;
           }
         }

lldb/source/Core/ModuleList.cpp

 #include "lldb/Host/FileSystem.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Host/Symbols.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/SymbolFile.h"
 #include "lldb/Symbol/VariableList.h"
 #include "lldb/Utility/Log.h"
 
+#include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Threading.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 ModuleList::ModuleList()
     : m_modules(), m_modules_mutex(), m_notifier(nullptr) {}
 
Error ModuleList::GetSharedModule(const ModuleSpec &module_spec,
   }
 
   if (module_search_paths_ptr) {
     const auto num_directories = module_search_paths_ptr->GetSize();
     for (size_t idx = 0; idx < num_directories; ++idx) {
       auto search_path_spec = module_search_paths_ptr->GetFileSpecAtIndex(idx);
       if (!search_path_spec.ResolvePath())
         continue;
-      if (!search_path_spec.Exists() || !search_path_spec.IsDirectory())
+      namespace fs = llvm::sys::fs;
+      if (!fs::is_directory(search_path_spec.GetPath()))
         continue;
       search_path_spec.AppendPathComponent(
           module_spec.GetFileSpec().GetFilename().AsCString());
       if (!search_path_spec.Exists())
         continue;
 
       auto resolved_module_spec(module_spec);
       resolved_module_spec.GetFileSpec() = search_path_spec;

lldb/source/Core/PluginManager.cpp

static void SetPluginInfo(const FileSpec &plugin_file_spec,
   plugin_map[plugin_file_spec] = plugin_info;
 }
 
 template <typename FPtrTy> static FPtrTy CastToFPtr(void *VPtr) {
   return reinterpret_cast<FPtrTy>(reinterpret_cast<intptr_t>(VPtr));
 }
 
 static FileSpec::EnumerateDirectoryResult
-LoadPluginCallback(void *baton, FileSpec::FileType file_type,
+LoadPluginCallback(void *baton, llvm::sys::fs::file_type ft,
                    const FileSpec &file_spec) {
   //    PluginManager *plugin_manager = (PluginManager *)baton;
   Error error;
 
+  namespace fs = llvm::sys::fs;
   // If we have a regular file, a symbolic link or unknown file type, try
   // and process the file. We must handle unknown as sometimes the directory
   // enumeration might be enumerating a file system that doesn't have correct
   // file type information.
-  if (file_type == FileSpec::eFileTypeRegular ||
-      file_type == FileSpec::eFileTypeSymbolicLink ||
-      file_type == FileSpec::eFileTypeUnknown) {
+  if (ft == fs::file_type::regular_file || ft == fs::file_type::symlink_file ||
+      ft == fs::file_type::type_unknown) {
     FileSpec plugin_file_spec(file_spec);
     plugin_file_spec.ResolvePath();
 
     if (PluginIsLoaded(plugin_file_spec))
       return FileSpec::eEnumerateDirectoryResultNext;
     else {
       PluginInfo plugin_info;
 
else {
         // again.
         SetPluginInfo(plugin_file_spec, plugin_info);
 
         return FileSpec::eEnumerateDirectoryResultNext;
       }
     }
   }
 
-  if (file_type == FileSpec::eFileTypeUnknown ||
-      file_type == FileSpec::eFileTypeDirectory ||
-      file_type == FileSpec::eFileTypeSymbolicLink) {
+  if (ft == fs::file_type::directory_file ||
+      ft == fs::file_type::symlink_file || ft == fs::file_type::type_unknown) {
     // Try and recurse into anything that a directory or symbolic link.
     // We must also do this for unknown as sometimes the directory enumeration
     // might be enumerating a file system that doesn't have correct file type
     // information.
     return FileSpec::eEnumerateDirectoryResultEnter;
   }
 
   return FileSpec::eEnumerateDirectoryResultNext;

lldb/source/Host/common/FileSpec.cpp

 
 #include "lldb/Host/Config.h" // Have to include this before we test the define...
 #ifdef LLDB_CONFIG_TILDE_RESOLVES_TO_USER
 #include <pwd.h>
 #endif
 
 #include "lldb/Core/StringList.h"
 #include "lldb/Host/FileSpec.h"
-#include "lldb/Host/FileSystem.h"
 #include "lldb/Utility/CleanUp.h"
 #include "lldb/Utility/RegularExpression.h"
 #include "lldb/Utility/Stream.h"
 #include "lldb/Utility/StreamString.h"
 
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/ConvertUTF.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/Program.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 namespace {
 
+static constexpr FileSpec::PathSyntax GetNativeSyntax() {
+#if defined(LLVM_ON_WIN32)
+  return FileSpec::ePathSyntaxWindows;
+#else
+  return FileSpec::ePathSyntaxPosix;
+#endif
+}
+
 bool PathSyntaxIsPosix(FileSpec::PathSyntax syntax) {
   return (syntax == FileSpec::ePathSyntaxPosix ||
           (syntax == FileSpec::ePathSyntaxHostNative &&
-           FileSystem::GetNativePathSyntax() == FileSpec::ePathSyntaxPosix));
+           GetNativeSyntax() == FileSpec::ePathSyntaxPosix));
 }
 
 const char *GetPathSeparators(FileSpec::PathSyntax syntax) {
   return PathSyntaxIsPosix(syntax) ? "/" : "\\/";
 }
 
 char GetPreferredPathSeparator(FileSpec::PathSyntax syntax) {
   return GetPathSeparators(syntax)[0];

 void Denormalize(llvm::SmallVectorImpl<char> &path,
                  FileSpec::PathSyntax syntax) {
   if (PathSyntaxIsPosix(syntax))
     return;
 
   std::replace(path.begin(), path.end(), '/', '\\');
 }
 
-bool GetFileStats(const FileSpec *file_spec, struct stat *stats_ptr) {
-  char resolved_path[PATH_MAX];
-  if (file_spec->GetPath(resolved_path, sizeof(resolved_path)))
-    return FileSystem::Stat(resolved_path, stats_ptr) == 0;
-  return false;
-}
-
 size_t FilenamePos(llvm::StringRef str, FileSpec::PathSyntax syntax) {
   if (str.size() == 2 && IsPathSeparator(str[0], syntax) && str[0] == str[1])
     return 0;
 
   if (str.size() > 0 && IsPathSeparator(str.back(), syntax))
     return str.size() - 1;
 
   size_t pos = str.find_last_of(GetPathSeparators(syntax), str.size() - 1);
#endif // #ifdef LLDB_CONFIG_TILDE_RESOLVES_TO_USER
 
   llvm::sys::fs::make_absolute(path);
   if (!llvm::sys::fs::exists(path)) {
     path.clear();
     path.append(original_path.begin(), original_path.end());
   }
 }
 
-FileSpec::FileSpec() : m_syntax(FileSystem::GetNativePathSyntax()) {}
+FileSpec::FileSpec() : m_syntax(GetNativeSyntax()) {}
 
 //------------------------------------------------------------------
 // Default constructor that can take an optional full path to a
 // file on disk.
 //------------------------------------------------------------------
 FileSpec::FileSpec(llvm::StringRef path, bool resolve_path, PathSyntax syntax)
     : m_syntax(syntax) {
   SetFile(path, resolve_path, syntax);
void FileSpec::SetFile(llvm::StringRef pathname, bool resolve,
                        PathSyntax syntax) {
   // CLEANUP: Use StringRef for string handling.  This function is kind of a
   // mess and the unclear semantics of RootDirStart and ParentPathEnd make
   // it very difficult to understand this function.  There's no reason this
   // function should be particularly complicated or difficult to understand.
   m_filename.Clear();
   m_directory.Clear();
   m_is_resolved = false;
-  m_syntax = (syntax == ePathSyntaxHostNative)
-                 ? FileSystem::GetNativePathSyntax()
-                 : syntax;
+  m_syntax = (syntax == ePathSyntaxHostNative) ? GetNativeSyntax() : syntax;
 
   if (pathname.empty())
     return;
 
   llvm::SmallString<64> resolved(pathname);
 
   if (resolve) {
     FileSpec::Resolve(resolved);
if (s) {
     if (!m_filename && !path.empty() && path.back() != path_separator)
       s->PutChar(path_separator);
   }
 }
 
 //------------------------------------------------------------------
 // Returns true if the file exists.
 //------------------------------------------------------------------
-bool FileSpec::Exists() const {
-  struct stat file_stats;
-  return GetFileStats(this, &file_stats);
-}
+bool FileSpec::Exists() const { return llvm::sys::fs::exists(GetPath()); }
 
 bool FileSpec::Readable() const {
-  const uint32_t permissions = GetPermissions();
-  if (permissions & eFilePermissionsEveryoneR)
-    return true;
-  return false;
+  return GetPermissions() & llvm::sys::fs::perms::all_read;
 }
 
 bool FileSpec::ResolveExecutableLocation() {
   // CLEANUP: Use StringRef for string handling.
   if (!m_directory) {
     const char *file_cstr = m_filename.GetCString();
     if (file_cstr) {
       const std::string file_str(file_cstr);
bool FileSpec::ResolvePath() {
   if (!GetPath(path_buf, PATH_MAX, false))
     return false;
   // SetFile(...) will set m_is_resolved correctly if it can resolve the path
   SetFile(path_buf, true);
   return m_is_resolved;
 }
 
 uint64_t FileSpec::GetByteSize() const {
-  struct stat file_stats;
-  if (GetFileStats(this, &file_stats))
-    return file_stats.st_size;
+  uint64_t Size = 0;
+  if (llvm::sys::fs::file_size(GetPath(), Size))
     return 0;
+  return Size;
 }
 
 FileSpec::PathSyntax FileSpec::GetPathSyntax() const { return m_syntax; }
 
-FileSpec::FileType FileSpec::GetFileType() const {
-  struct stat file_stats;
-  if (GetFileStats(this, &file_stats)) {
-    mode_t file_type = file_stats.st_mode & S_IFMT;
-    switch (file_type) {
-    case S_IFDIR:
-      return eFileTypeDirectory;
-    case S_IFREG:
-      return eFileTypeRegular;
-#ifndef _WIN32
-    case S_IFIFO:
-      return eFileTypePipe;
-    case S_IFSOCK:
-      return eFileTypeSocket;
-    case S_IFLNK:
-      return eFileTypeSymbolicLink;
-#endif
-    default:
-      break;
-    }
-    return eFileTypeUnknown;
-  }
-  return eFileTypeInvalid;
-}
-
-bool FileSpec::IsSymbolicLink() const {
-  char resolved_path[PATH_MAX];
-  if (!GetPath(resolved_path, sizeof(resolved_path)))
-    return false;
-
-#ifdef _WIN32
-  std::wstring wpath;
-  if (!llvm::ConvertUTF8toWide(resolved_path, wpath))
-    return false;
-  auto attrs = ::GetFileAttributesW(wpath.c_str());
-  if (attrs == INVALID_FILE_ATTRIBUTES)
-    return false;
-
-  return (attrs & FILE_ATTRIBUTE_REPARSE_POINT);
-#else
-  struct stat file_stats;
-  if (::lstat(resolved_path, &file_stats) != 0)
-    return false;
-
-  return (file_stats.st_mode & S_IFMT) == S_IFLNK;
-#endif
-}
-
 uint32_t FileSpec::GetPermissions() const {
-  uint32_t file_permissions = 0;
-  if (*this)
-    FileSystem::GetFilePermissions(*this, file_permissions);
-  return file_permissions;
+  namespace fs = llvm::sys::fs;
+  fs::file_status st;
+  if (fs::status(GetPath(), st, false))
+    return fs::perms::perms_not_known;
+
+  return st.permissions();
 }
 
 //------------------------------------------------------------------
 // Directory string get accessor.
 //------------------------------------------------------------------
 ConstString &FileSpec::GetDirectory() { return m_directory; }
 
 //------------------------------------------------------------------
#ifdef _WIN32
     WIN32_FIND_DATAW ffd;
     HANDLE hFind = FindFirstFileW(wszDir.c_str(), &ffd);
 
     if (hFind == INVALID_HANDLE_VALUE) {
       return eEnumerateDirectoryResultNext;
     }
 
     do {
-      FileSpec::FileType file_type = eFileTypeUnknown;
+      namespace fs = llvm::sys::fs;
+      fs::file_type ft = fs::file_type::type_unknown;
       if (ffd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
         size_t len = wcslen(ffd.cFileName);
 
         if (len == 1 && ffd.cFileName[0] == L'.')
           continue;
 
         if (len == 2 && ffd.cFileName[0] == L'.' && ffd.cFileName[1] == L'.')
           continue;
 
-        file_type = eFileTypeDirectory;
+        ft = fs::file_type::directory_file;
       } else if (ffd.dwFileAttributes & FILE_ATTRIBUTE_DEVICE) {
-        file_type = eFileTypeOther;
+        ft = fs::file_type::type_unknown;
       } else {
-        file_type = eFileTypeRegular;
+        ft = fs::file_type::regular_file;
       }
 
       std::string fileName;
       if (!llvm::convertWideToUTF8(ffd.cFileName, fileName)) {
         continue;
       }
 
       std::string child_path = llvm::join_items("\\", dir_path, fileName);
       // Don't resolve the file type or path
       FileSpec child_path_spec(child_path.data(), false);
 
-      EnumerateDirectoryResult result = callback(file_type, child_path_spec);
+      EnumerateDirectoryResult result = callback(ft, child_path_spec);
 
       switch (result) {
       case eEnumerateDirectoryResultNext:
         // Enumerate next entry in the current directory. We just
         // exit this switch and will continue enumerating the
         // current directory as we currently are...
         break;
 
#endif
 
           if (len == 1 && dp->d_name[0] == '.')
             continue;
 
           if (len == 2 && dp->d_name[0] == '.' && dp->d_name[1] == '.')
             continue;
         }
 
-        FileSpec::FileType file_type = eFileTypeUnknown;
+        using namespace llvm::sys::fs;
+        file_type ft = file_type::type_unknown;
 
         switch (dp->d_type) {
         default:
         case DT_UNKNOWN:
-          file_type = eFileTypeUnknown;
+          ft = file_type::type_unknown;
           break;
         case DT_FIFO:
-          file_type = eFileTypePipe;
+          ft = file_type::fifo_file;
           break;
         case DT_CHR:
-          file_type = eFileTypeOther;
+          ft = file_type::character_file;
           break;
         case DT_DIR:
-          file_type = eFileTypeDirectory;
+          ft = file_type::directory_file;
           break;
         case DT_BLK:
-          file_type = eFileTypeOther;
+          ft = file_type::block_file;
           break;
         case DT_REG:
-          file_type = eFileTypeRegular;
+          ft = file_type::regular_file;
           break;
         case DT_LNK:
-          file_type = eFileTypeSymbolicLink;
+          ft = file_type::symlink_file;
           break;
         case DT_SOCK:
-          file_type = eFileTypeSocket;
+          ft = file_type::socket_file;
           break;
 #if !defined(__OpenBSD__)
         case DT_WHT:
-          file_type = eFileTypeOther;
+          ft = file_type::type_unknown;
           break;
 #endif
         }
 
         std::string child_path;
         // Don't make paths with "/foo//bar", that just confuses everybody.
         if (dir_path_last_char == '/')
           child_path = llvm::join_items("", dir_path, dp->d_name);
         else
           child_path = llvm::join_items('/', dir_path, dp->d_name);
 
         // Don't resolve the file type or path
         FileSpec child_path_spec(child_path, false);
 
-        EnumerateDirectoryResult result =
-            callback(file_type, child_path_spec);
+        EnumerateDirectoryResult result = callback(ft, child_path_spec);
 
         switch (result) {
         case eEnumerateDirectoryResultNext:
           // Enumerate next entry in the current directory. We just
           // exit this switch and will continue enumerating the
           // current directory as we currently are...
           break;
 

 
 FileSpec::EnumerateDirectoryResult
 FileSpec::EnumerateDirectory(llvm::StringRef dir_path, bool find_directories,
                              bool find_files, bool find_other,
                              EnumerateDirectoryCallbackType callback,
                              void *callback_baton) {
   return ForEachItemInDirectory(
       dir_path,
-      [&find_directories, &find_files, &find_other, &callback,
-       &callback_baton](FileType file_type, const FileSpec &file_spec) {
+      [&find_directories, &find_files, &find_other, &callback, &callback_baton](
+          llvm::sys::fs::file_type file_type, const FileSpec &file_spec) {
         switch (file_type) {
-        case FileType::eFileTypeDirectory:
+        case llvm::sys::fs::file_type::directory_file:
           if (find_directories)
             return callback(callback_baton, file_type, file_spec);
           break;
-        case FileType::eFileTypeRegular:
+        case llvm::sys::fs::file_type::regular_file:
           if (find_files)
             return callback(callback_baton, file_type, file_spec);
           break;
         default:
           if (find_other)
             return callback(callback_baton, file_type, file_spec);
           break;
         }

lldb/source/Host/common/MonitoringProcessLauncher.cpp

 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Host/HostProcess.h"
 #include "lldb/Target/Platform.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/ProcessLaunchInfo.h"
 #include "lldb/Utility/Error.h"
 #include "lldb/Utility/Log.h"
 
+#include "llvm/Support/FileSystem.h"
+
 using namespace lldb;
 using namespace lldb_private;
 
 MonitoringProcessLauncher::MonitoringProcessLauncher(
     std::unique_ptr<ProcessLauncher> delegate_launcher)
     : m_delegate_launcher(std::move(delegate_launcher)) {}
 
 HostProcess
 MonitoringProcessLauncher::LaunchProcess(const ProcessLaunchInfo &launch_info,
                                          Error &error) {
   ProcessLaunchInfo resolved_info(launch_info);
 
   error.Clear();
   char exe_path[PATH_MAX];
 
   PlatformSP host_platform_sp(Platform::GetHostPlatform());
 
   const ArchSpec &arch_spec = resolved_info.GetArchitecture();
 
   FileSpec exe_spec(resolved_info.GetExecutableFile());
 
-  FileSpec::FileType file_type = exe_spec.GetFileType();
-  if (file_type != FileSpec::eFileTypeRegular) {
+  llvm::sys::fs::file_status stats;
+  status(exe_spec.GetPath(), stats);
+  if (!is_regular_file(stats)) {
     ModuleSpec module_spec(exe_spec, arch_spec);
     lldb::ModuleSP exe_module_sp;
     error =
         host_platform_sp->ResolveExecutable(module_spec, exe_module_sp, NULL);
 
     if (error.Fail())
       return HostProcess();
 
-    if (exe_module_sp)
+    if (exe_module_sp) {
       exe_spec = exe_module_sp->GetFileSpec();
+      status(exe_spec.GetPath(), stats);
+    }
   }
 
-  if (exe_spec.Exists()) {
+  if (exists(stats)) {
     exe_spec.GetPath(exe_path, sizeof(exe_path));
   } else {
     resolved_info.GetExecutableFile().GetPath(exe_path, sizeof(exe_path));
     error.SetErrorStringWithFormat("executable doesn't exist: '%s'", exe_path);
     return HostProcess();
   }
 
   resolved_info.SetExecutableFile(exe_spec, false);

lldb/source/Host/common/Symbols.cpp

if (module_uuid.IsValid()) {
       uuid_str.insert(2, 1, '/');
       uuid_str = uuid_str + ".debug";
     }
 
     size_t num_directories = debug_file_search_paths.GetSize();
     for (size_t idx = 0; idx < num_directories; ++idx) {
       FileSpec dirspec = debug_file_search_paths.GetFileSpecAtIndex(idx);
       dirspec.ResolvePath();
-      if (!dirspec.Exists() || !dirspec.IsDirectory())
+      if (!llvm::sys::fs::is_directory(dirspec.GetPath()))
         continue;
 
       std::vector<std::string> files;
       std::string dirname = dirspec.GetPath();
 
       files.push_back(dirname + "/" + symbol_filename);
       files.push_back(dirname + "/.debug/" + symbol_filename);
       files.push_back(dirname + "/.build-id/" + uuid_str);

lldb/source/Host/macosx/Host.mm

 #include "lldb/Utility/CleanUp.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/DataExtractor.h"
 #include "lldb/Utility/Endian.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/NameMatches.h"
 #include "lldb/Utility/StreamString.h"
 
+#include "llvm/Support/FileSystem.h"
+
 #include "cfcpp/CFCBundle.h"
 #include "cfcpp/CFCMutableArray.h"
 #include "cfcpp/CFCMutableDictionary.h"
 #include "cfcpp/CFCReleaser.h"
 #include "cfcpp/CFCString.h"
 
 #include <objc/objc-auto.h>
 

 }
 
 using namespace lldb;
 using namespace lldb_private;
 
 bool Host::GetBundleDirectory(const FileSpec &file,
                               FileSpec &bundle_directory) {
 #if defined(__APPLE__)
-  if (file.GetFileType() == FileSpec::eFileTypeDirectory) {
+  if (llvm::sys::fs::is_directory(file.GetPath())) {
     char path[PATH_MAX];
     if (file.GetPath(path, sizeof(path))) {
       CFCBundle bundle(path);
       if (bundle.GetPath(path, sizeof(path))) {
         bundle_directory.SetFile(path, false);
         return true;
       }
     }
   }
 #endif
   bundle_directory.Clear();
   return false;
 }
 
 bool Host::ResolveExecutableInBundle(FileSpec &file) {
 #if defined(__APPLE__)
-  if (file.GetFileType() == FileSpec::eFileTypeDirectory) {
+  if (llvm::sys::fs::is_directory(file.GetPath())) {
     char path[PATH_MAX];
     if (file.GetPath(path, sizeof(path))) {
       CFCBundle bundle(path);
       CFCReleaser<CFURLRef> url(bundle.CopyExecutableURL());
       if (url.get()) {
         if (::CFURLGetFileSystemRepresentation(url.get(), YES, (UInt8 *)path,
                                                sizeof(path))) {
           file.SetFile(path, false);

 Error Host::LaunchProcess(ProcessLaunchInfo &launch_info) {
   Error error;
   char exe_path[PATH_MAX];
   PlatformSP host_platform_sp(Platform::GetHostPlatform());
 
   ModuleSpec exe_module_spec(launch_info.GetExecutableFile(),
                              launch_info.GetArchitecture());
 
-  FileSpec::FileType file_type = exe_module_spec.GetFileSpec().GetFileType();
-  if (file_type != FileSpec::eFileTypeRegular) {
+  if (!llvm::sys::fs::is_regular_file(
+          exe_module_spec.GetFileSpec().GetPath())) {
     lldb::ModuleSP exe_module_sp;
     error = host_platform_sp->ResolveExecutable(exe_module_spec, exe_module_sp,
                                                 NULL);
 
     if (error.Fail())
       return error;
 
     if (exe_module_sp)

lldb/source/Host/macosx/HostInfoMacOSX.mm

 
 #include "lldb/Host/HostInfo.h"
 #include "lldb/Host/macosx/HostInfoMacOSX.h"
 #include "lldb/Interpreter/Args.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/SafeMachO.h"
 
 #include "llvm/ADT/SmallString.h"
+#include "llvm/Support/FileSystem.h"
 #include "llvm/Support/raw_ostream.h"
 
 // C++ Includes
 #include <string>
 
 // C inclues
 #include <stdlib.h>
 #include <sys/sysctl.h>
#endif
     // OS X .dylib lives.  This is not going to work if the bin and lib
     // dir are not both in the same dir.
     //
     // It is not going to work to do it by the executable path either,
     // as in the case of a python script, the executable is python, not
     // the lldb driver.
     raw_path.append("/../bin");
     FileSpec support_dir_spec(raw_path, true);
-    if (!support_dir_spec.Exists() || !support_dir_spec.IsDirectory()) {
+    if (!llvm::sys::fs::is_directory(support_dir_spec.GetPath())) {
       Log *log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_HOST);
       if (log)
         log->Printf("HostInfoMacOSX::%s(): failed to find support directory",
                     __FUNCTION__);
       return false;
     }
 
     // Get normalization from support_dir_spec.  Note the FileSpec resolve

lldb/source/Host/macosx/Symbols.cpp

 #include "lldb/Utility/DataBuffer.h"
 #include "lldb/Utility/DataExtractor.h"
 #include "lldb/Utility/Endian.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/StreamString.h"
 #include "lldb/Utility/UUID.h"
 #include "mach/machine.h"
 
+#include "llvm/Support/FileSystem.h"
+
 using namespace lldb;
 using namespace lldb_private;
 using namespace llvm::MachO;
 
 #if !defined(__arm__) && !defined(__arm64__) &&                                \
     !defined(__aarch64__) // No DebugSymbols on the iOS devices
 extern "C" {
 
if (module_uuid != NULL) {
                   dsym_url.get(), true, (UInt8 *)path, sizeof(path) - 1)) {
             if (log) {
               log->Printf("DebugSymbols framework returned dSYM path of %s for "
                           "UUID %s -- looking for the dSYM",
                           path, uuid->GetAsString().c_str());
             }
             FileSpec dsym_filespec(path, path[0] == '~');
 
-            if (dsym_filespec.GetFileType() == FileSpec::eFileTypeDirectory) {
+            if (llvm::sys::fs::is_directory(dsym_filespec.GetPath())) {
               dsym_filespec =
                   Symbols::FindSymbolFileInBundle(dsym_filespec, uuid, arch);
               ++items_found;
             } else {
               ++items_found;
             }
             return_module_spec.GetSymbolFileSpec() = dsym_filespec;
           }
if (module_uuid != NULL) {
                 if (log) {
                   log->Printf("Looking for executable binary next to dSYM "
                               "bundle with name with name %s",
                               path);
                 }
                 FileSpec file_spec(path, true);
                 ModuleSpecList module_specs;
                 ModuleSpec matched_module_spec;
-                switch (file_spec.GetFileType()) {
-                case FileSpec::eFileTypeDirectory: // Bundle directory?
+                using namespace llvm::sys::fs;
+                switch (get_file_type(file_spec.GetPath())) {
+
+                case file_type::directory_file: // Bundle directory?
                 {
                   CFCBundle bundle(path);
                   CFCReleaser<CFURLRef> bundle_exe_url(
                       bundle.CopyExecutableURL());
                   if (bundle_exe_url.get()) {
                     if (::CFURLGetFileSystemRepresentation(bundle_exe_url.get(),
                                                            true, (UInt8 *)path,
                                                            sizeof(path) - 1)) {
if (module_uuid != NULL) {
                                       "compatible; using",
                                       path);
                         }
                       }
                     }
                   }
                 } break;
 
-                case FileSpec::eFileTypePipe:   // Forget pipes
-                case FileSpec::eFileTypeSocket: // We can't process socket files
-                case FileSpec::eFileTypeInvalid: // File doesn't exist...
+                case file_type::fifo_file:      // Forget pipes
+                case file_type::socket_file:    // We can't process socket files
+                case file_type::file_not_found: // File doesn't exist...
+                case file_type::status_error:
                   break;
 
-                case FileSpec::eFileTypeUnknown:
-                case FileSpec::eFileTypeRegular:
-                case FileSpec::eFileTypeSymbolicLink:
-                case FileSpec::eFileTypeOther:
+                case file_type::type_unknown:
+                case file_type::regular_file:
+                case file_type::symlink_file:
+                case file_type::block_file:
+                case file_type::character_file:
                   if (ObjectFile::GetModuleSpecifications(file_spec, 0, 0,
                                                           module_specs) &&
                       module_specs.FindMatchingModuleSpec(module_spec,
                                                           matched_module_spec))
 
                   {
                     ++items_found;
                     return_module_spec.GetFileSpec() = file_spec;

lldb/source/Host/posix/FileSystem.cpp

 #include <sys/statvfs.h>
 #endif
 
 // lldb Includes
 #include "lldb/Host/Host.h"
 #include "lldb/Utility/Error.h"
 #include "lldb/Utility/StreamString.h"
 
+#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;
 }
if (::mkdir(file_spec.GetCString(), file_permissions) == -1) {
         // Try and make the directory again now that the parent directory was
         // made successfully
         if (::mkdir(file_spec.GetCString(), file_permissions) == -1) {
           error.SetErrorToErrno();
         }
         return error;
       } break;
       case EEXIST: {
-        if (file_spec.IsDirectory())
+        if (llvm::sys::fs::is_directory(file_spec.GetPath()))
           return Error(); // It is a directory and it already exists
       } break;
       }
     }
     return error;
   }
   return Error("empty path");
 }
 
 Error FileSystem::DeleteDirectory(const FileSpec &file_spec, bool recurse) {
   Error error;
   if (file_spec) {
     if (recurse) {
       // Save all sub directories in a list so we don't recursively call this
       // function
       // and possibly run out of file descriptors if the directory is too deep.
       std::vector<FileSpec> sub_directories;
 
       FileSpec::ForEachItemInDirectory(
           file_spec.GetCString(),
           [&error, &sub_directories](
-              FileSpec::FileType file_type,
+              llvm::sys::fs::file_type ft,
               const FileSpec &spec) -> FileSpec::EnumerateDirectoryResult {
-            if (file_type == FileSpec::eFileTypeDirectory) {
+            if (ft == llvm::sys::fs::file_type::directory_file) {
               // Save all directorires and process them after iterating through
               // this directory
               sub_directories.push_back(spec);
             } else {
               // Update sub_spec to point to the current file and delete it
               error = FileSystem::Unlink(spec);
             }
             // If anything went wrong, stop iterating, else process the next

lldb/source/Plugins/ExpressionParser/Clang/ClangModulesDeclVendor.cpp

 #include "clang/Basic/TargetInfo.h"
 #include "clang/Frontend/CompilerInstance.h"
 #include "clang/Frontend/FrontendActions.h"
 #include "clang/Lex/Preprocessor.h"
 #include "clang/Lex/PreprocessorOptions.h"
 #include "clang/Parse/Parser.h"
 #include "clang/Sema/Lookup.h"
 #include "clang/Serialization/ASTReader.h"
+#include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/Threading.h"
 
 // Project includes
 #include "ClangModulesDeclVendor.h"
 
 #include "lldb/Host/FileSpec.h"
 #include "lldb/Host/Host.h"
for (size_t spi = 0, spe = module_search_paths.GetSize(); spi < spe; ++spi) {
     search_path_argument.append(search_path.GetPath());
 
     compiler_invocation_arguments.push_back(search_path_argument);
   }
 
   {
     FileSpec clang_resource_dir = GetResourceDir();
 
-    if (clang_resource_dir.IsDirectory()) {
+    if (llvm::sys::fs::is_directory(clang_resource_dir.GetPath())) {
       compiler_invocation_arguments.push_back("-resource-dir");
       compiler_invocation_arguments.push_back(clang_resource_dir.GetPath());
     }
   }
 
   llvm::IntrusiveRefCntPtr<clang::DiagnosticsEngine> diagnostics_engine =
       clang::CompilerInstance::createDiagnostics(new clang::DiagnosticOptions,
                                                  new StoringDiagnosticConsumer);

lldb/source/Plugins/Platform/MacOSX/PlatformAppleTVSimulator.cpp

 #include "lldb/Host/Host.h"
 #include "lldb/Host/HostInfo.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/Error.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/StreamString.h"
 
+#include "llvm/Support/FileSystem.h"
+
 using namespace lldb;
 using namespace lldb_private;
 
 //------------------------------------------------------------------
 // Static Variables
 //------------------------------------------------------------------
 static uint32_t g_initialize_count = 0;
 
if (resolved_module_spec.GetFileSpec().Exists()) {
     error.SetErrorStringWithFormat("'%s' does not exist",
                                    module_spec.GetFileSpec().GetPath().c_str());
   }
 
   return error;
 }
 
 static FileSpec::EnumerateDirectoryResult
-EnumerateDirectoryCallback(void *baton, FileSpec::FileType file_type,
+EnumerateDirectoryCallback(void *baton, llvm::sys::fs::file_type ft,
                            const FileSpec &file_spec) {
-  if (file_type == FileSpec::eFileTypeDirectory) {
+  if (ft == llvm::sys::fs::file_type::directory_file) {
     const char *filename = file_spec.GetFilename().GetCString();
     if (filename &&
         strncmp(filename, "AppleTVSimulator", strlen("AppleTVSimulator")) ==
             0) {
       ::snprintf((char *)baton, PATH_MAX, "%s", filename);
       return FileSpec::eEnumerateDirectoryResultQuit;
     }
   }

lldb/source/Plugins/Platform/MacOSX/PlatformAppleWatchSimulator.cpp

if (resolved_module_spec.GetFileSpec().Exists()) {
     error.SetErrorStringWithFormat("'%s' does not exist",
                                    module_spec.GetFileSpec().GetPath().c_str());
   }
 
   return error;
 }
 
 static FileSpec::EnumerateDirectoryResult
-EnumerateDirectoryCallback(void *baton, FileSpec::FileType file_type,
+EnumerateDirectoryCallback(void *baton, llvm::sys::fs::file_type ft,
                            const FileSpec &file_spec) {
-  if (file_type == FileSpec::eFileTypeDirectory) {
+  if (ft == llvm::sys::fs::file_type::directory_file) {
     const char *filename = file_spec.GetFilename().GetCString();
     if (filename &&
         strncmp(filename, "AppleWatchSimulator",
                 strlen("AppleWatchSimulator")) == 0) {
       ::snprintf((char *)baton, PATH_MAX, "%s", filename);
       return FileSpec::eEnumerateDirectoryResultQuit;
     }
   }

lldb/source/Plugins/Platform/MacOSX/PlatformDarwin.h

 // C Includes
 // C++ Includes
 
 // Other libraries and framework includes
 // Project includes
 #include "Plugins/Platform/POSIX/PlatformPOSIX.h"
 #include "lldb/Host/FileSpec.h"
 #include "llvm/ADT/StringRef.h"
+#include "llvm/Support/FileSystem.h"
 
 #include <string>
 #include <tuple>
 
 class PlatformDarwin : public PlatformPOSIX {
 public:
   PlatformDarwin(bool is_host);
 
static bool SDKSupportsModules(SDKType desired_type,
                                  const lldb_private::FileSpec &sdk_path);
 
   struct SDKEnumeratorInfo {
     lldb_private::FileSpec found_path;
     SDKType sdk_type;
   };
 
   static lldb_private::FileSpec::EnumerateDirectoryResult
-  DirectoryEnumerator(void *baton, lldb_private::FileSpec::FileType file_type,
+  DirectoryEnumerator(void *baton, llvm::sys::fs::file_type file_type,
                       const lldb_private::FileSpec &spec);
 
   static lldb_private::FileSpec
   FindSDKInXcodeForModules(SDKType sdk_type,
                            const lldb_private::FileSpec &sdks_spec);
 
   static lldb_private::FileSpec
   GetSDKDirectoryForModules(PlatformDarwin::SDKType sdk_type);

lldb/source/Plugins/Platform/MacOSX/PlatformDarwin.cpp

 #include "lldb/Symbol/SymbolFile.h"
 #include "lldb/Symbol/SymbolVendor.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/DataBufferLLVM.h"
 #include "lldb/Utility/Error.h"
 #include "lldb/Utility/Log.h"
 #include "llvm/ADT/STLExtras.h"
+#include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Threading.h"
 
 #if defined(__APPLE__)
 #include <TargetConditionals.h> // for TARGET_OS_TV, TARGET_OS_WATCH
 #endif
 
 using namespace lldb;
 using namespace lldb_private;
FileSpecList PlatformDarwin::LocateExecutableScriptingResources(
   return file_list;
 }
 
 Error PlatformDarwin::ResolveSymbolFile(Target &target,
                                         const ModuleSpec &sym_spec,
                                         FileSpec &sym_file) {
   Error error;
   sym_file = sym_spec.GetSymbolFileSpec();
-  if (sym_file.Exists()) {
-    if (sym_file.GetFileType() == FileSpec::eFileTypeDirectory) {
+
+  llvm::sys::fs::file_status st;
+  if (status(sym_file.GetPath(), st, false)) {
+    error.SetErrorString("Could not stat file!");
+    return error;
+  }
+
+  if (exists(st)) {
+    if (is_directory(st)) {
       sym_file = Symbols::FindSymbolFileInBundle(
           sym_file, sym_spec.GetUUIDPtr(), sym_spec.GetArchitecturePtr());
     }
   } else {
     if (sym_spec.GetUUID().IsValid()) {
     }
   }
   return error;
if (!developer_dir_path_valid) {
             if (cmd_output_ptr[i] == '\r' || cmd_output_ptr[i] == '\n' ||
                 cmd_output_ptr[i] == '\0')
               break;
             developer_dir_path[i] = cmd_output_ptr[i];
           }
           developer_dir_path[i] = '\0';
 
           FileSpec devel_dir(developer_dir_path, false);
-          if (devel_dir.Exists() && devel_dir.IsDirectory()) {
+          if (llvm::sys::fs::is_directory(devel_dir.GetPath())) {
             developer_dir_path_valid = true;
           }
         }
       }
     }
 
     if (developer_dir_path_valid) {
       temp_file_spec.SetFile(developer_dir_path, false);
if (minor_version.getAsInteger(10, minor))
       return false;
 
     return SDKSupportsModules(desired_type, major, minor, micro);
   }
 
   return false;
 }
 
-FileSpec::EnumerateDirectoryResult
-PlatformDarwin::DirectoryEnumerator(void *baton, FileSpec::FileType file_type,
-                                    const FileSpec &spec) {
+FileSpec::EnumerateDirectoryResult PlatformDarwin::DirectoryEnumerator(
+    void *baton, llvm::sys::fs::file_type file_type, const FileSpec &spec) {
   SDKEnumeratorInfo *enumerator_info = static_cast<SDKEnumeratorInfo *>(baton);
 
   if (SDKSupportsModules(enumerator_info->sdk_type, spec)) {
     enumerator_info->found_path = spec;
     return FileSpec::EnumerateDirectoryResult::eEnumerateDirectoryResultNext;
   }
 
   return FileSpec::EnumerateDirectoryResult::eEnumerateDirectoryResultNext;
 }
 
 FileSpec PlatformDarwin::FindSDKInXcodeForModules(SDKType sdk_type,
                                                   const FileSpec &sdks_spec) {
   // Look inside Xcode for the required installed iOS SDK version
 
-  if (!sdks_spec.IsDirectory())
+  if (!llvm::sys::fs::is_directory(sdks_spec.GetPath())) {
     return FileSpec();
+  }
 
   const bool find_directories = true;
   const bool find_files = false;
   const bool find_other = true; // include symlinks
 
   SDKEnumeratorInfo enumerator_info;
 
   enumerator_info.sdk_type = sdk_type;
 
   FileSpec::EnumerateDirectory(sdks_spec.GetPath(), find_directories,
                                find_files, find_other, DirectoryEnumerator,
                                &enumerator_info);
 
-  if (enumerator_info.found_path.IsDirectory())
+  if (llvm::sys::fs::is_directory(enumerator_info.found_path.GetPath()))
     return enumerator_info.found_path;
   else
     return FileSpec();
 }
 
 FileSpec PlatformDarwin::GetSDKDirectoryForModules(SDKType sdk_type) {
   switch (sdk_type) {
   case SDKType::MacOSX:
#endif
 
   FileSpec sysroot_spec;
   // Scope for mutex locker below
   {
     std::lock_guard<std::mutex> guard(m_mutex);
     sysroot_spec = GetSDKDirectoryForModules(sdk_type);
   }
 
-  if (sysroot_spec.IsDirectory()) {
+  if (llvm::sys::fs::is_directory(sysroot_spec.GetPath())) {
     options.push_back("-isysroot");
     options.push_back(sysroot_spec.GetPath());
   }
 }
 
 ConstString PlatformDarwin::GetFullNameForDylib(ConstString basename) {
   if (basename.IsEmpty())
     return basename;

lldb/source/Plugins/Platform/MacOSX/PlatformDarwinKernel.h

 #if defined(__APPLE__) // This Plugin uses the Mac-specific
                        // source/Host/macosx/cfcpp utilities
 
 // C Includes
 // C++ Includes
 // Other libraries and framework includes
 #include "lldb/Host/FileSpec.h"
 
+#include "llvm/Support/FileSystem.h"
+
 // Project includes
 #include "PlatformDarwin.h"
 
 class PlatformDarwinKernel : public PlatformDarwin {
 public:
   //------------------------------------------------------------
   // Class Functions
   //------------------------------------------------------------
protected:
   void GetUserSpecifiedDirectoriesToSearch();
 
   static void AddRootSubdirsToSearchPaths(PlatformDarwinKernel *thisp,
                                           const std::string &dir);
 
   void AddSDKSubdirsToSearchPaths(const std::string &dir);
 
   static lldb_private::FileSpec::EnumerateDirectoryResult
-  FindKDKandSDKDirectoriesInDirectory(
-      void *baton, lldb_private::FileSpec::FileType file_type,
+  FindKDKandSDKDirectoriesInDirectory(void *baton, llvm::sys::fs::file_type ft,
                                       const lldb_private::FileSpec &file_spec);
 
   void SearchForKextsAndKernelsRecursively();
 
   static lldb_private::FileSpec::EnumerateDirectoryResult
   GetKernelsAndKextsInDirectoryWithRecursion(
-      void *baton, lldb_private::FileSpec::FileType file_type,
+      void *baton, llvm::sys::fs::file_type ft,
       const lldb_private::FileSpec &file_spec);
 
   static lldb_private::FileSpec::EnumerateDirectoryResult
   GetKernelsAndKextsInDirectoryNoRecursion(
-      void *baton, lldb_private::FileSpec::FileType file_type,
+      void *baton, llvm::sys::fs::file_type ft,
       const lldb_private::FileSpec &file_spec);
 
   static lldb_private::FileSpec::EnumerateDirectoryResult
-  GetKernelsAndKextsInDirectoryHelper(
-      void *baton, lldb_private::FileSpec::FileType file_type,
-      const lldb_private::FileSpec &file_spec, bool recurse);
+  GetKernelsAndKextsInDirectoryHelper(void *baton, llvm::sys::fs::file_type ft,
+                                      const lldb_private::FileSpec &file_spec,
+                                      bool recurse);
 
   static void AddKextToMap(PlatformDarwinKernel *thisp,
                            const lldb_private::FileSpec &file_spec);
 
   // Returns true if there is a .dSYM bundle next to the kext, or next to the
   // binary inside the kext.
   static bool
   KextHasdSYMSibling(const lldb_private::FileSpec &kext_bundle_filepath);

lldb/source/Plugins/Platform/MacOSX/PlatformDarwinKernel.cpp

 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Target/Platform.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/Error.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/StreamString.h"
 
+#include "llvm/Support/FileSystem.h"
+
 #include <CoreFoundation/CoreFoundation.h>
 
 #include "Host/macosx/cfcpp/CFCBundle.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 //------------------------------------------------------------------
void PlatformDarwinKernel::CollectKextAndKernelDirectories() {
   if (m_ios_debug_session != eLazyBoolYes) {
     AddRootSubdirsToSearchPaths(this, "/");
   }
 
   GetUserSpecifiedDirectoriesToSearch();
 
   // Add simple directory /Applications/Xcode.app/Contents/Developer/../Symbols
   FileSpec possible_dir(developer_dir + "/../Symbols", true);
-  if (possible_dir.Exists() && possible_dir.IsDirectory())
+  if (llvm::sys::fs::is_directory(possible_dir.GetPath()))
     m_search_directories.push_back(possible_dir);
 
   // Add simple directory of the current working directory
   m_search_directories_no_recursing.push_back(FileSpec(".", true));
 }
 
 void PlatformDarwinKernel::GetUserSpecifiedDirectoriesToSearch() {
   FileSpecList user_dirs(GetGlobalProperties()->GetKextDirectories());
   std::vector<FileSpec> possible_sdk_dirs;
 
   const uint32_t user_dirs_count = user_dirs.GetSize();
   for (uint32_t i = 0; i < user_dirs_count; i++) {
     FileSpec dir = user_dirs.GetFileSpecAtIndex(i);
     dir.ResolvePath();
-    if (dir.Exists() && dir.IsDirectory()) {
+    if (llvm::sys::fs::is_directory(dir.GetPath())) {
       m_search_directories.push_back(dir);
     }
   }
 }
 
 void PlatformDarwinKernel::AddRootSubdirsToSearchPaths(
     PlatformDarwinKernel *thisp, const std::string &dir) {
   const char *subdirs[] = {
       "/System/Library/Extensions", "/Library/Extensions",
       "/System/Library/Kernels",
       "/System/Library/Extensions/KDK", // this one probably only exist in
                                         // /AppleInternal/Developer/KDKs/*.kdk/...
       nullptr};
   for (int i = 0; subdirs[i] != nullptr; i++) {
     FileSpec testdir(dir + subdirs[i], true);
-    if (testdir.Exists() && testdir.IsDirectory())
+    if (llvm::sys::fs::is_directory(testdir.GetPath()))
       thisp->m_search_directories.push_back(testdir);
   }
 
   // Look for kernel binaries in the top level directory, without any recursion
   thisp->m_search_directories_no_recursing.push_back(
       FileSpec(dir + "/", false));
 }
 
 // Given a directory path dir, look for any subdirs named *.kdk and *.sdk
 void PlatformDarwinKernel::AddSDKSubdirsToSearchPaths(const std::string &dir) {
   // Look for *.kdk and *.sdk in dir
   const bool find_directories = true;
   const bool find_files = false;
   const bool find_other = false;
   FileSpec::EnumerateDirectory(dir.c_str(), find_directories, find_files,
                                find_other, FindKDKandSDKDirectoriesInDirectory,
                                this);
 }
 
 // Helper function to find *.sdk and *.kdk directories in a given directory.
 FileSpec::EnumerateDirectoryResult
 PlatformDarwinKernel::FindKDKandSDKDirectoriesInDirectory(
-    void *baton, FileSpec::FileType file_type, const FileSpec &file_spec) {
+    void *baton, llvm::sys::fs::file_type ft, const FileSpec &file_spec) {
   static ConstString g_sdk_suffix = ConstString("sdk");
   static ConstString g_kdk_suffix = ConstString("kdk");
 
   PlatformDarwinKernel *thisp = (PlatformDarwinKernel *)baton;
-  if (file_type == FileSpec::eFileTypeDirectory &&
+  if (ft == llvm::sys::fs::file_type::directory_file &&
       (file_spec.GetFileNameExtension() == g_sdk_suffix ||
        file_spec.GetFileNameExtension() == g_kdk_suffix)) {
     AddRootSubdirsToSearchPaths(thisp, file_spec.GetPath());
   }
   return FileSpec::eEnumerateDirectoryResultNext;
 }
 
 // Recursively search trough m_search_directories looking for

 // the UUID of a file (or if it's a Mach-O binary at all) without creating a
 // whole Module for
 // the file and throwing it away if it's not wanted.
 //
 // Recurse into any subdirectories found.
 
 FileSpec::EnumerateDirectoryResult
 PlatformDarwinKernel::GetKernelsAndKextsInDirectoryWithRecursion(
-    void *baton, FileSpec::FileType file_type, const FileSpec &file_spec) {
-  return GetKernelsAndKextsInDirectoryHelper(baton, file_type, file_spec, true);
+    void *baton, llvm::sys::fs::file_type ft, const FileSpec &file_spec) {
+  return GetKernelsAndKextsInDirectoryHelper(baton, ft, file_spec, true);
 }
 
 FileSpec::EnumerateDirectoryResult
 PlatformDarwinKernel::GetKernelsAndKextsInDirectoryNoRecursion(
-    void *baton, FileSpec::FileType file_type, const FileSpec &file_spec) {
-  return GetKernelsAndKextsInDirectoryHelper(baton, file_type, file_spec,
-                                             false);
+    void *baton, llvm::sys::fs::file_type ft, const FileSpec &file_spec) {
+  return GetKernelsAndKextsInDirectoryHelper(baton, ft, file_spec, false);
 }
 
 FileSpec::EnumerateDirectoryResult
 PlatformDarwinKernel::GetKernelsAndKextsInDirectoryHelper(
-    void *baton, FileSpec::FileType file_type, const FileSpec &file_spec,
+    void *baton, llvm::sys::fs::file_type ft, const FileSpec &file_spec,
     bool recurse) {
   static ConstString g_kext_suffix = ConstString("kext");
   static ConstString g_dsym_suffix = ConstString("dSYM");
   static ConstString g_bundle_suffix = ConstString("Bundle");
   ConstString file_spec_extension = file_spec.GetFileNameExtension();
 
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_PLATFORM));
   if (log)
     log->Printf("PlatformDarwinKernel examining %s",
                 file_spec.GetPath().c_str());
 
   PlatformDarwinKernel *thisp = (PlatformDarwinKernel *)baton;
-  if (file_type == FileSpec::eFileTypeRegular ||
-      file_type == FileSpec::eFileTypeSymbolicLink) {
+  if (ft == llvm::sys::fs::file_type::regular_file ||
+      ft == llvm::sys::fs::file_type::symlink_file) {
     ConstString filename = file_spec.GetFilename();
     if ((strncmp(filename.GetCString(), "kernel", 6) == 0 ||
          strncmp(filename.GetCString(), "mach", 4) == 0) &&
         file_spec_extension != g_dsym_suffix) {
       if (KernelHasdSYMSibling(file_spec))
         thisp->m_kernel_binaries_with_dsyms.push_back(file_spec);
       else
         thisp->m_kernel_binaries_without_dsyms.push_back(file_spec);
       return FileSpec::eEnumerateDirectoryResultNext;
     }
-  } else if (file_type == FileSpec::eFileTypeDirectory &&
+  } else if (ft == llvm::sys::fs::file_type::directory_file &&
              file_spec_extension == g_kext_suffix) {
     AddKextToMap(thisp, file_spec);
     // Look to see if there is a PlugIns subdir with more kexts
     FileSpec contents_plugins(file_spec.GetPath() + "/Contents/PlugIns", false);
     std::string search_here_too;
-    if (contents_plugins.Exists() && contents_plugins.IsDirectory()) {
+    if (llvm::sys::fs::is_directory(contents_plugins.GetPath())) {
       search_here_too = contents_plugins.GetPath();
     } else {
       FileSpec plugins(file_spec.GetPath() + "/PlugIns", false);
-      if (plugins.Exists() && plugins.IsDirectory()) {
+      if (llvm::sys::fs::is_directory(plugins.GetPath())) {
         search_here_too = plugins.GetPath();
       }
     }
 
     if (!search_here_too.empty()) {
       const bool find_directories = true;
       const bool find_files = false;
       const bool find_other = false;

 //    /dir/dir/foo.kext/Contents/MacOS/foo.dSYM
 //    /dir/dir/foo.kext/foo.dSYM
 bool PlatformDarwinKernel::KextHasdSYMSibling(
     const FileSpec &kext_bundle_filepath) {
   FileSpec dsym_fspec = kext_bundle_filepath;
   std::string filename = dsym_fspec.GetFilename().AsCString();
   filename += ".dSYM";
   dsym_fspec.GetFilename() = ConstString(filename);
-  if (dsym_fspec.Exists() && dsym_fspec.IsDirectory()) {
+  if (llvm::sys::fs::is_directory(dsym_fspec.GetPath())) {
     return true;
   }
   // Should probably get the CFBundleExecutable here or call
   // CFBundleCopyExecutableURL
 
   // Look for a deep bundle foramt
   ConstString executable_name =
       kext_bundle_filepath.GetFileNameStrippingExtension();
   std::string deep_bundle_str =
       kext_bundle_filepath.GetPath() + "/Contents/MacOS/";
   deep_bundle_str += executable_name.AsCString();
   deep_bundle_str += ".dSYM";
   dsym_fspec.SetFile(deep_bundle_str, true);
-  if (dsym_fspec.Exists() && dsym_fspec.IsDirectory()) {
+  if (llvm::sys::fs::is_directory(dsym_fspec.GetPath())) {
     return true;
   }
 
   // look for a shallow bundle format
   //
   std::string shallow_bundle_str = kext_bundle_filepath.GetPath() + "/";
   shallow_bundle_str += executable_name.AsCString();
   shallow_bundle_str += ".dSYM";
   dsym_fspec.SetFile(shallow_bundle_str, true);
-  if (dsym_fspec.Exists() && dsym_fspec.IsDirectory()) {
+  if (llvm::sys::fs::is_directory(dsym_fspec.GetPath())) {
     return true;
   }
   return false;
 }
 
 // Given a FileSpec of /dir/dir/mach.development.t7004
 // Return true if a dSYM exists next to it:
 //    /dir/dir/mach.development.t7004.dSYM
 bool PlatformDarwinKernel::KernelHasdSYMSibling(const FileSpec &kernel_binary) {
   FileSpec kernel_dsym = kernel_binary;
   std::string filename = kernel_binary.GetFilename().AsCString();
   filename += ".dSYM";
   kernel_dsym.GetFilename() = ConstString(filename);
-  if (kernel_dsym.Exists() && kernel_dsym.IsDirectory()) {
+  if (llvm::sys::fs::is_directory(kernel_dsym.GetPath())) {
     return true;
   }
   return false;
 }
 
 Error PlatformDarwinKernel::GetSharedModule(
     const ModuleSpec &module_spec, Process *process, ModuleSP &module_sp,
     const FileSpecList *module_search_paths_ptr, ModuleSP *old_module_sp_ptr,

lldb/source/Plugins/Platform/MacOSX/PlatformRemoteAppleTV.h

 // C Includes
 // C++ Includes
 #include <string>
 
 // Other libraries and framework includes
 // Project includes
 #include "lldb/Host/FileSpec.h"
 
+#include "llvm/Support/FileSystem.h"
+
 #include "PlatformDarwin.h"
 
 class PlatformRemoteAppleTV : public PlatformDarwin {
 public:
   PlatformRemoteAppleTV();
 
   ~PlatformRemoteAppleTV() override = default;
 
protected:
   const char *GetDeviceSupportDirectoryForOSVersion();
 
   const SDKDirectoryInfo *GetSDKDirectoryForLatestOSVersion();
 
   const SDKDirectoryInfo *GetSDKDirectoryForCurrentOSVersion();
 
   static lldb_private::FileSpec::EnumerateDirectoryResult
   GetContainedFilesIntoVectorOfStringsCallback(
-      void *baton, lldb_private::FileSpec::FileType file_type,
+      void *baton, llvm::sys::fs::file_type ft,
       const lldb_private::FileSpec &file_spec);
 
   uint32_t FindFileInAllSDKs(const char *platform_file_path,
                              lldb_private::FileSpecList &file_list);
 
   bool GetFileInSDK(const char *platform_file_path, uint32_t sdk_idx,
                     lldb_private::FileSpec &local_file);
 

lldb/source/Plugins/Platform/MacOSX/PlatformRemoteAppleTV.cpp

error.SetErrorStringWithFormat(
         resolved_module_spec.GetFileSpec().GetPath().c_str());
   }
 
   return error;
 }
 
 FileSpec::EnumerateDirectoryResult
 PlatformRemoteAppleTV::GetContainedFilesIntoVectorOfStringsCallback(
-    void *baton, FileSpec::FileType file_type, const FileSpec &file_spec) {
+    void *baton, llvm::sys::fs::file_type ft, const FileSpec &file_spec) {
   ((PlatformRemoteAppleTV::SDKDirectoryInfoCollection *)baton)
       ->push_back(PlatformRemoteAppleTV::SDKDirectoryInfo(file_spec));
   return FileSpec::eEnumerateDirectoryResultNext;
 }
 
 bool PlatformRemoteAppleTV::UpdateSDKDirectoryInfosIfNeeded() {
   Log *log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_HOST);
   std::lock_guard<std::mutex> guard(m_sdk_dir_mutex);

lldb/source/Plugins/Platform/MacOSX/PlatformRemoteAppleWatch.h

 #include <vector>
 
 // Other libraries and framework includes
 // Project includes
 #include "lldb/Host/FileSpec.h"
 
 #include "PlatformDarwin.h"
 
+#include "llvm/Support/FileSystem.h"
+
 class PlatformRemoteAppleWatch : public PlatformDarwin {
 public:
   PlatformRemoteAppleWatch();
 
   ~PlatformRemoteAppleWatch() override = default;
 
   //------------------------------------------------------------
   // Class Functions
protected:
   const char *GetDeviceSupportDirectoryForOSVersion();
 
   const SDKDirectoryInfo *GetSDKDirectoryForLatestOSVersion();
 
   const SDKDirectoryInfo *GetSDKDirectoryForCurrentOSVersion();
 
   static lldb_private::FileSpec::EnumerateDirectoryResult
   GetContainedFilesIntoVectorOfStringsCallback(
-      void *baton, lldb_private::FileSpec::FileType file_type,
+      void *baton, llvm::sys::fs::file_type ft,
       const lldb_private::FileSpec &file_spec);
 
   uint32_t FindFileInAllSDKs(const char *platform_file_path,
                              lldb_private::FileSpecList &file_list);
 
   bool GetFileInSDK(const char *platform_file_path, uint32_t sdk_idx,
                     lldb_private::FileSpec &local_file);
 

lldb/source/Plugins/Platform/MacOSX/PlatformRemoteAppleWatch.cpp

error.SetErrorStringWithFormat(
         resolved_module_spec.GetFileSpec().GetPath().c_str());
   }
 
   return error;
 }
 
 FileSpec::EnumerateDirectoryResult
 PlatformRemoteAppleWatch::GetContainedFilesIntoVectorOfStringsCallback(
-    void *baton, FileSpec::FileType file_type, const FileSpec &file_spec) {
+    void *baton, llvm::sys::fs::file_type ft, const FileSpec &file_spec) {
   ((PlatformRemoteAppleWatch::SDKDirectoryInfoCollection *)baton)
       ->push_back(PlatformRemoteAppleWatch::SDKDirectoryInfo(file_spec));
   return FileSpec::eEnumerateDirectoryResultNext;
 }
 
 bool PlatformRemoteAppleWatch::UpdateSDKDirectoryInfosIfNeeded() {
   Log *log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_HOST);
   std::lock_guard<std::mutex> guard(m_sdk_dir_mutex);

lldb/source/Plugins/Platform/MacOSX/PlatformRemoteiOS.h

 // C++ Includes
 #include <string>
 
 // Other libraries and framework includes
 // Project includes
 #include "PlatformDarwin.h"
 #include "lldb/Host/FileSpec.h"
 
+#include "llvm/Support/FileSystem.h"
+
 class PlatformRemoteiOS : public PlatformDarwin {
 public:
   PlatformRemoteiOS();
 
   ~PlatformRemoteiOS() override;
 
   //------------------------------------------------------------
   // Class Functions
protected:
   const char *GetDeviceSupportDirectoryForOSVersion();
 
   const SDKDirectoryInfo *GetSDKDirectoryForLatestOSVersion();
 
   const SDKDirectoryInfo *GetSDKDirectoryForCurrentOSVersion();
 
   static lldb_private::FileSpec::EnumerateDirectoryResult
   GetContainedFilesIntoVectorOfStringsCallback(
-      void *baton, lldb_private::FileSpec::FileType file_type,
+      void *baton, llvm::sys::fs::file_type ft,
       const lldb_private::FileSpec &file_spec);
 
   uint32_t FindFileInAllSDKs(const char *platform_file_path,
                              lldb_private::FileSpecList &file_list);
 
   bool GetFileInSDK(const char *platform_file_path, uint32_t sdk_idx,
                     lldb_private::FileSpec &local_file);
 

lldb/source/Plugins/Platform/MacOSX/PlatformRemoteiOS.cpp

error.SetErrorStringWithFormat(
         resolved_module_spec.GetFileSpec().GetPath().c_str());
   }
 
   return error;
 }
 
 FileSpec::EnumerateDirectoryResult
 PlatformRemoteiOS::GetContainedFilesIntoVectorOfStringsCallback(
-    void *baton, FileSpec::FileType file_type, const FileSpec &file_spec) {
+    void *baton, llvm::sys::fs::file_type ft, const FileSpec &file_spec) {
   ((PlatformRemoteiOS::SDKDirectoryInfoCollection *)baton)
       ->push_back(PlatformRemoteiOS::SDKDirectoryInfo(file_spec));
   return FileSpec::eEnumerateDirectoryResultNext;
 }
 
 bool PlatformRemoteiOS::UpdateSDKDirectoryInfosIfNeeded() {
   Log *log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_HOST);
   std::lock_guard<std::mutex> guard(m_sdk_dir_mutex);

lldb/source/Plugins/Platform/MacOSX/PlatformiOSSimulator.cpp

 #include "lldb/Host/Host.h"
 #include "lldb/Host/HostInfo.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/Error.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/StreamString.h"
 
+#include "llvm/Support/FileSystem.h"
+
 using namespace lldb;
 using namespace lldb_private;
 
 //------------------------------------------------------------------
 // Static Variables
 //------------------------------------------------------------------
 static uint32_t g_initialize_count = 0;
 
if (resolved_module_spec.GetFileSpec().Exists()) {
     error.SetErrorStringWithFormat("'%s' does not exist",
                                    module_spec.GetFileSpec().GetPath().c_str());
   }
 
   return error;
 }
 
 static FileSpec::EnumerateDirectoryResult
-EnumerateDirectoryCallback(void *baton, FileSpec::FileType file_type,
+EnumerateDirectoryCallback(void *baton, llvm::sys::fs::file_type ft,
                            const FileSpec &file_spec) {
-  if (file_type == FileSpec::eFileTypeDirectory) {
+  if (ft == llvm::sys::fs::file_type::directory_file) {
     const char *filename = file_spec.GetFilename().GetCString();
     if (filename &&
         strncmp(filename, "iPhoneSimulator", strlen("iPhoneSimulator")) == 0) {
       ::snprintf((char *)baton, PATH_MAX, "%s", filename);
       return FileSpec::eEnumerateDirectoryResultQuit;
     }
   }
   return FileSpec::eEnumerateDirectoryResultNext;

lldb/source/Plugins/Process/Darwin/NativeProcessDarwin.cpp

 #include "lldb/Utility/StreamString.h"
 
 #include "CFBundle.h"
 #include "CFString.h"
 #include "DarwinProcessLauncher.h"
 
 #include "MachException.h"
 
+#include "llvm/Support/FileSystem.h"
+
 using namespace lldb;
 using namespace lldb_private;
 using namespace lldb_private::process_darwin;
 using namespace lldb_private::darwin_process_launcher;
 
 // -----------------------------------------------------------------------------
 // Hidden Impl
 // -----------------------------------------------------------------------------
Error NativeProcessProtocol::Launch(
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS));
 
   Error error;
 
   // Verify the working directory is valid if one was specified.
   FileSpec working_dir(launch_info.GetWorkingDirectory());
   if (working_dir &&
       (!working_dir.ResolvePath() ||
-       working_dir.GetFileType() != FileSpec::eFileTypeDirectory)) {
+       !llvm::sys::fs::is_directory(working_dir.GetPath())) {
     error.SetErrorStringWithFormat("No such file or directory: %s",
                                    working_dir.GetCString());
     return error;
   }
 
   // Launch the inferior.
   int pty_master_fd = -1;
   LaunchFlavor launch_flavor = LaunchFlavor::Default;

lldb/source/Plugins/Process/FreeBSD/ProcessFreeBSD.cpp

 #include "lldb/Host/Host.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Target/DynamicLoader.h"
 #include "lldb/Target/Platform.h"
 #include "lldb/Target/Target.h"
 
 #include "lldb/Host/posix/Fcntl.h"
 
+#include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Threading.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 namespace {
 UnixSignalsSP &GetFreeBSDSignals() {
   static UnixSignalsSP s_freebsd_signals_sp(new FreeBSDSignals());
ProcessFreeBSD::GetFileSpec(const lldb_private::FileAction *file_action,
   return file_spec;
 }
 
 Error ProcessFreeBSD::DoLaunch(Module *module, ProcessLaunchInfo &launch_info) {
   Error error;
   assert(m_monitor == NULL);
 
   FileSpec working_dir = launch_info.GetWorkingDirectory();
-  if (working_dir &&
-      (!working_dir.ResolvePath() ||
-       working_dir.GetFileType() != FileSpec::eFileTypeDirectory)) {
+  namespace fs = llvm::sys::fs;
+  if (working_dir && (!working_dir.ResolvePath() ||
+                      !fs::is_directory(working_dir.GetPath()))) {
     error.SetErrorStringWithFormat("No such file or directory: %s",
                                    working_dir.GetCString());
     return error;
   }
 
   SetPrivateState(eStateLaunching);
 
   const lldb_private::FileAction *file_action;

lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp

 #include "lldb/Utility/LLDBAssert.h"
 #include "lldb/Utility/StringExtractor.h"
 
 #include "NativeThreadLinux.h"
 #include "Plugins/Process/POSIX/ProcessPOSIXLog.h"
 #include "ProcFileReader.h"
 #include "Procfs.h"
 
+#include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Threading.h"
 
 #include <linux/unistd.h>
 #include <sys/socket.h>
 #include <sys/syscall.h>
 #include <sys/types.h>
 #include <sys/user.h>
 #include <sys/wait.h>
Error NativeProcessProtocol::Launch(
     NativeProcessProtocol::NativeDelegate &native_delegate, MainLoop &mainloop,
     NativeProcessProtocolSP &native_process_sp) {
   Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_PROCESS));
 
   Error error;
 
   // Verify the working directory is valid if one was specified.
   FileSpec working_dir{launch_info.GetWorkingDirectory()};
-  if (working_dir &&
-      (!working_dir.ResolvePath() ||
-       working_dir.GetFileType() != FileSpec::eFileTypeDirectory)) {
+  if (working_dir && (!working_dir.ResolvePath() ||
+                      !llvm::sys::fs::is_directory(working_dir.GetPath()))) {
     error.SetErrorStringWithFormat("No such file or directory: %s",
                                    working_dir.GetCString());
     return error;
   }
 
   // Create the NativeProcessLinux in launch mode.
   native_process_sp.reset(new NativeProcessLinux());
 

lldb/source/Plugins/ScriptInterpreter/Python/ScriptInterpreterPython.cpp

 #include "lldb/Target/ThreadPlan.h"
 
 #if defined(_WIN32)
 #include "lldb/Host/windows/ConnectionGenericFileWindows.h"
 #endif
 
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringRef.h"
+#include "llvm/Support/FileSystem.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 static ScriptInterpreterPython::SWIGInitCallback g_swig_init_callback = nullptr;
 static ScriptInterpreterPython::SWIGBreakpointCallbackFunction
     g_swig_breakpoint_callback = nullptr;
 static ScriptInterpreterPython::SWIGWatchpointCallbackFunction
lldb::DebuggerSP debugger_sp = m_interpreter.GetDebugger().shared_from_this();
     StreamString command_stream;
 
     // Before executing Python code, lock the GIL.
     Locker py_lock(this, Locker::AcquireLock |
                              (init_session ? Locker::InitSession : 0) |
                              Locker::NoSTDIN,
                    Locker::FreeAcquiredLock |
                        (init_session ? Locker::TearDownSession : 0));
-
-    if (target_file.GetFileType() == FileSpec::eFileTypeInvalid ||
-        target_file.GetFileType() == FileSpec::eFileTypeUnknown) {
+    namespace fs = llvm::sys::fs;
+    fs::file_status st;
+    std::error_code ec = status(target_file.GetPath(), st);
+
+    if (ec || st.type() == fs::file_type::status_error ||
+        st.type() == fs::file_type::type_unknown ||
+        st.type() == fs::file_type::file_not_found) {
       // if not a valid file of any sort, check if it might be a filename still
       // dot can't be used but / and \ can, and if either is found, reject
       if (strchr(pathname, '\\') || strchr(pathname, '/')) {
         error.SetErrorString("invalid pathname");
         return false;
       }
       basename = pathname; // not a filename, probably a package of some sort,
                            // let it go through
-    } else if (target_file.GetFileType() == FileSpec::eFileTypeDirectory ||
-               target_file.GetFileType() == FileSpec::eFileTypeRegular ||
-               target_file.GetFileType() == FileSpec::eFileTypeSymbolicLink) {
+    } else if (is_directory(st) || is_regular_file(st)) {
       std::string directory = target_file.GetDirectory().GetCString();
       replace_all(directory, "\\", "\\\\");
       replace_all(directory, "'", "\\'");
 
       // now make sure that Python has "directory" in the search path
       StreamString command_stream;
       command_stream.Printf("if not (sys.path.__contains__('%s')):\n    "
                             "sys.path.insert(1,'%s');\n\n",

lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

 #include "DWARFDebugPubnames.h"
 #include "DWARFDebugRanges.h"
 #include "DWARFDeclContext.h"
 #include "DWARFFormValue.h"
 #include "LogChannelDWARF.h"
 #include "SymbolFileDWARFDebugMap.h"
 #include "SymbolFileDWARFDwo.h"
 
+#include "llvm/Support/FileSystem.h"
+
 #include <map>
 
 #include <ctype.h>
 #include <string.h>
 
 //#define ENABLE_DEBUG_PRINTF // COMMENT OUT THIS LINE PRIOR TO CHECKIN
 
 #ifdef ENABLE_DEBUG_PRINTF
static const char *resolveCompDir(const char *path_from_dwarf) {
   const auto &file_specs = GetGlobalPluginProperties()->GetSymLinkPaths();
   for (size_t i = 0; i < file_specs.GetSize() && !is_symlink; ++i)
     is_symlink = FileSpec::Equal(file_specs.GetFileSpecAtIndex(i),
                                  local_path_spec, true);
 
   if (!is_symlink)
     return local_path;
 
-  if (!local_path_spec.IsSymbolicLink())
+  namespace fs = llvm::sys::fs;
+  if (fs::get_file_type(local_path_spec.GetPath(), false) !=
+      fs::file_type::symlink_file)
     return local_path;
 
   FileSpec resolved_local_path_spec;
   const auto error =
       FileSystem::Readlink(local_path_spec, resolved_local_path_spec);
   if (error.Success())
     return resolved_local_path_spec.GetCString();
 

lldb/source/Target/ModuleCache.cpp

private:
   std::unique_ptr<lldb_private::LockFile> m_lock;
   FileSpec m_file_spec;
 
 public:
   ModuleLock(const FileSpec &root_dir_spec, const UUID &uuid, Error &error);
   void Delete();
 };
 
-FileSpec JoinPath(const FileSpec &path1, const char *path2) {
+static FileSpec JoinPath(const FileSpec &path1, const char *path2) {
   FileSpec result_spec(path1);
   result_spec.AppendPathComponent(path2);
   return result_spec;
 }
 
-Error MakeDirectory(const FileSpec &dir_path) {
-  if (dir_path.Exists()) {
-    if (!dir_path.IsDirectory())
-      return Error("Invalid existing path");
+static Error MakeDirectory(const FileSpec &dir_path) {
+  namespace fs = llvm::sys::fs;
 
-    return Error();
-  }
-
-  return FileSystem::MakeDirectory(dir_path, eFilePermissionsDirectoryDefault);
+  return fs::create_directories(dir_path.GetPath(), true, fs::perms::owner_all);
 }
 
 FileSpec GetModuleDirectory(const FileSpec &root_dir_spec, const UUID &uuid) {
   const auto modules_dir_spec = JoinPath(root_dir_spec, kModulesSubdir);
   return JoinPath(modules_dir_spec, uuid.GetAsString().c_str());
 }
 
 FileSpec GetSymbolFileSpec(const FileSpec &module_file_spec) {

lldb/source/Target/Platform.cpp

 #include "lldb/Target/Platform.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/UnixSignals.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/Error.h"
 #include "lldb/Utility/Log.h"
 
+#include "llvm/Support/FileSystem.h"
+
 // Define these constants from POSIX mman.h rather than include the file
 // so that they will be correct even when compiled on Linux.
 #define MAP_PRIVATE 2
 #define MAP_ANON 0x1000
 
 using namespace lldb;
 using namespace lldb_private;
 

 
 struct RecurseCopyBaton {
   const FileSpec &dst;
   Platform *platform_ptr;
   Error error;
 };
 
 static FileSpec::EnumerateDirectoryResult
-RecurseCopy_Callback(void *baton, FileSpec::FileType file_type,
+RecurseCopy_Callback(void *baton, llvm::sys::fs::file_type ft,
                      const FileSpec &src) {
   RecurseCopyBaton *rc_baton = (RecurseCopyBaton *)baton;
-  switch (file_type) {
-  case FileSpec::eFileTypePipe:
-  case FileSpec::eFileTypeSocket:
+  namespace fs = llvm::sys::fs;
+  switch (ft) {
+  case fs::file_type::fifo_file:
+  case fs::file_type::socket_file:
     // we have no way to copy pipes and sockets - ignore them and continue
     return FileSpec::eEnumerateDirectoryResultNext;
     break;
 
-  case FileSpec::eFileTypeDirectory: {
+  case fs::file_type::directory_file: {
     // make the new directory and get in there
     FileSpec dst_dir = rc_baton->dst;
     if (!dst_dir.GetFilename())
       dst_dir.GetFilename() = src.GetLastPathComponent();
     Error error = rc_baton->platform_ptr->MakeDirectory(
         dst_dir, lldb::eFilePermissionsDirectoryDefault);
     if (error.Fail()) {
       rc_baton->error.SetErrorStringWithFormat(
FileSpec::EnumerateDirectory(src_dir_path, true, true, true,
                                  RecurseCopy_Callback, &rc_baton2);
     if (rc_baton2.error.Fail()) {
       rc_baton->error.SetErrorString(rc_baton2.error.AsCString());
       return FileSpec::eEnumerateDirectoryResultQuit; // got an error, bail out
     }
     return FileSpec::eEnumerateDirectoryResultNext;
   } break;
 
-  case FileSpec::eFileTypeSymbolicLink: {
+  case fs::file_type::symlink_file: {
     // copy the file and keep going
     FileSpec dst_file = rc_baton->dst;
     if (!dst_file.GetFilename())
       dst_file.GetFilename() = src.GetFilename();
 
     FileSpec src_resolved;
 
     rc_baton->error = FileSystem::Readlink(src, src_resolved);
 
     if (rc_baton->error.Fail())
       return FileSpec::eEnumerateDirectoryResultQuit; // got an error, bail out
 
     rc_baton->error =
         rc_baton->platform_ptr->CreateSymlink(dst_file, src_resolved);
 
     if (rc_baton->error.Fail())
       return FileSpec::eEnumerateDirectoryResultQuit; // got an error, bail out
 
     return FileSpec::eEnumerateDirectoryResultNext;
   } break;
 
-  case FileSpec::eFileTypeRegular: {
+  case fs::file_type::regular_file: {
     // copy the file and keep going
     FileSpec dst_file = rc_baton->dst;
     if (!dst_file.GetFilename())
       dst_file.GetFilename() = src.GetFilename();
     Error err = rc_baton->platform_ptr->PutFile(src, dst_file);
     if (err.Fail()) {
       rc_baton->error.SetErrorString(err.AsCString());
       return FileSpec::eEnumerateDirectoryResultQuit; // got an error, bail out
     }
     return FileSpec::eEnumerateDirectoryResultNext;
   } break;
 
-  case FileSpec::eFileTypeInvalid:
-  case FileSpec::eFileTypeOther:
-  case FileSpec::eFileTypeUnknown:
+  default:
     rc_baton->error.SetErrorStringWithFormat(
         "invalid file detected during copy: %s", src.GetPath().c_str());
     return FileSpec::eEnumerateDirectoryResultQuit; // got an error, bail out
     break;
   }
-  llvm_unreachable("Unhandled FileSpec::FileType!");
+  llvm_unreachable("Unhandled file_type!");
 }
 
 Error Platform::Install(const FileSpec &src, const FileSpec &dst) {
   Error error;
 
   Log *log = GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PLATFORM);
   if (log)
     log->Printf("Platform::Install (src='%s', dst='%s')", src.GetPath().c_str(),
Error Platform::Install(const FileSpec &src, const FileSpec &dst) {
   if (log)
     log->Printf("Platform::Install (src='%s', dst='%s') fixed_dst='%s'",
                 src.GetPath().c_str(), dst.GetPath().c_str(),
                 fixed_dst.GetPath().c_str());
 
   if (GetSupportsRSync()) {
     error = PutFile(src, dst);
   } else {
-    switch (src.GetFileType()) {
-    case FileSpec::eFileTypeDirectory: {
+    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);
       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 FileSpec::eFileTypeRegular:
+    case fs::file_type::regular_file:
       if (GetFileExists(fixed_dst))
         Unlink(fixed_dst);
       error = PutFile(src, fixed_dst);
       break;
 
-    case FileSpec::eFileTypeSymbolicLink: {
+    case fs::file_type::symlink_file: {
       if (GetFileExists(fixed_dst))
         Unlink(fixed_dst);
       FileSpec src_resolved;
       error = FileSystem::Readlink(src, src_resolved);
       if (error.Success())
         error = CreateSymlink(dst, src_resolved);
     } break;
-    case FileSpec::eFileTypePipe:
+    case fs::file_type::fifo_file:
       error.SetErrorString("platform install doesn't handle pipes");
       break;
-    case FileSpec::eFileTypeSocket:
+    case fs::file_type::socket_file:
       error.SetErrorString("platform install doesn't handle sockets");
       break;
-    case FileSpec::eFileTypeInvalid:
-    case FileSpec::eFileTypeUnknown:
-    case FileSpec::eFileTypeOther:
+    default:
       error.SetErrorString(
           "platform install doesn't handle non file or directory items");
       break;
     }
   }
   return error;
 }
 

 Error Platform::PutFile(const FileSpec &source, const FileSpec &destination,
                         uint32_t uid, uint32_t gid) {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_PLATFORM));
   if (log)
     log->Printf("[PutFile] Using block by block transfer....\n");
 
   uint32_t source_open_options =
       File::eOpenOptionRead | File::eOpenOptionCloseOnExec;
-  if (source.GetFileType() == FileSpec::eFileTypeSymbolicLink)
+  namespace fs = llvm::sys::fs;
+  if (fs::is_symlink_file(source.GetPath()))
     source_open_options |= File::eOpenOptionDontFollowSymlinks;
 
   File source_file(source, source_open_options, lldb::eFilePermissionsUserRW);
   Error error;
   uint32_t permissions = source_file.GetPermissions(error);
   if (permissions == 0)
     permissions = lldb::eFilePermissionsFileDefault;
 

lldb/source/Target/TargetList.cpp

if (!file.Exists() && user_exe_path.startswith("~")) {
     else
       file = FileSpec(unglobbed_path.c_str(), false);
   }
 
   bool user_exe_path_is_bundle = false;
   char resolved_bundle_exe_path[PATH_MAX];
   resolved_bundle_exe_path[0] = '\0';
   if (file) {
-    if (file.GetFileType() == FileSpec::eFileTypeDirectory)
+    if (llvm::sys::fs::is_directory(file.GetPath()))
       user_exe_path_is_bundle = true;
 
     if (file.IsRelative() && !user_exe_path.empty()) {
       // Ignore paths that start with "./" and "../"
       if (!user_exe_path.startswith("./") && !user_exe_path.startswith("../")) {
         llvm::SmallString<64> cwd;
         if (! llvm::sys::fs::current_path(cwd)) {
           cwd += '/';

lldb/source/Utility/Error.cpp

 // C Includes
 #ifdef __APPLE__
 #include <mach/mach.h>
 #endif
 
 // C++ Includes
 #include <cerrno>
 #include <cstdarg>
+#include <system_error>
 
 // Other libraries and framework includes
 #include "llvm/ADT/SmallVector.h"
 
 // Project includes
 #include "lldb/Utility/Error.h"
 #include "lldb/Utility/VASPrintf.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 Error::Error() : m_code(0), m_type(eErrorTypeInvalid), m_string() {}
 
 Error::Error(ValueType err, ErrorType type)
     : m_code(err), m_type(type), m_string() {}
 
+Error::Error(std::error_code EC)
+    : m_code(EC.value()), m_type(ErrorType::eErrorTypeGeneric),
+      m_string(EC.message()) {}
+
 Error::Error(const Error &rhs) = default;
 
 Error::Error(const char *format, ...)
     : m_code(0), m_type(eErrorTypeInvalid), m_string() {
   va_list args;
   va_start(args, format);
   SetErrorToGenericError();
   SetErrorStringWithVarArg(format, args);

llvm/include/llvm/Support/FileSystem.h

 inline bool is_local(int FD) {
   bool Result;
   return !is_local(FD, Result) && Result;
 }
 
 /// @brief Does status represent a directory?
 ///
 /// @param Path The path to get the type of.
+/// @param follow For symbolic links, indicates whether to return the file type
+///               of the link itself, or of the target.
 /// @returns A value from the file_type enumeration indicating the type of file.
-file_type get_file_type(const Twine &Path, bool follow = true);
+file_type get_file_type(const Twine &Path, bool Follow = true);
 
 /// @brief Does status represent a directory?
 ///
 /// @param status A file_status previously returned from status.
 /// @returns status.type() == file_type::directory_file.
 bool is_directory(file_status status);
 
 /// @brief Is path a directory?
 ///
 /// @param path Input path.
-/// @param result Set to true if \a path is a directory, false if it is not.
-///               Undefined otherwise.
+/// @param result Set to true if \a path is a directory (after following
+///               symlinks, false if it is not. Undefined otherwise.
 /// @returns errc::success if result has been successfully set, otherwise a
 ///          platform-specific error_code.
 std::error_code is_directory(const Twine &path, bool &result);
 
 /// @brief Simpler version of is_directory for clients that don't need to
 ///        differentiate between an error and false.
 inline bool is_directory(const Twine &Path) {
   bool Result;
   return !is_directory(Path, Result) && Result;
 }
 
 /// @brief Does status represent a regular file?
 ///
 /// @param status A file_status previously returned from status.
 /// @returns status_known(status) && status.type() == file_type::regular_file.
 bool is_regular_file(file_status status);
 
 /// @brief Is path a regular file?
 ///
 /// @param path Input path.
-/// @param result Set to true if \a path is a regular file, false if it is not.
-///               Undefined otherwise.
+/// @param result Set to true if \a path is a regular file (after following
+///               symlinks), false if it is not. Undefined otherwise.
 /// @returns errc::success if result has been successfully set, otherwise a
 ///          platform-specific error_code.
 std::error_code is_regular_file(const Twine &path, bool &result);
 
 /// @brief Simpler version of is_regular_file for clients that don't need to
 ///        differentiate between an error and false.
 inline bool is_regular_file(const Twine &Path) {
   bool Result;
   if (is_regular_file(Path, Result))
     return false;
   return Result;
 }
 
+/// @brief Does status represent a symlink file?
+///
+/// @param status A file_status previously returned from status.
+/// @returns status_known(status) && status.type() == file_type::symlink_file.
+bool is_symlink_file(file_status status);
+
+/// @brief Is path a symlink file?
+///
+/// @param path Input path.
+/// @param result Set to true if \a path is a symlink file, false if it is not.
+///               Undefined otherwise.
+/// @returns errc::success if result has been successfully set, otherwise a
+///          platform-specific error_code.
+std::error_code is_symlink_file(const Twine &path, bool &result);
+
+/// @brief Simpler version of is_symlink_file for clients that don't need to
+///        differentiate between an error and false.
+inline bool is_symlink_file(const Twine &Path) {
+  bool Result;
+  if (is_symlink_file(Path, Result))
+    return false;
+  return Result;
+}
+
 /// @brief Does this status represent something that exists but is not a
-///        directory, regular file, or symlink?
+///        directory or regular file?
 ///
 /// @param status A file_status previously returned from status.
 /// @returns exists(s) && !is_regular_file(s) && !is_directory(s)
 bool is_other(file_status status);
 
 /// @brief Is path something that exists but is not a directory,
 ///        regular file, or symlink?
 ///

llvm/lib/Support/Path.cpp

 std::error_code is_regular_file(const Twine &path, bool &result) {
   file_status st;
   if (std::error_code ec = status(path, st))
     return ec;
   result = is_regular_file(st);
   return std::error_code();
 }
 
+bool is_symlink_file(file_status status) {
+  return status.type() == file_type::symlink_file;
+}
+
+std::error_code is_symlink_file(const Twine &path, bool &result) {
+  file_status st;
+  if (std::error_code ec = status(path, st, false))
+    return ec;
+  result = is_symlink_file(st);
+  return std::error_code();
+}
+
 bool is_other(file_status status) {
   return exists(status) &&
          !is_regular_file(status) &&
          !is_directory(status);
 }
 
 std::error_code is_other(const Twine &Path, bool &Result) {
   file_status FileStatus;