[FileSystem] Move EnumerateDirectory from FileSpec to FileSystem.

[JDevlieghere]

Summary

This patch moves the EnumerateDirectory functionality and related enums and typedefs from FileSpec to FileSystem. The long term goal is to remove this method and use the filesystem iterators without this indirection, but for introducing the VFS into LLDB this should be sufficient.

[labath]

lgtm

lldb/trunk/include/lldb/Utility/FileSpec.h

public:
   ///
   /// @return
   ///     A boolean value indicating whether the path was updated.
   //------------------------------------------------------------------
   bool RemoveLastPathComponent();
 
   ConstString GetLastPathComponent() const;
 
-  enum EnumerateDirectoryResult {
-    eEnumerateDirectoryResultNext,  // Enumerate next entry in the current
-                                    // directory
-    eEnumerateDirectoryResultEnter, // Recurse into the current entry if it is a
-                                    // directory or symlink, or next if not
-    eEnumerateDirectoryResultQuit   // Stop directory enumerations at any level
-  };
-
-  typedef EnumerateDirectoryResult (*EnumerateDirectoryCallbackType)(
-      void *baton, llvm::sys::fs::file_type file_type, const FileSpec &spec);
-
-  static void EnumerateDirectory(llvm::StringRef dir_path,
-                                 bool find_directories, bool find_files,
-                                 bool find_other,
-                                 EnumerateDirectoryCallbackType callback,
-                                 void *callback_baton);
-
-  typedef std::function<EnumerateDirectoryResult(
-      llvm::sys::fs::file_type file_type, const FileSpec &spec)>
-      DirectoryCallback;
-
 protected:
   //------------------------------------------------------------------
   // Convenience method for setting the file without changing the style.
   //------------------------------------------------------------------
   void SetFile(llvm::StringRef path, bool resolve_path);
 
   //------------------------------------------------------------------
   // Member variables

lldb/trunk/source/Core/Debugger.cpp

 #include "lldb/Core/Mangled.h"    // for Mangled
 #include "lldb/Core/ModuleList.h" // for Mangled
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/StreamAsynchronousIO.h"
 #include "lldb/Core/StreamFile.h"
 #include "lldb/DataFormatters/DataVisualization.h"
 #include "lldb/Expression/REPL.h"
 #include "lldb/Host/File.h" // for File, File::kInv...
+#include "lldb/Host/FileSystem.h"
 #include "lldb/Host/HostInfo.h"
 #include "lldb/Host/Terminal.h"
 #include "lldb/Host/ThreadLauncher.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Interpreter/OptionValue.h" // for OptionValue, Opt...
 #include "lldb/Interpreter/OptionValueProperties.h"
 #include "lldb/Interpreter/OptionValueSInt64.h"
 #include "lldb/Interpreter/OptionValueString.h"
if (g_load_plugin_callback) {
     // The g_load_plugin_callback is registered in SBDebugger::Initialize() 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
+static FileSystem::EnumerateDirectoryResult
 LoadPluginCallback(void *baton, llvm::sys::fs::file_type ft,
-                   const FileSpec &file_spec) {
+                   llvm::StringRef path) {
   Status error;
 
   static ConstString g_dylibext(".dylib");
   static ConstString g_solibext(".so");
 
   if (!baton)
-    return FileSpec::eEnumerateDirectoryResultQuit;
+    return FileSystem::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 (ft == fs::file_type::regular_file || ft == fs::file_type::symlink_file ||
       ft == fs::file_type::type_unknown) {
-    FileSpec plugin_file_spec(file_spec);
+    FileSpec plugin_file_spec(path, false);
     plugin_file_spec.ResolvePath();
 
     if (plugin_file_spec.GetFileNameExtension() != g_dylibext &&
         plugin_file_spec.GetFileNameExtension() != g_solibext) {
-      return FileSpec::eEnumerateDirectoryResultNext;
+      return FileSystem::eEnumerateDirectoryResultNext;
     }
 
     Status plugin_load_error;
     debugger->LoadPlugin(plugin_file_spec, plugin_load_error);
 
-    return FileSpec::eEnumerateDirectoryResultNext;
+    return FileSystem::eEnumerateDirectoryResultNext;
   } 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 FileSystem::eEnumerateDirectoryResultEnter;
   }
 
-  return FileSpec::eEnumerateDirectoryResultNext;
+  return FileSystem::eEnumerateDirectoryResultNext;
 }
 
 void Debugger::InstanceInitialize() {
   const bool find_directories = true;
   const bool find_files = true;
   const bool find_other = true;
   char dir_path[PATH_MAX];
   if (FileSpec dir_spec = HostInfo::GetSystemPluginDir()) {
     if (dir_spec.Exists() && dir_spec.GetPath(dir_path, sizeof(dir_path))) {
-      FileSpec::EnumerateDirectory(dir_path, find_directories, find_files,
-                                   find_other, LoadPluginCallback, this);
+      FileSystem::Instance().EnumerateDirectory(dir_path, find_directories,
+                                                find_files, find_other,
+                                                LoadPluginCallback, this);
     }
   }
 
   if (FileSpec dir_spec = HostInfo::GetUserPluginDir()) {
     if (dir_spec.Exists() && dir_spec.GetPath(dir_path, sizeof(dir_path))) {
-      FileSpec::EnumerateDirectory(dir_path, find_directories, find_files,
-                                   find_other, LoadPluginCallback, this);
+      FileSystem::Instance().EnumerateDirectory(dir_path, find_directories,
+                                                find_files, find_other,
+                                                LoadPluginCallback, this);
     }
   }
 
   PluginManager::DebuggerInitialize(*this);
 }
 
 DebuggerSP Debugger::CreateInstance(lldb::LogOutputCallback log_callback,
                                     void *baton) {

lldb/trunk/source/Core/PluginManager.cpp

 //===-- PluginManager.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/PluginManager.h"
 
 #include "lldb/Core/Debugger.h"
+#include "lldb/Host/FileSystem.h"
 #include "lldb/Host/HostInfo.h"
 #include "lldb/Interpreter/OptionValueProperties.h"
 #include "lldb/Utility/ConstString.h" // for ConstString
 #include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/StringList.h" // for StringList
 
 #if defined(_WIN32)
static void SetPluginInfo(const FileSpec &plugin_file_spec,
   assert(plugin_map.find(plugin_file_spec) == plugin_map.end());
   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
+static FileSystem::EnumerateDirectoryResult
 LoadPluginCallback(void *baton, llvm::sys::fs::file_type ft,
-                   const FileSpec &file_spec) {
+                   llvm::StringRef path) {
   //    PluginManager *plugin_manager = (PluginManager *)baton;
   Status 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 (ft == fs::file_type::regular_file || ft == fs::file_type::symlink_file ||
       ft == fs::file_type::type_unknown) {
-    FileSpec plugin_file_spec(file_spec);
+    FileSpec plugin_file_spec(path, false);
     plugin_file_spec.ResolvePath();
 
     if (PluginIsLoaded(plugin_file_spec))
-      return FileSpec::eEnumerateDirectoryResultNext;
+      return FileSystem::eEnumerateDirectoryResultNext;
     else {
       PluginInfo plugin_info;
 
       std::string pluginLoadError;
       plugin_info.library = llvm::sys::DynamicLibrary::getPermanentLibrary(
           plugin_file_spec.GetPath().c_str(), &pluginLoadError);
       if (plugin_info.library.isValid()) {
         bool success = false;
else {
           // instance to invalidate it.
           plugin_info = PluginInfo();
         }
 
         // Regardless of success or failure, cache the plug-in load in our
         // plug-in info so we don't try to load it again and again.
         SetPluginInfo(plugin_file_spec, plugin_info);
 
-        return FileSpec::eEnumerateDirectoryResultNext;
+        return FileSystem::eEnumerateDirectoryResultNext;
       }
     }
   }
 
   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 FileSystem::eEnumerateDirectoryResultEnter;
   }
 
-  return FileSpec::eEnumerateDirectoryResultNext;
+  return FileSystem::eEnumerateDirectoryResultNext;
 }
 
 void PluginManager::Initialize() {
 #if 1
   const bool find_directories = true;
   const bool find_files = true;
   const bool find_other = true;
   char dir_path[PATH_MAX];
   if (FileSpec dir_spec = HostInfo::GetSystemPluginDir()) {
     if (dir_spec.Exists() && dir_spec.GetPath(dir_path, sizeof(dir_path))) {
-      FileSpec::EnumerateDirectory(dir_path, find_directories, find_files,
-                                   find_other, LoadPluginCallback, nullptr);
+      FileSystem::Instance().EnumerateDirectory(dir_path, find_directories,
+                                                find_files, find_other,
+                                                LoadPluginCallback, nullptr);
     }
   }
 
   if (FileSpec dir_spec = HostInfo::GetUserPluginDir()) {
     if (dir_spec.Exists() && dir_spec.GetPath(dir_path, sizeof(dir_path))) {
-      FileSpec::EnumerateDirectory(dir_path, find_directories, find_files,
-                                   find_other, LoadPluginCallback, nullptr);
+      FileSystem::Instance().EnumerateDirectory(dir_path, find_directories,
+                                                find_files, find_other,
+                                                LoadPluginCallback, nullptr);
     }
   }
 #endif
 }
 
 void PluginManager::Terminate() {
   std::lock_guard<std::recursive_mutex> guard(GetPluginMapMutex());
   PluginTerminateMap &plugin_map = GetPluginMap();

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

Status PlatformAppleTVSimulator::ResolveExecutable(
   } else {
     error.SetErrorStringWithFormat("'%s' does not exist",
                                    module_spec.GetFileSpec().GetPath().c_str());
   }
 
   return error;
 }
 
-static FileSpec::EnumerateDirectoryResult
+static FileSystem::EnumerateDirectoryResult
 EnumerateDirectoryCallback(void *baton, llvm::sys::fs::file_type ft,
-                           const FileSpec &file_spec) {
+                           llvm::StringRef path) {
   if (ft == llvm::sys::fs::file_type::directory_file) {
+    FileSpec file_spec(path, false);
     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;
+      return FileSystem::eEnumerateDirectoryResultQuit;
     }
   }
-  return FileSpec::eEnumerateDirectoryResultNext;
+  return FileSystem::eEnumerateDirectoryResultNext;
 }
 
 const char *PlatformAppleTVSimulator::GetSDKDirectoryAsCString() {
   std::lock_guard<std::mutex> guard(m_sdk_dir_mutex);
   if (m_sdk_directory.empty()) {
     const char *developer_dir = GetDeveloperDirectory();
     if (developer_dir) {
       char sdks_directory[PATH_MAX];
       char sdk_dirname[PATH_MAX];
       sdk_dirname[0] = '\0';
       snprintf(sdks_directory, sizeof(sdks_directory),
                "%s/Platforms/AppleTVSimulator.platform/Developer/SDKs",
                developer_dir);
       FileSpec simulator_sdk_spec;
       bool find_directories = true;
       bool find_files = false;
       bool find_other = false;
-      FileSpec::EnumerateDirectory(sdks_directory, find_directories, find_files,
-                                   find_other, EnumerateDirectoryCallback,
-                                   sdk_dirname);
+      FileSystem::Instance().EnumerateDirectory(
+          sdks_directory, find_directories, find_files, find_other,
+          EnumerateDirectoryCallback, sdk_dirname);
 
       if (sdk_dirname[0]) {
         m_sdk_directory = sdks_directory;
         m_sdk_directory.append(1, '/');
         m_sdk_directory.append(sdk_dirname);
         return m_sdk_directory.c_str();
       }
     }

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

Status PlatformAppleWatchSimulator::ResolveExecutable(
   } else {
     error.SetErrorStringWithFormat("'%s' does not exist",
                                    module_spec.GetFileSpec().GetPath().c_str());
   }
 
   return error;
 }
 
-static FileSpec::EnumerateDirectoryResult
+static FileSystem::EnumerateDirectoryResult
 EnumerateDirectoryCallback(void *baton, llvm::sys::fs::file_type ft,
-                           const FileSpec &file_spec) {
+                           llvm::StringRef path) {
   if (ft == llvm::sys::fs::file_type::directory_file) {
+    FileSpec file_spec(path, false);
     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;
+      return FileSystem::eEnumerateDirectoryResultQuit;
     }
   }
-  return FileSpec::eEnumerateDirectoryResultNext;
+  return FileSystem::eEnumerateDirectoryResultNext;
 }
 
 const char *PlatformAppleWatchSimulator::GetSDKDirectoryAsCString() {
   std::lock_guard<std::mutex> guard(m_sdk_dir_mutex);
   if (m_sdk_directory.empty()) {
     const char *developer_dir = GetDeveloperDirectory();
     if (developer_dir) {
       char sdks_directory[PATH_MAX];
       char sdk_dirname[PATH_MAX];
       sdk_dirname[0] = '\0';
       snprintf(sdks_directory, sizeof(sdks_directory),
                "%s/Platforms/AppleWatchSimulator.platform/Developer/SDKs",
                developer_dir);
       FileSpec simulator_sdk_spec;
       bool find_directories = true;
       bool find_files = false;
       bool find_other = false;
-      FileSpec::EnumerateDirectory(sdks_directory, find_directories, find_files,
-                                   find_other, EnumerateDirectoryCallback,
-                                   sdk_dirname);
+      FileSystem::Instance().EnumerateDirectory(
+          sdks_directory, find_directories, find_files, find_other,
+          EnumerateDirectoryCallback, sdk_dirname);
 
       if (sdk_dirname[0]) {
         m_sdk_directory = sdks_directory;
         m_sdk_directory.append(1, '/');
         m_sdk_directory.append(sdk_dirname);
         return m_sdk_directory.c_str();
       }
     }

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

 #define liblldb_PlatformDarwin_h_
 
 // C Includes
 // C++ Includes
 
 // Other libraries and framework includes
 // Project includes
 #include "Plugins/Platform/POSIX/PlatformPOSIX.h"
+#include "lldb/Host/FileSystem.h"
 #include "lldb/Utility/FileSpec.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/FileSystem.h"
 
 #include <string>
 #include <tuple>
 
 class PlatformDarwin : public PlatformPOSIX {
protected:
   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
+  static lldb_private::FileSystem::EnumerateDirectoryResult
   DirectoryEnumerator(void *baton, llvm::sys::fs::file_type file_type,
-                      const lldb_private::FileSpec &spec);
+                      llvm::StringRef path);
 
   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

if (last_path_component) {
     if (version.tryParse(version_part))
       return false;
     return SDKSupportsModules(desired_type, version);
   }
 
   return false;
 }
 
-FileSpec::EnumerateDirectoryResult PlatformDarwin::DirectoryEnumerator(
-    void *baton, llvm::sys::fs::file_type file_type, const FileSpec &spec) {
+FileSystem::EnumerateDirectoryResult PlatformDarwin::DirectoryEnumerator(
+    void *baton, llvm::sys::fs::file_type file_type, llvm::StringRef path) {
   SDKEnumeratorInfo *enumerator_info = static_cast<SDKEnumeratorInfo *>(baton);
 
+  FileSpec spec(path, false);
   if (SDKSupportsModules(enumerator_info->sdk_type, spec)) {
     enumerator_info->found_path = spec;
-    return FileSpec::EnumerateDirectoryResult::eEnumerateDirectoryResultNext;
+    return FileSystem::EnumerateDirectoryResult::eEnumerateDirectoryResultNext;
   }
 
-  return FileSpec::EnumerateDirectoryResult::eEnumerateDirectoryResultNext;
+  return FileSystem::EnumerateDirectoryResult::eEnumerateDirectoryResultNext;
 }
 
 FileSpec PlatformDarwin::FindSDKInXcodeForModules(SDKType sdk_type,
                                                   const FileSpec &sdks_spec) {
   // Look inside Xcode for the required installed iOS SDK version
 
   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);
+  FileSystem::Instance().EnumerateDirectory(
+      sdks_spec.GetPath(), find_directories, find_files, find_other,
+      DirectoryEnumerator, &enumerator_info);
 
   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) {

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

protected:
 
   void GetUserSpecifiedDirectoriesToSearch();
 
   static void AddRootSubdirsToSearchPaths(PlatformDarwinKernel *thisp,
                                           const std::string &dir);
 
   void AddSDKSubdirsToSearchPaths(const std::string &dir);
 
-  static lldb_private::FileSpec::EnumerateDirectoryResult
+  static lldb_private::FileSystem::EnumerateDirectoryResult
   FindKDKandSDKDirectoriesInDirectory(void *baton, llvm::sys::fs::file_type ft,
-                                      const lldb_private::FileSpec &file_spec);
+                                      llvm::StringRef path);
 
   void SearchForKextsAndKernelsRecursively();
 
-  static lldb_private::FileSpec::EnumerateDirectoryResult
-  GetKernelsAndKextsInDirectoryWithRecursion(
-      void *baton, llvm::sys::fs::file_type ft,
-      const lldb_private::FileSpec &file_spec);
-
-  static lldb_private::FileSpec::EnumerateDirectoryResult
-  GetKernelsAndKextsInDirectoryNoRecursion(
-      void *baton, llvm::sys::fs::file_type ft,
-      const lldb_private::FileSpec &file_spec);
+  static lldb_private::FileSystem::EnumerateDirectoryResult
+  GetKernelsAndKextsInDirectoryWithRecursion(void *baton,
+                                             llvm::sys::fs::file_type ft,
+                                             llvm::StringRef path);
+
+  static lldb_private::FileSystem::EnumerateDirectoryResult
+  GetKernelsAndKextsInDirectoryNoRecursion(void *baton,
+                                           llvm::sys::fs::file_type ft,
+                                           llvm::StringRef path);
 
-  static lldb_private::FileSpec::EnumerateDirectoryResult
+  static lldb_private::FileSystem::EnumerateDirectoryResult
   GetKernelsAndKextsInDirectoryHelper(void *baton, llvm::sys::fs::file_type ft,
-                                      const lldb_private::FileSpec &file_spec,
-                                      bool recurse);
+                                      llvm::StringRef path, bool recurse);
 
   static std::vector<lldb_private::FileSpec>
   SearchForExecutablesRecursively(const std::string &dir);
 
   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);
 
   // Returns true if there is a .dSYM bundle next to the kernel
   static bool
   KernelHasdSYMSibling(const lldb_private::FileSpec &kext_bundle_filepath);
 
   lldb_private::Status
   ExamineKextForMatchingUUID(const lldb_private::FileSpec &kext_bundle_path,
                              const lldb_private::UUID &uuid,
                              const lldb_private::ArchSpec &arch,
                              lldb::ModuleSP &exe_module_sp);
 
-  // Most of the ivars are assembled under FileSpec::EnumerateDirectory calls
+  // Most of the ivars are assembled under FileSystem::EnumerateDirectory calls
   // where the
   // function being called for each file/directory must be static.  We'll pass a
   // this pointer
   // as a baton and access the ivars directly.  Toss-up whether this should just
   // be a struct
   // at this point.
 
 public:

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

 }
 
 // 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);
+  FileSystem::Instance().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
+FileSystem::EnumerateDirectoryResult
 PlatformDarwinKernel::FindKDKandSDKDirectoriesInDirectory(
-    void *baton, llvm::sys::fs::file_type ft, const FileSpec &file_spec) {
+    void *baton, llvm::sys::fs::file_type ft, llvm::StringRef path) {
   static ConstString g_sdk_suffix = ConstString(".sdk");
   static ConstString g_kdk_suffix = ConstString(".kdk");
 
   PlatformDarwinKernel *thisp = (PlatformDarwinKernel *)baton;
+  FileSpec file_spec(path, false);
   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;
+  return FileSystem::eEnumerateDirectoryResultNext;
 }
 
 // Recursively search trough m_search_directories looking for kext and kernel
 // binaries, adding files found to the appropriate lists.
 void PlatformDarwinKernel::SearchForKextsAndKernelsRecursively() {
   const uint32_t num_dirs = m_search_directories.size();
   for (uint32_t i = 0; i < num_dirs; i++) {
     const FileSpec &dir = m_search_directories[i];
     const bool find_directories = true;
     const bool find_files = true;
     const bool find_other = true; // I think eFileTypeSymbolicLink are "other"s.
-    FileSpec::EnumerateDirectory(
+    FileSystem::Instance().EnumerateDirectory(
         dir.GetPath().c_str(), find_directories, find_files, find_other,
         GetKernelsAndKextsInDirectoryWithRecursion, this);
   }
   const uint32_t num_dirs_no_recurse = m_search_directories_no_recursing.size();
   for (uint32_t i = 0; i < num_dirs_no_recurse; i++) {
     const FileSpec &dir = m_search_directories_no_recursing[i];
     const bool find_directories = true;
     const bool find_files = true;
     const bool find_other = true; // I think eFileTypeSymbolicLink are "other"s.
-    FileSpec::EnumerateDirectory(
+    FileSystem::Instance().EnumerateDirectory(
         dir.GetPath().c_str(), find_directories, find_files, find_other,
         GetKernelsAndKextsInDirectoryNoRecursion, this);
   }
 }
 
 // We're only doing a filename match here.  We won't try opening the file to
 // see if it's really a kernel or not until we need to find a kernel of a given
 // UUID.  There's no cheap way to find 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
+FileSystem::EnumerateDirectoryResult
 PlatformDarwinKernel::GetKernelsAndKextsInDirectoryWithRecursion(
-    void *baton, llvm::sys::fs::file_type ft, const FileSpec &file_spec) {
-  return GetKernelsAndKextsInDirectoryHelper(baton, ft, file_spec, true);
+    void *baton, llvm::sys::fs::file_type ft, llvm::StringRef path) {
+  return GetKernelsAndKextsInDirectoryHelper(baton, ft, path, true);
 }
 
-FileSpec::EnumerateDirectoryResult
+FileSystem::EnumerateDirectoryResult
 PlatformDarwinKernel::GetKernelsAndKextsInDirectoryNoRecursion(
-    void *baton, llvm::sys::fs::file_type ft, const FileSpec &file_spec) {
-  return GetKernelsAndKextsInDirectoryHelper(baton, ft, file_spec, false);
+    void *baton, llvm::sys::fs::file_type ft, llvm::StringRef path) {
+  return GetKernelsAndKextsInDirectoryHelper(baton, ft, path, false);
 }
 
-FileSpec::EnumerateDirectoryResult
+FileSystem::EnumerateDirectoryResult
 PlatformDarwinKernel::GetKernelsAndKextsInDirectoryHelper(
-    void *baton, llvm::sys::fs::file_type ft, const FileSpec &file_spec,
+    void *baton, llvm::sys::fs::file_type ft, llvm::StringRef path,
     bool recurse) {
   static ConstString g_kext_suffix = ConstString(".kext");
   static ConstString g_dsym_suffix = ConstString(".dSYM");
   static ConstString g_bundle_suffix = ConstString("Bundle");
+
+  FileSpec file_spec(path, false);
   ConstString file_spec_extension = file_spec.GetFileNameExtension();
 
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_PLATFORM));
   Log *log_verbose(GetLogIfAllCategoriesSet(LIBLLDB_LOG_PLATFORM | LLDB_LOG_OPTION_VERBOSE));
 
   if (log_verbose)
       log_verbose->Printf ("PlatformDarwinKernel examining '%s'", file_spec.GetPath().c_str());
 
if ((strncmp(filename.GetCString(), "kernel", 6) == 0 ||
       else
       {
         if (log)
         {
             log->Printf ("PlatformDarwinKernel registering kernel binary '%s', no dSYM", file_spec.GetPath().c_str());
         }
         thisp->m_kernel_binaries_without_dsyms.push_back(file_spec);
       }
-      return FileSpec::eEnumerateDirectoryResultNext;
+      return FileSystem::eEnumerateDirectoryResultNext;
     }
   } 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 (llvm::sys::fs::is_directory(contents_plugins.GetPath())) {
       search_here_too = contents_plugins.GetPath();
     } else {
       FileSpec plugins(file_spec.GetPath() + "/PlugIns", false);
       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;
-      FileSpec::EnumerateDirectory(
+      FileSystem::Instance().EnumerateDirectory(
           search_here_too.c_str(), find_directories, find_files, find_other,
           recurse ? GetKernelsAndKextsInDirectoryWithRecursion
                   : GetKernelsAndKextsInDirectoryNoRecursion,
           baton);
     }
-    return FileSpec::eEnumerateDirectoryResultNext;
+    return FileSystem::eEnumerateDirectoryResultNext;
   }
   // Don't recurse into dSYM/kext/bundle directories
   if (recurse && file_spec_extension != g_dsym_suffix &&
       file_spec_extension != g_kext_suffix &&
       file_spec_extension != g_bundle_suffix) {
     if (log_verbose)
         log_verbose->Printf ("PlatformDarwinKernel descending into directory '%s'", file_spec.GetPath().c_str());
-    return FileSpec::eEnumerateDirectoryResultEnter;
+    return FileSystem::eEnumerateDirectoryResultEnter;
   } else {
-    return FileSpec::eEnumerateDirectoryResultNext;
+    return FileSystem::eEnumerateDirectoryResultNext;
   }
 }
 
 void PlatformDarwinKernel::AddKextToMap(PlatformDarwinKernel *thisp,
                                         const FileSpec &file_spec) {
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_PLATFORM));
   CFCBundle bundle(file_spec.GetPath().c_str());
   CFStringRef bundle_id(bundle.GetIdentifier());

lldb/trunk/source/Plugins/Platform/MacOSX/PlatformRemoteDarwinDevice.h

protected:
   const char *GetDeviceSupportDirectory();
 
   const char *GetDeviceSupportDirectoryForOSVersion();
 
   const SDKDirectoryInfo *GetSDKDirectoryForLatestOSVersion();
 
   const SDKDirectoryInfo *GetSDKDirectoryForCurrentOSVersion();
 
-  static lldb_private::FileSpec::EnumerateDirectoryResult
-  GetContainedFilesIntoVectorOfStringsCallback(
-      void *baton, llvm::sys::fs::file_type ft,
-      const lldb_private::FileSpec &file_spec);
+  static lldb_private::FileSystem::EnumerateDirectoryResult
+  GetContainedFilesIntoVectorOfStringsCallback(void *baton,
+                                               llvm::sys::fs::file_type ft,
+                                               llvm::StringRef path);
 
   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);
 
   uint32_t FindFileInAllSDKs(const lldb_private::FileSpec &platform_file,

lldb/trunk/source/Plugins/Platform/MacOSX/PlatformRemoteDarwinDevice.cpp

if (resolved_module_spec.GetFileSpec().Exists()) {
     error.SetErrorStringWithFormat(
         "'%s' does not exist",
         resolved_module_spec.GetFileSpec().GetPath().c_str());
   }
 
   return error;
 }
 
-FileSpec::EnumerateDirectoryResult
+FileSystem::EnumerateDirectoryResult
 PlatformRemoteDarwinDevice::GetContainedFilesIntoVectorOfStringsCallback(
-    void *baton, llvm::sys::fs::file_type ft, const FileSpec &file_spec) {
+    void *baton, llvm::sys::fs::file_type ft, llvm::StringRef path) {
   ((PlatformRemoteDarwinDevice::SDKDirectoryInfoCollection *)baton)
-      ->push_back(PlatformRemoteDarwinDevice::SDKDirectoryInfo(file_spec));
-  return FileSpec::eEnumerateDirectoryResultNext;
+      ->push_back(
+          PlatformRemoteDarwinDevice::SDKDirectoryInfo(FileSpec(path, false)));
+  return FileSystem::eEnumerateDirectoryResultNext;
 }
 
 bool PlatformRemoteDarwinDevice::UpdateSDKDirectoryInfosIfNeeded() {
   Log *log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_HOST);
   std::lock_guard<std::mutex> guard(m_sdk_dir_mutex);
   if (m_sdk_directory_infos.empty()) {
     // A --sysroot option was supplied - add it to our list of SDKs to check
     if (m_sdk_sysroot) {
if (log) {
                   device_support_dir);
     }
     if (device_support_dir) {
       const bool find_directories = true;
       const bool find_files = false;
       const bool find_other = false;
 
       SDKDirectoryInfoCollection builtin_sdk_directory_infos;
-      FileSpec::EnumerateDirectory(m_device_support_directory, find_directories,
-                                   find_files, find_other,
-                                   GetContainedFilesIntoVectorOfStringsCallback,
-                                   &builtin_sdk_directory_infos);
+      FileSystem::Instance().EnumerateDirectory(
+          m_device_support_directory, find_directories, find_files, find_other,
 
       // Only add SDK directories that have symbols in them, some SDKs only
       // contain developer disk images and no symbols, so they aren't useful to
       // us.
       FileSpec sdk_symbols_symlink_fspec;
       for (const auto &sdk_directory_info : builtin_sdk_directory_infos) {
         sdk_symbols_symlink_fspec = sdk_directory_info.directory;
         sdk_symbols_symlink_fspec.AppendPathComponent("Symbols");
if (device_support_dir) {
         if (local_sdk_cache.Exists()) {
             if (log) {
             log->Printf("PlatformRemoteDarwinDevice::UpdateSDKDirectoryInfosIfNeeded "
                         "searching %s for additional SDKs",
                         local_sdk_cache.GetPath().c_str());
             }
             char path[PATH_MAX];
             if (local_sdk_cache.GetPath(path, sizeof(path))) {
-            FileSpec::EnumerateDirectory(
+              FileSystem::Instance().EnumerateDirectory(
                   path, find_directories, find_files, find_other,
                   GetContainedFilesIntoVectorOfStringsCallback,
                   &m_sdk_directory_infos);
               const uint32_t num_sdk_infos = m_sdk_directory_infos.size();
               // First try for an exact match of major, minor and update
               for (uint32_t i = num_installed; i < num_sdk_infos; ++i) {
                 m_sdk_directory_infos[i].user_cached = true;
                 if (log) {
                 log->Printf("PlatformRemoteDarwinDevice::UpdateSDKDirectoryInfosIfNeeded "
                             "user SDK directory %s",
                             m_sdk_directory_infos[i].directory.GetPath().c_str());
                 }
             }
           }
         }
       }
 
       const char *addtional_platform_dirs = getenv("PLATFORM_SDK_DIRECTORY");
       if (addtional_platform_dirs) {
         SDKDirectoryInfoCollection env_var_sdk_directory_infos;
-        FileSpec::EnumerateDirectory(addtional_platform_dirs, find_directories,
-                                     find_files, find_other,
-                                     GetContainedFilesIntoVectorOfStringsCallback,
-                                     &env_var_sdk_directory_infos);
+        FileSystem::Instance().EnumerateDirectory(
+            addtional_platform_dirs, find_directories, find_files, find_other,
         FileSpec sdk_symbols_symlink_fspec;
         for (const auto &sdk_directory_info : env_var_sdk_directory_infos) {
           sdk_symbols_symlink_fspec = sdk_directory_info.directory;
           sdk_symbols_symlink_fspec.AppendPathComponent("Symbols");
           if (sdk_symbols_symlink_fspec.Exists()) {
             m_sdk_directory_infos.push_back(sdk_directory_info);
             if (log) {
               log->Printf("PlatformRemoteDarwinDevice::UpdateSDKDirectoryInfosIfNeeded "

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

Status PlatformiOSSimulator::ResolveExecutable(
   } else {
     error.SetErrorStringWithFormat("'%s' does not exist",
                                    module_spec.GetFileSpec().GetPath().c_str());
   }
 
   return error;
 }
 
-static FileSpec::EnumerateDirectoryResult
+static FileSystem::EnumerateDirectoryResult
 EnumerateDirectoryCallback(void *baton, llvm::sys::fs::file_type ft,
-                           const FileSpec &file_spec) {
+                           llvm::StringRef path) {
   if (ft == llvm::sys::fs::file_type::directory_file) {
+    FileSpec file_spec(path, false);
     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 FileSystem::eEnumerateDirectoryResultQuit;
     }
   }
-  return FileSpec::eEnumerateDirectoryResultNext;
+  return FileSystem::eEnumerateDirectoryResultNext;
 }
 
 const char *PlatformiOSSimulator::GetSDKDirectoryAsCString() {
   std::lock_guard<std::mutex> guard(m_sdk_dir_mutex);
   if (m_sdk_directory.empty()) {
     const char *developer_dir = GetDeveloperDirectory();
     if (developer_dir) {
       char sdks_directory[PATH_MAX];
       char sdk_dirname[PATH_MAX];
       sdk_dirname[0] = '\0';
       snprintf(sdks_directory, sizeof(sdks_directory),
                "%s/Platforms/iPhoneSimulator.platform/Developer/SDKs",
                developer_dir);
       FileSpec simulator_sdk_spec;
       bool find_directories = true;
       bool find_files = false;
       bool find_other = false;
-      FileSpec::EnumerateDirectory(sdks_directory, find_directories, find_files,
-                                   find_other, EnumerateDirectoryCallback,
-                                   sdk_dirname);
+      FileSystem::Instance().EnumerateDirectory(
+          sdks_directory, find_directories, find_files, find_other,
+          EnumerateDirectoryCallback, sdk_dirname);
 
       if (sdk_dirname[0]) {
         m_sdk_directory = sdks_directory;
         m_sdk_directory.append(1, '/');
         m_sdk_directory.append(sdk_dirname);
         return m_sdk_directory.c_str();
       }
     }

lldb/trunk/source/Target/Platform.cpp

 }
 
 struct RecurseCopyBaton {
   const FileSpec &dst;
   Platform *platform_ptr;
   Status error;
 };
 
-static FileSpec::EnumerateDirectoryResult
+static FileSystem::EnumerateDirectoryResult
 RecurseCopy_Callback(void *baton, llvm::sys::fs::file_type ft,
-                     const FileSpec &src) {
+                     llvm::StringRef path) {
   RecurseCopyBaton *rc_baton = (RecurseCopyBaton *)baton;
+  FileSpec src(path, false);
   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;
+    return FileSystem::eEnumerateDirectoryResultNext;
     break;
 
   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();
     Status error = rc_baton->platform_ptr->MakeDirectory(
         dst_dir, lldb::eFilePermissionsDirectoryDefault);
     if (error.Fail()) {
       rc_baton->error.SetErrorStringWithFormat(
           "unable to setup directory %s on remote end", dst_dir.GetCString());
-      return FileSpec::eEnumerateDirectoryResultQuit; // got an error, bail out
+      return FileSystem::eEnumerateDirectoryResultQuit; // got an error, bail out
     }
 
     // now recurse
     std::string src_dir_path(src.GetPath());
 
     // 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(dst_dir.GetPath().c_str());
     RecurseCopyBaton rc_baton2 = {recurse_dst, rc_baton->platform_ptr,
                                   Status()};
-    FileSpec::EnumerateDirectory(src_dir_path, true, true, true,
+    FileSystem::Instance().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 FileSystem::eEnumerateDirectoryResultQuit; // got an error, bail out
     }
-    return FileSpec::eEnumerateDirectoryResultNext;
+    return FileSystem::eEnumerateDirectoryResultNext;
   } break;
 
   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::Instance().Readlink(src, src_resolved);
 
     if (rc_baton->error.Fail())
-      return FileSpec::eEnumerateDirectoryResultQuit; // got an error, bail out
+      return FileSystem::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 FileSystem::eEnumerateDirectoryResultQuit; // got an error, bail out
 
-    return FileSpec::eEnumerateDirectoryResultNext;
+    return FileSystem::eEnumerateDirectoryResultNext;
   } break;
 
   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();
     Status 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 FileSystem::eEnumerateDirectoryResultQuit; // got an error, bail out
     }
-    return FileSpec::eEnumerateDirectoryResultNext;
+    return FileSystem::eEnumerateDirectoryResultNext;
   } break;
 
   default:
     rc_baton->error.SetErrorStringWithFormat(
         "invalid file detected during copy: %s", src.GetPath().c_str());
-    return FileSpec::eEnumerateDirectoryResultQuit; // got an error, bail out
+    return FileSystem::eEnumerateDirectoryResultQuit; // got an error, bail out
     break;
   }
   llvm_unreachable("Unhandled file_type!");
 }
 
 Status Platform::Install(const FileSpec &src, const FileSpec &dst) {
   Status error;
 
case fs::file_type::directory_file: {
       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, Status()};
-        FileSpec::EnumerateDirectory(src_dir_path, true, true, true,
-                                     RecurseCopy_Callback, &baton);
+        FileSystem::Instance().EnumerateDirectory(
+            src_dir_path, true, true, true, RecurseCopy_Callback, &baton);
         return baton.error;
       }
     } break;
 
     case fs::file_type::regular_file:
       llvm::sys::fs::remove(fixed_dst.GetPath());
       error = PutFile(src, fixed_dst);
       break;

lldb/trunk/source/Utility/FileSpec.cpp

 //------------------------------------------------------------------
 // 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.
 //------------------------------------------------------------------
 size_t FileSpec::MemorySize() const {
   return m_filename.MemorySize() + m_directory.MemorySize();
 }
 
-void FileSpec::EnumerateDirectory(llvm::StringRef dir_path,
-                                  bool find_directories, bool find_files,
-                                  bool find_other,
-                                  EnumerateDirectoryCallbackType callback,
-                                  void *callback_baton) {
-  namespace fs = llvm::sys::fs;
-  std::error_code EC;
-  fs::recursive_directory_iterator Iter(dir_path, EC);
-  fs::recursive_directory_iterator End;
-  for (; Iter != End && !EC; Iter.increment(EC)) {
-    const auto &Item = *Iter;
-    llvm::ErrorOr<fs::basic_file_status> Status = Item.status();
-    if (!Status)
-      break;
-    if (!find_files && fs::is_regular_file(*Status))
-      continue;
-    if (!find_directories && fs::is_directory(*Status))
-      continue;
-    if (!find_other && fs::is_other(*Status))
-      continue;
-
-    FileSpec Spec(Item.path(), false);
-    auto Result = callback(callback_baton, Status->type(), Spec);
-    if (Result == eEnumerateDirectoryResultQuit)
-      return;
-    if (Result == eEnumerateDirectoryResultNext) {
-      // Default behavior is to recurse.  Opt out if the callback doesn't want
-      // this behavior.
-      Iter.no_push();
-    }
-  }
-}
-
 FileSpec
 FileSpec::CopyByAppendingPathComponent(llvm::StringRef component) const {
   FileSpec ret = *this;
   ret.AppendPathComponent(component);
   return ret;
 }
 
 FileSpec FileSpec::CopyByRemovingLastPathComponent() const {