Remove all of LLDB's custom filesystem statting code.

[zturner]

Summary

LLVM provides this functionality, so there is no point duplicating it. This is a pretty large patch because we call functions like FileSpec::IsRegularFile(), or FileSpec::GetFileType() all over the place, and all of these are replaced with calls to llvm now. Also deleted is LLDB's entire FileType enumeration.

I don't think it's a very important optimization, but one nice functional change is that we now stat only once when previously we would stat many times on the same file (for example calling Exists() followed by IsDirectory() followed by IsRegularFile() is 3 stats, whereas in this patch we're down to 1.

In addition to all of this, I think this is an important change because it removes an assumption previously baked into the FileSpec API that this was always a valid operation. But it is pretty common to have a FileSpec that refers to a file on a remote platform, perhaps even with an incomptible PathSyntax, and in this case it doesn't make sense to be calling these functions on it.

In any case, it's a necessary pre-requisite to getting FileSpec not be dependent on Host.

[tberghammer]

Can you make the usage of "using namespace llvm::sys::fs;" a bit more consistent? Sometime you write fully qualified name, sometime you add it to the top of the file while sometime only to the function where it is used.

llvm/include/llvm/Support/FileSystem.h

482–486 ↗

(On Diff #90619)

Please fix the comment

[labath]

Cool.

I would find using fs = llvm::sys::fs (or whatever is the correct namespace alias syntax) more readable, as you then still have fs:: in the references, but maybe that's just my preference...

[labath]

Zachary, unfortunately I had to revert this -- while investigating the breakages I've found a problem I don't think any of us realised -- llvm's statting code is based on stat(2), while lldb uses lstat(2). I think we need to go back and re-audit each case to see whether the behavior difference is a problem. In most of the cases, I think using stat would make things simpler (no need to special case symlink as a file type), but at least one case (SymbolFileDWARF) really depends on the lstat behavior (not resolving symlinks), so we need to figure out how to handle that.

lldb/trunk/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/trunk/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/trunk/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 (remainder[0] == '\0' || strstr(name, remainder) == name) {
     if (strlen(name) + parameters->baselen >= PATH_MAX)
       return FileSpec::eEnumerateDirectoryResultNext;
 
     strcpy(end_ptr, name);
 
     bool isa_directory = false;
-    if (file_type == FileSpec::eFileTypeDirectory)
+    if (file_type == llvm::sys::fs::file_type::directory_file)
       isa_directory = true;
-    else if (file_type == FileSpec::eFileTypeSymbolicLink) {
-      if (FileSpec(partial_name_copy, false).IsDirectory())
+    else if (file_type == llvm::sys::fs::file_type::symlink_file) {
+      if (llvm::sys::fs::is_directory(partial_name_copy))
         isa_directory = true;
     }
 
     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';

lldb/trunk/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/trunk/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/trunk/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))
+      return 0;
+    if (exists(stats)) {
+      if (stats.type() == file_type::symlink_file) {
+        // 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/trunk/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/trunk/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/trunk/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/trunk/source/Host/common/FileSpec.cpp

uint64_t FileSpec::GetByteSize() const {
   struct stat file_stats;
   if (GetFileStats(this, &file_stats))
     return file_stats.st_size;
   return 0;
 }
 
 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;
 }
 
 //------------------------------------------------------------------
#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_device;
           break;
         case DT_DIR:
-          file_type = eFileTypeDirectory;
+          ft = file_type::directory_file;
           break;
         case DT_BLK:
-          file_type = eFileTypeOther;
+          ft = file_type::block_device;
           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/trunk/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;
+  if (status(exe_spec.GetPath(), stats) || !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)
       exe_spec = exe_module_sp->GetFileSpec();
   }
 
-  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/trunk/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/trunk/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/trunk/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/trunk/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/trunk/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/trunk/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/trunk/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/trunk/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/trunk/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/trunk/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)) {
+    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/trunk/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/trunk/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/trunk/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/trunk/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/trunk/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/trunk/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/trunk/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/trunk/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/trunk/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/trunk/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/trunk/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());

 }
 
 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)) {
+      (!working_dir.ResolvePath() || !llvm::sys::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/trunk/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/trunk/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) || fs::is_regular_file(st) ||
+               st.type() == fs::file_type::symlink_file) {
       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/trunk/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()) !=
+      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/trunk/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())
+static Error MakeDirectory(const FileSpec &dir_path) {
+  llvm::sys::fs::file_status st;
+  if (status(dir_path.GetPath(), st))
+    return Error("Could not stat path");
+
+  if (exists(st)) {
+    if (!is_directory(st))
       return Error("Invalid existing path");
 
     return Error();
   }
 
   return FileSystem::MakeDirectory(dir_path, eFilePermissionsDirectoryDefault);
 }
 

lldb/trunk/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())) {
+    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::get_file_type(source.GetPath()) == fs::file_type::symlink_file)
     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/trunk/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 += '/';

llvm/trunk/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 status A file_status previously returned from status.
 /// @returns status.type() == file_type::directory_file.
+file_type get_file_type(const Twine &Path);
+
+/// @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.
 /// @returns errc::success if result has been successfully set, otherwise a

llvm/trunk/lib/Support/Path.cpp

 bool exists(file_status status) {
   return status_known(status) && status.type() != file_type::file_not_found;
 }
 
 bool status_known(file_status s) {
   return s.type() != file_type::status_error;
 }
 
+file_type get_file_type(const Twine &Path) {
+  file_status st;
+  if (status(Path, st))
+    return file_type::status_error;
+  return st.type();
+}
+
 bool is_directory(file_status status) {
   return status.type() == file_type::directory_file;
 }
 
 std::error_code is_directory(const Twine &path, bool &result) {
   file_status st;
   if (std::error_code ec = status(path, st))
     return ec;