[FileSystem] Remove Exists() from FileSpec

[JDevlieghere]

Summary

This patch removes the Exists method from FileSpec and updates its uses with calls to the FileSystem.

include/lldb/Utility/FileSpec.h

public:
   /// delimiter, and the filename.
   ///
   /// @param[in] s
   ///     The stream to which to dump the object description.
   //------------------------------------------------------------------
   void Dump(Stream *s) const;
 
   //------------------------------------------------------------------
-  /// Existence test.
-  ///
-  /// @return
-  ///     \b true if the file exists on disk, \b false otherwise.
-  //------------------------------------------------------------------
-  bool Exists() const;
-
-  //------------------------------------------------------------------
   /// Canonicalize this file path (basically running the static
   /// FileSpec::Resolve method on it). Useful if you asked us not to resolve
   /// the file path when you set the file.
   //------------------------------------------------------------------
   bool ResolvePath();
 
   Style GetPathStyle() const;
 

source/API/SBDebugger.cpp

if (init_func) {
         error.SetErrorString("plug-in refused to load "
                              "(lldb::PluginInitialize(lldb::SBDebugger) "
                              "returned false)");
     } else {
       error.SetErrorString("plug-in is missing the required initialization: "
                            "lldb::PluginInitialize(lldb::SBDebugger)");
     }
   } else {
-    if (spec.Exists())
+    if (FileSystem::Instance().Exists(spec))
       error.SetErrorString("this file does not represent a loadable dylib");
     else
       error.SetErrorString("no such file");
   }
   return llvm::sys::DynamicLibrary();
 }
 
 static llvm::ManagedStatic<SystemLifetimeManager> g_debugger_lifetime;

source/API/SBFileSpec.cpp

const SBFileSpec &SBFileSpec::operator=(const SBFileSpec &rhs) {
   return *this;
 }
 
 bool SBFileSpec::IsValid() const { return m_opaque_ap->operator bool(); }
 
 bool SBFileSpec::Exists() const {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
-  bool result = m_opaque_ap->Exists();
+  bool result = FileSystem::Instance().Exists(*m_opaque_ap);
 
   if (log)
     log->Printf("SBFileSpec(%p)::Exists () => %s",
                 static_cast<void *>(m_opaque_ap.get()),
                 (result ? "true" : "false"));
 
   return result;
 }

source/Commands/CommandObjectMemory.cpp

Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
                           ExecutionContext *execution_context) override {
       Status error;
       const int short_option =
           g_memory_write_option_table[option_idx].short_option;
 
       switch (short_option) {
       case 'i':
         m_infile.SetFile(option_value, true, FileSpec::Style::native);
-        if (!m_infile.Exists()) {
+        if (!FileSystem::Instance().Exists(m_infile)) {
           m_infile.Clear();
           error.SetErrorStringWithFormat("input file does not exist: '%s'",
                                          option_value.str().c_str());
         }
         break;
 
       case 'o': {
         if (option_value.getAsInteger(0, m_infile_offset)) {

source/Commands/CommandObjectPlatform.cpp

bool DoExecute(Args &args, CommandReturnObject &result) override {
     if (args.GetArgumentCount() != 2) {
       result.AppendError("platform target-install takes two arguments");
       result.SetStatus(eReturnStatusFailed);
       return false;
     }
     // TODO: move the bulk of this code over to the platform itself
     FileSpec src(args.GetArgumentAtIndex(0), true);
     FileSpec dst(args.GetArgumentAtIndex(1), false);
-    if (!src.Exists()) {
+    if (!FileSystem::Instance().Exists(src)) {
       result.AppendError("source location does not exist or is not accessible");
       result.SetStatus(eReturnStatusFailed);
       return false;
     }
     PlatformSP platform_sp(
         m_interpreter.GetDebugger().GetPlatformList().GetSelectedPlatform());
     if (!platform_sp) {
       result.AppendError("no platform currently selected");

source/Commands/CommandObjectTarget.cpp

 
 protected:
   bool DoExecute(Args &command, CommandReturnObject &result) override {
     const size_t argc = command.GetArgumentCount();
     FileSpec core_file(m_core_file.GetOptionValue().GetCurrentValue());
     FileSpec remote_file(m_remote_file.GetOptionValue().GetCurrentValue());
 
     if (core_file) {
-      if (!core_file.Exists()) {
+      if (!FileSystem::Instance().Exists(core_file)) {
         result.AppendErrorWithFormat("core file '%s' doesn't exist",
                                      core_file.GetPath().c_str());
         result.SetStatus(eReturnStatusFailed);
         return false;
       }
       if (!FileSystem::Instance().Readable(core_file)) {
         result.AppendErrorWithFormat("core file '%s' is not readable",
                                      core_file.GetPath().c_str());
         result.SetStatus(eReturnStatusFailed);
         return false;
       }
     }
 
     if (argc == 1 || core_file || remote_file) {
       FileSpec symfile(m_symbol_file.GetOptionValue().GetCurrentValue());
       if (symfile) {
-        if (symfile.Exists()) {
+        if (FileSystem::Instance().Exists(symfile)) {
           if (!FileSystem::Instance().Readable(symfile)) {
             result.AppendErrorWithFormat("symbol file '%s' is not readable",
                                          symfile.GetPath().c_str());
             result.SetStatus(eReturnStatusFailed);
             return false;
           }
         } else {
           char symfile_path[PATH_MAX];
if (argc == 1 || core_file || remote_file) {
         // have switched platforms depending on what the arguments were to
         // CreateTarget() we can't rely on the selected platform.
 
         PlatformSP platform_sp = target_sp->GetPlatform();
 
         if (remote_file) {
           if (platform_sp) {
             // I have a remote file.. two possible cases
-            if (file_spec && file_spec.Exists()) {
+            if (file_spec && FileSystem::Instance().Exists(file_spec)) {
               // if the remote file does not exist, push it there
               if (!platform_sp->GetFileExists(remote_file)) {
                 Status err = platform_sp->PutFile(file_spec, remote_file);
                 if (err.Fail()) {
                   result.AppendError(err.AsCString());
                   result.SetStatus(eReturnStatusFailed);
                   return false;
                 }
if (argc == 1 || core_file || remote_file) {
           ModuleSpec main_module_spec(file_spec);
           ModuleSP module_sp = target_sp->GetSharedModule(main_module_spec);
           if (module_sp)
             module_sp->SetPlatformFileSpec(remote_file);
         }
         if (core_file) {
           char core_path[PATH_MAX];
           core_file.GetPath(core_path, sizeof(core_path));
-          if (core_file.Exists()) {
+          if (FileSystem::Instance().Exists(core_file)) {
             if (!FileSystem::Instance().Readable(core_file)) {
               result.AppendMessageWithFormat(
                   "Core file '%s' is not readable.\n", core_path);
               result.SetStatus(eReturnStatusFailed);
               return false;
             }
             FileSpec core_file_dir;
             core_file_dir.GetDirectory() = core_file.GetDirectory();
if (target == nullptr) {
           return false;
         }
       } else {
         for (auto &entry : args.entries()) {
           if (entry.ref.empty())
             continue;
 
           FileSpec file_spec(entry.ref, true);
-          if (file_spec.Exists()) {
+          if (FileSystem::Instance().Exists(file_spec)) {
             ModuleSpec module_spec(file_spec);
             if (m_uuid_option_group.GetOptionValue().OptionWasSet())
               module_spec.GetUUID() =
                   m_uuid_option_group.GetOptionValue().GetCurrentValue();
             if (m_symbol_file.GetOptionValue().OptionWasSet())
               module_spec.GetSymbolFileSpec() =
                   m_symbol_file.GetOptionValue().GetCurrentValue();
             if (!module_spec.GetArchitecture().IsValid())
if (argc == 0) {
           if (process) {
             const StateType process_state = process->GetState();
             if (StateIsStoppedState(process_state, true)) {
               StackFrame *frame = m_exe_ctx.GetFramePtr();
               if (frame) {
                 ModuleSP frame_module_sp(
                     frame->GetSymbolContext(eSymbolContextModule).module_sp);
                 if (frame_module_sp) {
-                  if (frame_module_sp->GetPlatformFileSpec().Exists()) {
+                  if (FileSystem::Instance().Exists(
+                          frame_module_sp->GetPlatformFileSpec())) {
                     module_spec.GetArchitecture() =
                         frame_module_sp->GetArchitecture();
                     module_spec.GetFileSpec() =
                         frame_module_sp->GetPlatformFileSpec();
                   }
                   module_spec.GetUUID() = frame_module_sp->GetUUID();
                   success = module_spec.GetUUID().IsValid() ||
                             module_spec.GetFileSpec();
if (argc == 0) {
               module_spec.GetPlatformFileSpec() =
                   module_sp->GetPlatformFileSpec();
               module_spec.GetUUID() = module_sp->GetUUID();
               module_spec.GetArchitecture() = module_sp->GetArchitecture();
             } else {
               module_spec.GetArchitecture() = target->GetArchitecture();
             }
             success |= module_spec.GetUUID().IsValid() ||
-                       module_spec.GetFileSpec().Exists();
+                       FileSystem::Instance().Exists(module_spec.GetFileSpec());
           }
         }
 
         if (success) {
           if (Symbols::DownloadObjectAndSymbolFile(module_spec)) {
             if (module_spec.GetSymbolFileSpec())
               success = AddModuleSymbols(target, module_spec, flush, result);
           }
if (argc == 0) {
               FileSpec symfile_spec;
               if (platform_sp
                       ->ResolveSymbolFile(*target, module_spec, symfile_spec)
                       .Success())
                 module_spec.GetSymbolFileSpec() = symfile_spec;
             }
 
             ArchSpec arch;
-            bool symfile_exists = module_spec.GetSymbolFileSpec().Exists();
+            bool symfile_exists =
+                FileSystem::Instance().Exists(module_spec.GetSymbolFileSpec());
 
             if (symfile_exists) {
               if (!AddModuleSymbols(target, module_spec, flush, result))
                 break;
             } else {
               std::string resolved_symfile_path =
                   module_spec.GetSymbolFileSpec().GetPath();
               if (resolved_symfile_path != entry.ref) {

source/Core/Debugger.cpp

 }
 
 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))) {
+    if (FileSystem::Instance().Exists(dir_spec) &&
+        dir_spec.GetPath(dir_path, sizeof(dir_path))) {
       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))) {
+    if (FileSystem::Instance().Exists(dir_spec) &&
+        dir_spec.GetPath(dir_path, sizeof(dir_path))) {
       FileSystem::Instance().EnumerateDirectory(dir_path, find_directories,
                                                 find_files, find_other,
                                                 LoadPluginCallback, this);
     }
   }
 
   PluginManager::DebuggerInitialize(*this);
 }

source/Core/DynamicLoader.cpp

void DynamicLoader::SetStopWhenImagesChange(bool stop) {
   m_process->SetStopOnSharedLibraryEvents(stop);
 }
 
 ModuleSP DynamicLoader::GetTargetExecutable() {
   Target &target = m_process->GetTarget();
   ModuleSP executable = target.GetExecutableModule();
 
   if (executable) {
-    if (executable->GetFileSpec().Exists()) {
+    if (FileSystem::Instance().Exists(executable->GetFileSpec())) {
       ModuleSpec module_spec(executable->GetFileSpec(),
                              executable->GetArchitecture());
       auto module_sp = std::make_shared<Module>(module_spec);
 
       // Check if the executable has changed and set it to the target
       // executable if they differ.
       if (module_sp && module_sp->GetUUID().IsValid() &&
           executable->GetUUID().IsValid()) {

source/Core/Module.cpp

void Module::PreloadSymbols() {
   }
   // Now we can prime the symbol table.
   if (Symtab * symtab = sym_vendor->GetSymtab()) {
     symtab->PreloadSymbols();
   }
 }
 
 void Module::SetSymbolFileFileSpec(const FileSpec &file) {
-  if (!file.Exists())
+  if (!FileSystem::Instance().Exists(file))
     return;
   if (m_symfile_ap) {
     // Remove any sections in the unified section list that come from the
     // current symbol vendor.
     SectionList *section_list = GetSectionList();
     SymbolFile *symbol_file = m_symfile_ap->GetSymbolFile();
     if (section_list && symbol_file) {
       ObjectFile *obj_file = symbol_file->GetObjectFile();
if (script_language != eScriptLanguageNone) {
 
     const uint32_t num_specs = file_specs.GetSize();
     if (num_specs) {
       ScriptInterpreter *script_interpreter =
           debugger.GetCommandInterpreter().GetScriptInterpreter();
       if (script_interpreter) {
         for (uint32_t i = 0; i < num_specs; ++i) {
           FileSpec scripting_fspec(file_specs.GetFileSpecAtIndex(i));
-          if (scripting_fspec && scripting_fspec.Exists()) {
+          if (scripting_fspec &&
+              FileSystem::Instance().Exists(scripting_fspec)) {
             if (should_load == eLoadScriptFromSymFileWarn) {
               if (feedback_stream)
                 feedback_stream->Printf(
                     "warning: '%s' contains a debug script. To run this script "
                     "in "
                     "this debug session:\n\n    command script import "
                     "\"%s\"\n\n"
                     "To run all discovered debug scripts in this session:\n\n"

source/Core/ModuleList.cpp

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;
       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())
+      if (!FileSystem::Instance().Exists(search_path_spec))
         continue;
 
       auto resolved_module_spec(module_spec);
       resolved_module_spec.GetFileSpec() = search_path_spec;
       module_sp.reset(new Module(resolved_module_spec));
       if (module_sp->GetObjectFile()) {
         // If we get in here we got the correct arch, now we just need to
         // verify the UUID if one was given
Status ModuleList::GetSharedModule(const ModuleSpec &module_spec,
   // Fixup the incoming path in case the path points to a valid file, yet the
   // arch or UUID (if one was passed in) don't match.
   ModuleSpec located_binary_modulespec =
       Symbols::LocateExecutableObjectFile(module_spec);
 
   // Don't look for the file if it appears to be the same one we already
   // checked for above...
   if (located_binary_modulespec.GetFileSpec() != module_file_spec) {
-    if (!located_binary_modulespec.GetFileSpec().Exists()) {
+    if (!FileSystem::Instance().Exists(
+            located_binary_modulespec.GetFileSpec())) {
       located_binary_modulespec.GetFileSpec().GetPath(path, sizeof(path));
       if (path[0] == '\0')
         module_file_spec.GetPath(path, sizeof(path));
       // How can this check ever be true? This branch it is false, and we
       // haven't modified file_spec.
-      if (located_binary_modulespec.GetFileSpec().Exists()) {
+      if (FileSystem::Instance().Exists(
+              located_binary_modulespec.GetFileSpec())) {
         std::string uuid_str;
         if (uuid_ptr && uuid_ptr->IsValid())
           uuid_str = uuid_ptr->GetAsString();
 
         if (arch.IsValid()) {
           if (!uuid_str.empty())
             error.SetErrorStringWithFormat(
                 "'%s' does not contain the %s architecture and UUID %s", path,

source/Core/PluginManager.cpp

 
 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))) {
+    if (FileSystem::Instance().Exists(dir_spec) &&
+        dir_spec.GetPath(dir_path, sizeof(dir_path))) {
       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))) {
+    if (FileSystem::Instance().Exists(dir_spec) &&
+        dir_spec.GetPath(dir_path, sizeof(dir_path))) {
       FileSystem::Instance().EnumerateDirectory(dir_path, find_directories,
                                                 find_files, find_other,
                                                 LoadPluginCallback, nullptr);
     }
   }
 #endif
 }
 

source/Core/SourceManager.cpp

if (target_sp && file_sp &&
           target_sp->GetSourcePathMap().GetModificationID())
     file_sp.reset();
 
   // Update the file contents if needed if we found a file
   if (file_sp)
     file_sp->UpdateIfNeeded();
 
   // If file_sp is no good or it points to a non-existent file, reset it.
-  if (!file_sp || !file_sp->GetFileSpec().Exists()) {
+  if (!file_sp || !FileSystem::Instance().Exists(file_sp->GetFileSpec())) {
     if (target_sp)
       file_sp = std::make_shared<File>(file_spec, target_sp.get());
     else
       file_sp = std::make_shared<File>(file_spec, debugger_sp);
 
     if (debugger_sp)
       debugger_sp->GetSourceFileCache().AddSourceFile(file_sp);
   }
if (target) {
             SymbolContext sc;
             sc_list.GetContextAtIndex(0, sc);
             m_file_spec = sc.comp_unit;
             m_mod_time = FileSystem::Instance().GetModificationTime(m_file_spec);
           }
         }
       }
       // Try remapping if m_file_spec does not correspond to an existing file.
-      if (!m_file_spec.Exists()) {
+      if (!FileSystem::Instance().Exists(m_file_spec)) {
         FileSpec new_file_spec;
         // Check target specific source remappings first, then fall back to
         // modules objects can have individual path remappings that were
         // detected when the debug info for a module was found. then
         if (target->GetSourcePathMap().FindFile(m_file_spec, new_file_spec) ||
             target->GetImages().FindSourceFile(m_file_spec, new_file_spec)) {
           m_file_spec = new_file_spec;
           m_mod_time = FileSystem::Instance().GetModificationTime(m_file_spec);

source/Host/common/HostInfoBase.cpp

 // variables correctly in a thread safe way. Really each of the variables in
 // HostInfoBaseFields should live in the functions in which they are used and
 // each one should be static, but the work around is in place to avoid this
 // restriction. Ick.
 //----------------------------------------------------------------------
 
 struct HostInfoBaseFields {
   ~HostInfoBaseFields() {
-    if (m_lldb_process_tmp_dir.Exists()) {
+    if (FileSystem::Instance().Exists(m_lldb_process_tmp_dir)) {
       // Remove the LLDB temporary directory if we have one. Set "recurse" to
       // true to all files that were created for the LLDB process can be
       // cleaned up.
       llvm::sys::fs::remove_directories(m_lldb_process_tmp_dir.GetPath());
     }
   }
 
   std::string m_host_triple;

source/Host/common/Symbols.cpp

static bool LookForDsymNextToExecutablePath(const ModuleSpec &mod_spec,
   dsym_directory.RemoveLastPathComponent();
 
   std::string dsym_filename = filename.AsCString();
   dsym_filename += ".dSYM";
   dsym_directory.AppendPathComponent(dsym_filename);
   dsym_directory.AppendPathComponent("Contents");
   dsym_directory.AppendPathComponent("Resources");
   dsym_directory.AppendPathComponent("DWARF");
-  
-  if (dsym_directory.Exists()) {
+  if (FileSystem::Instance().Exists(dsym_directory)) {
 
     // See if the binary name exists in the dSYM DWARF
     // subdir.
     dsym_fspec = dsym_directory;
     dsym_fspec.AppendPathComponent(filename.AsCString());
-    if (dsym_fspec.Exists()
-        && FileAtPathContainsArchAndUUID(dsym_fspec, 
-                         mod_spec.GetArchitecturePtr(),
+    if (FileSystem::Instance().Exists(dsym_fspec) &&
+        FileAtPathContainsArchAndUUID(dsym_fspec, mod_spec.GetArchitecturePtr(),
                                       mod_spec.GetUUIDPtr())) {
       return true;
     }
 
     // See if we have "../CF.framework" - so we'll look for
     // CF.framework.dSYM/Contents/Resources/DWARF/CF
     // We need to drop the last suffix after '.' to match 
     // 'CF' in the DWARF subdir.
     std::string binary_name (filename.AsCString());
     auto last_dot = binary_name.find_last_of('.');
     if (last_dot != std::string::npos) {
       binary_name.erase(last_dot);
       dsym_fspec = dsym_directory;
       dsym_fspec.AppendPathComponent(binary_name);
-      if (dsym_fspec.Exists()
-          && FileAtPathContainsArchAndUUID(dsym_fspec, 
+      if (FileSystem::Instance().Exists(dsym_fspec) &&
+          FileAtPathContainsArchAndUUID(dsym_fspec,
                                         mod_spec.GetArchitecturePtr(),
                                         mod_spec.GetUUIDPtr())) {
         return true;
       }
     }
-  } 
-  
+  }
   // See if we have a .dSYM.yaa next to this executable path.
   FileSpec dsym_yaa_fspec = exec_fspec;
   dsym_yaa_fspec.RemoveLastPathComponent();
   std::string dsym_yaa_filename = filename.AsCString();
   dsym_yaa_filename += ".dSYM.yaa";
   dsym_yaa_fspec.AppendPathComponent(dsym_yaa_filename);
 
-  if (dsym_yaa_fspec.Exists()) {
+  if (FileSystem::Instance().Exists(dsym_yaa_fspec)) {
     ModuleSpec mutable_mod_spec = mod_spec;
-    if (Symbols::DownloadObjectAndSymbolFile (mutable_mod_spec, true)
-        && mutable_mod_spec.GetSymbolFileSpec().Exists()) {
+    if (Symbols::DownloadObjectAndSymbolFile(mutable_mod_spec, true) &&
+        FileSystem::Instance().Exists(mutable_mod_spec.GetSymbolFileSpec())) {
       dsym_fspec = mutable_mod_spec.GetSymbolFileSpec();
       return true;
     }
   }
 
   return false;
 }
 
ModuleSpec Symbols::LocateExecutableObjectFile(const ModuleSpec &module_spec) {
   } else {
     LocateMacOSXFilesUsingDebugSymbols(module_spec, result);
   }
   return result;
 }
 
 FileSpec Symbols::LocateExecutableSymbolFile(const ModuleSpec &module_spec) {
   FileSpec symbol_file_spec = module_spec.GetSymbolFileSpec();
-  if (symbol_file_spec.IsAbsolute() && symbol_file_spec.Exists())
+  if (symbol_file_spec.IsAbsolute() &&
+      FileSystem::Instance().Exists(symbol_file_spec))
     return symbol_file_spec;
 
   const char *symbol_filename = symbol_file_spec.GetFilename().AsCString();
   if (symbol_filename && symbol_filename[0]) {
     FileSpecList debug_file_search_paths(
         Target::GetDefaultDebugFileSearchPaths());
 
     // Add module directory.
for (size_t idx = 0; idx < num_directories; ++idx) {
       for (size_t idx_file = 0; idx_file < num_files; ++idx_file) {
         const std::string &filename = files[idx_file];
         FileSpec file_spec(filename, true);
 
         if (llvm::sys::fs::equivalent(file_spec.GetPath(),
                                       module_file_spec.GetPath()))
           continue;
 
-        if (file_spec.Exists()) {
+        if (FileSystem::Instance().Exists(file_spec)) {
           lldb_private::ModuleSpecList specs;
           const size_t num_specs =
               ObjectFile::GetModuleSpecifications(file_spec, 0, 0, specs);
           assert(num_specs <= 1 &&
                  "Symbol Vendor supports only a single architecture");
           if (num_specs == 1) {
             ModuleSpec mspec;
             if (specs.GetModuleSpecAtIndex(0, mspec)) {

source/Host/macosx/Symbols.cpp

if (module_uuid.size() == 16) {
             if (exec_cf_path && ::CFStringGetFileSystemRepresentation(
                                     exec_cf_path, path, sizeof(path))) {
               if (log) {
                 log->Printf("plist bundle has exec path of %s for UUID %s",
                             path, uuid->GetAsString().c_str());
               }
               ++items_found;
               FileSpec exec_filespec(path, path[0] == '~');
-              if (exec_filespec.Exists()) {
+              if (FileSystem::Instance().Exists(exec_filespec)) {
                 success = true;
                 return_module_spec.GetFileSpec() = exec_filespec;
               }
             }
           }
 
           if (!success) {
             // No dictionary, check near the dSYM bundle for an executable that
bool Symbols::DownloadObjectAndSymbolFile(ModuleSpec &module_spec,
   }
 
   // When g_dbgshell_command is NULL, the user has not enabled the use of an
   // external program to find the symbols, don't run it for them.
   if (force_lookup == false && g_dbgshell_command == NULL) {
     return false;
   }
 
-  if (uuid_ptr || (file_spec_ptr && file_spec_ptr->Exists())) {
+  if (uuid_ptr ||
+      (file_spec_ptr && FileSystem::Instance().Exists(*file_spec_ptr))) {
     static bool g_located_dsym_for_uuid_exe = false;
     static bool g_dsym_for_uuid_exe_exists = false;
     static char g_dsym_for_uuid_exe_path[PATH_MAX];
     if (!g_located_dsym_for_uuid_exe) {
       g_located_dsym_for_uuid_exe = true;
       const char *dsym_for_uuid_exe_path_cstr =
           getenv("LLDB_APPLE_DSYMFORUUID_EXECUTABLE");
       FileSpec dsym_for_uuid_exe_spec;
       if (dsym_for_uuid_exe_path_cstr) {
         dsym_for_uuid_exe_spec.SetFile(dsym_for_uuid_exe_path_cstr, true,
                                        FileSpec::Style::native);
-        g_dsym_for_uuid_exe_exists = dsym_for_uuid_exe_spec.Exists();
+        g_dsym_for_uuid_exe_exists =
+            FileSystem::Instance().Exists(dsym_for_uuid_exe_spec);
       }
 
       if (!g_dsym_for_uuid_exe_exists) {
         dsym_for_uuid_exe_spec.SetFile("/usr/local/bin/dsymForUUID", false,
                                        FileSpec::Style::native);
-        g_dsym_for_uuid_exe_exists = dsym_for_uuid_exe_spec.Exists();
+        g_dsym_for_uuid_exe_exists =
+            FileSystem::Instance().Exists(dsym_for_uuid_exe_spec);
         if (!g_dsym_for_uuid_exe_exists) {
           long bufsize;
           if ((bufsize = sysconf(_SC_GETPW_R_SIZE_MAX)) != -1) {
             char buffer[bufsize];
             struct passwd pwd;
             struct passwd *tilde_rc = NULL;
             // we are a library so we need to use the reentrant version of
             // getpwnam()
             if (getpwnam_r("rc", &pwd, buffer, bufsize, &tilde_rc) == 0 &&
                 tilde_rc && tilde_rc->pw_dir) {
               std::string dsymforuuid_path(tilde_rc->pw_dir);
               dsymforuuid_path += "/bin/dsymForUUID";
               dsym_for_uuid_exe_spec.SetFile(dsymforuuid_path.c_str(), false,
                                              FileSpec::Style::native);
-              g_dsym_for_uuid_exe_exists = dsym_for_uuid_exe_spec.Exists();
+              g_dsym_for_uuid_exe_exists =
+                  FileSystem::Instance().Exists(dsym_for_uuid_exe_spec);
             }
           }
         }
       }
       if (!g_dsym_for_uuid_exe_exists && g_dbgshell_command != NULL) {
         dsym_for_uuid_exe_spec.SetFile(g_dbgshell_command, true,
                                        FileSpec::Style::native);
-        g_dsym_for_uuid_exe_exists = dsym_for_uuid_exe_spec.Exists();
+        g_dsym_for_uuid_exe_exists =
+            FileSystem::Instance().Exists(dsym_for_uuid_exe_spec);
       }
 
       if (g_dsym_for_uuid_exe_exists)
         dsym_for_uuid_exe_spec.GetPath(g_dsym_for_uuid_exe_path,
                                        sizeof(g_dsym_for_uuid_exe_path));
     }
     if (g_dsym_for_uuid_exe_exists) {
       std::string uuid_str;

source/Host/macosx/objcxx/Host.mm

LaunchInNewTerminalWithAppleScript(const char *exe_path,
   FileSpec darwin_debug_file_spec = HostInfo::GetSupportExeDir();
   if (!darwin_debug_file_spec) {
     error.SetErrorString("can't locate the 'darwin-debug' executable");
     return error;
   }
 
   darwin_debug_file_spec.GetFilename().SetCString("darwin-debug");
 
-  if (!darwin_debug_file_spec.Exists()) {
+  if (!FileSystem::Instance().Exists(darwin_debug_file_spec)) {
     error.SetErrorStringWithFormat(
         "the 'darwin-debug' executable doesn't exists at '%s'",
         darwin_debug_file_spec.GetPath().c_str());
     return error;
   }
 
   char launcher_path[PATH_MAX];
   darwin_debug_file_spec.GetPath(launcher_path, sizeof(launcher_path));
Status Host::ShellExpandArguments(ProcessLaunchInfo &launch_info) {
   if (launch_info.GetFlags().Test(eLaunchFlagShellExpandArguments)) {
     FileSpec expand_tool_spec = HostInfo::GetSupportExeDir();
     if (!expand_tool_spec) {
       error.SetErrorString(
           "could not get support executable directory for lldb-argdumper tool");
       return error;
     }
     expand_tool_spec.AppendPathComponent("lldb-argdumper");
-    if (!expand_tool_spec.Exists()) {
+    if (!FileSystem::Instance().Exists(expand_tool_spec)) {
       error.SetErrorStringWithFormat(
           "could not find the lldb-argdumper tool: %s",
           expand_tool_spec.GetPath().c_str());
       return error;
     }
 
     StreamString expand_tool_spec_stream;
     expand_tool_spec_stream.Printf("\"%s\"",
                                    expand_tool_spec.GetPath().c_str());
 
     Args expand_command(expand_tool_spec_stream.GetData());
     expand_command.AppendArguments(launch_info.GetArguments());
 
     int status;
     std::string output;
     FileSpec cwd(launch_info.GetWorkingDirectory());
-    if (!cwd.Exists()) {
+    if (!FileSystem::Instance().Exists(cwd)) {
       char *wd = getcwd(nullptr, 0);
       if (wd == nullptr) {
         error.SetErrorStringWithFormat(
             "cwd does not exist; cannot launch with shell argument expansion");
         return error;
       } else {
         FileSpec working_dir(wd, false);
         free(wd);

source/Interpreter/CommandInterpreter.cpp

if (target) {
           target->TargetProperties::GetLoadCWDlldbinitFile();
       if (should_load == eLoadCWDlldbinitWarn) {
         FileSpec dot_lldb(".lldbinit", true);
         llvm::SmallString<64> home_dir_path;
         llvm::sys::path::home_directory(home_dir_path);
         FileSpec homedir_dot_lldb(home_dir_path.c_str(), false);
         homedir_dot_lldb.AppendPathComponent(".lldbinit");
         homedir_dot_lldb.ResolvePath();
-        if (dot_lldb.Exists() &&
+        if (FileSystem::Instance().Exists(dot_lldb) &&
             dot_lldb.GetDirectory() != homedir_dot_lldb.GetDirectory()) {
           result.AppendErrorWithFormat(
               "There is a .lldbinit file in the current directory which is not "
               "being read.\n"
               "To silence this warning without sourcing in the local "
               ".lldbinit,\n"
               "add the following to the lldbinit file in your home directory:\n"
               "    settings set target.load-cwd-lldbinit false\n"
if (m_skip_app_init_files == false) {
       const char *program_name = program_file_spec.GetFilename().AsCString();
 
       if (program_name) {
         char program_init_file_name[PATH_MAX];
         ::snprintf(program_init_file_name, sizeof(program_init_file_name),
                    "%s-%s", init_file_path.c_str(), program_name);
         init_file.SetFile(program_init_file_name, true,
                           FileSpec::Style::native);
-        if (!init_file.Exists())
+        if (!FileSystem::Instance().Exists(init_file))
           init_file.Clear();
       }
     }
 
     if (!init_file && !m_skip_lldbinit_files)
       init_file.SetFile(init_file_path, false, FileSpec::Style::native);
   }
 
   // If the file exists, tell HandleCommand to 'source' it; this will do the
   // actual broadcasting of the commands back to any appropriate listener (see
   // CommandObjectSource::Execute for more details).
 
-  if (init_file.Exists()) {
+  if (FileSystem::Instance().Exists(init_file)) {
     const bool saved_batch = SetBatchCommandMode(true);
     CommandInterpreterRunOptions options;
     options.SetSilent(true);
     options.SetStopOnError(false);
     options.SetStopOnContinue(true);
 
     HandleCommandsFromFile(init_file,
                            nullptr, // Execution context
enum {
   eHandleCommandFlagEchoCommentCommand = (1u << 3),
   eHandleCommandFlagPrintResult = (1u << 4),
   eHandleCommandFlagStopOnCrash = (1u << 5)
 };
 
 void CommandInterpreter::HandleCommandsFromFile(
     FileSpec &cmd_file, ExecutionContext *context,
     CommandInterpreterRunOptions &options, CommandReturnObject &result) {
-  if (cmd_file.Exists()) {
+  if (FileSystem::Instance().Exists(cmd_file)) {
     StreamFileSP input_file_sp(new StreamFile());
 
     std::string cmd_file_path = cmd_file.GetPath();
     Status error = input_file_sp->GetFile().Open(cmd_file_path.c_str(),
                                                  File::eOpenOptionRead);
 
     if (error.Success()) {
       Debugger &debugger = GetDebugger();

source/Interpreter/OptionValuePathMappings.cpp

 //===-- OptionValuePathMappings.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/Interpreter/OptionValuePathMappings.h"
 
 // C Includes
 // C++ Includes
 // Other libraries and framework includes
 // Project includes
+#include "lldb/Host/FileSystem.h"
 #include "lldb/Host/StringConvert.h"
 #include "lldb/Utility/Args.h"
 #include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/Stream.h"
 
 using namespace lldb;
 using namespace lldb_private;
 namespace {
 static bool VerifyPathExists(const char *path) {
   if (path && path[0])
-    return FileSpec(path, false).Exists();
+    return FileSystem::Instance().Exists(path);
   else
     return false;
 }
 }
 
 void OptionValuePathMappings::DumpValue(const ExecutionContext *exe_ctx,
                                         Stream &strm, uint32_t dump_mask) {
   if (dump_mask & eDumpOptionType)

source/Plugins/DynamicLoader/Darwin-Kernel/DynamicLoaderDarwinKernel.cpp

if (!m_module_sp && uuid_is_valid) {
       ModuleSpec module_spec;
       module_spec.GetUUID() = m_uuid;
       module_spec.GetArchitecture() = target.GetArchitecture();
 
       // For the kernel, we really do need an on-disk file copy of the binary
       // to do anything useful. This will force a clal to
       if (IsKernel()) {
         if (Symbols::DownloadObjectAndSymbolFile(module_spec, true)) {
-          if (module_spec.GetFileSpec().Exists()) {
+          if (FileSystem::Instance().Exists(module_spec.GetFileSpec())) {
             m_module_sp.reset(new Module(module_spec.GetFileSpec(),
                                          target.GetArchitecture()));
             if (m_module_sp.get() &&
                 m_module_sp->MatchesModuleSpec(module_spec)) {
               ModuleList loaded_module_list;
               loaded_module_list.Append(m_module_sp);
               target.ModulesDidLoad(loaded_module_list);
             }

source/Plugins/DynamicLoader/Hexagon-DYLD/DynamicLoaderHexagonDYLD.cpp

ModuleSP DynamicLoaderHexagonDYLD::GetTargetExecutable() {
   Target &target = m_process->GetTarget();
   ModuleSP executable = target.GetExecutableModule();
 
   // There is no executable
   if (!executable.get())
     return executable;
 
   // The target executable file does not exits
-  if (!executable->GetFileSpec().Exists())
+  if (!FileSystem::Instance().Exists(executable->GetFileSpec()))
     return executable;
 
   // Prep module for loading
   ModuleSpec module_spec(executable->GetFileSpec(),
                          executable->GetArchitecture());
   ModuleSP module_sp(new Module(module_spec));
 
   // Check if the executable has changed and set it to the target executable if

source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.cpp

bool RenderScriptRuntime::LoadAllocation(Stream &strm, const uint32_t alloc_id,
 
   assert(alloc->data_ptr.isValid() && alloc->element.type.isValid() &&
          alloc->element.type_vec_size.isValid() && alloc->size.isValid() &&
          alloc->element.datum_size.isValid() &&
          "Allocation information not available");
 
   // Check we can read from file
   FileSpec file(path, true);
-  if (!file.Exists()) {
+  if (!FileSystem::Instance().Exists(file)) {
     strm.Printf("Error: File %s does not exist", path);
     strm.EOL();
     return false;
   }
 
   if (!FileSystem::Instance().Readable(file)) {
     strm.Printf("Error: File %s does not have readable permissions", path);
     strm.EOL();
public:
     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                           ExecutionContext *exe_ctx) override {
       Status err;
       const int short_option = m_getopt_table[option_idx].val;
 
       switch (short_option) {
       case 'f':
         m_outfile.SetFile(option_arg, true, FileSpec::Style::native);
-        if (m_outfile.Exists()) {
+        if (FileSystem::Instance().Exists(m_outfile)) {
           m_outfile.Clear();
           err.SetErrorStringWithFormat("file already exists: '%s'",
                                        option_arg.str().c_str());
         }
         break;
       default:
         err.SetErrorStringWithFormat("unrecognized option '%c'", short_option);
         break;

source/Plugins/ObjectFile/Mach-O/ObjectFileMachO.cpp

if (m_header.flags & 0x80000000u) {
       if (process) {
         GetProcessSharedCacheUUID(process, process_shared_cache_base_addr, process_shared_cache_uuid);
       }
 
       // First see if we can find an exact match for the inferior process
       // shared cache UUID in the development or non-development shared caches
       // on disk.
       if (process_shared_cache_uuid.IsValid()) {
-        if (dsc_development_filespec.Exists()) {
+        if (FileSystem::Instance().Exists(dsc_development_filespec)) {
           UUID dsc_development_uuid = GetSharedCacheUUID(
               dsc_development_filespec, byte_order, addr_byte_size);
           if (dsc_development_uuid.IsValid() &&
               dsc_development_uuid == process_shared_cache_uuid) {
             dsc_filespec = dsc_development_filespec;
             dsc_uuid = dsc_development_uuid;
           }
         }
-        if (!dsc_uuid.IsValid() && dsc_nondevelopment_filespec.Exists()) {
+        if (!dsc_uuid.IsValid() &&
+            FileSystem::Instance().Exists(dsc_nondevelopment_filespec)) {
           UUID dsc_nondevelopment_uuid = GetSharedCacheUUID(
               dsc_nondevelopment_filespec, byte_order, addr_byte_size);
           if (dsc_nondevelopment_uuid.IsValid() &&
               dsc_nondevelopment_uuid == process_shared_cache_uuid) {
             dsc_filespec = dsc_nondevelopment_filespec;
             dsc_uuid = dsc_nondevelopment_uuid;
           }
         }
       }
 
       // Failing a UUID match, prefer the development dyld_shared cache if both
       // are present.
-      if (!dsc_filespec.Exists()) {
-        if (dsc_development_filespec.Exists()) {
+      if (!FileSystem::Instance().Exists(dsc_filespec)) {
+        if (FileSystem::Instance().Exists(dsc_development_filespec)) {
           dsc_filespec = dsc_development_filespec;
         } else {
           dsc_filespec = dsc_nondevelopment_filespec;
         }
       }
 
       /* The dyld_cache_header has a pointer to the
          dyld_cache_local_symbols_info structure (localSymbolsOffset).
if (m_header.flags & 0x80000000u) {
                                   // The linker has been generating bad N_SO
                                   // entries with doubled up paths
                                   // in the format "%s%s" where the first
                                   // string in the DW_AT_comp_dir, and the
                                   // second is the directory for the source
                                   // file so you end up with a path that looks
                                   // like "/tmp/src//tmp/src/"
                                   FileSpec so_dir(so_path, false);
-                                  if (!so_dir.Exists()) {
+                                  if (!FileSystem::Instance().Exists(so_dir)) {
                                     so_dir.SetFile(
                                         &full_so_path[double_slash_pos + 1],
                                         false);
-                                    if (so_dir.Exists()) {
+                                    if (FileSystem::Instance().Exists(so_dir)) {
                                       // Trim off the incorrect path
                                       full_so_path.erase(0,
                                                          double_slash_pos + 1);
                                     }
                                   }
                                 }
                                 if (*full_so_path.rbegin() != '/')
                                   full_so_path += '/';
if (nlist_data.GetByteSize() > 0) {
                   const size_t double_slash_pos = full_so_path.find("//");
                   if (double_slash_pos != std::string::npos) {
                     // The linker has been generating bad N_SO entries with
                     // doubled up paths in the format "%s%s" where the first
                     // string in the DW_AT_comp_dir, and the second is the
                     // directory for the source file so you end up with a path
                     // that looks like "/tmp/src//tmp/src/"
                     FileSpec so_dir(so_path, false);
-                    if (!so_dir.Exists()) {
+                    if (!FileSystem::Instance().Exists(so_dir)) {
                       so_dir.SetFile(&full_so_path[double_slash_pos + 1], false,
                                      FileSpec::Style::native);
-                      if (so_dir.Exists()) {
+                      if (FileSystem::Instance().Exists(so_dir)) {
                         // Trim off the incorrect path
                         full_so_path.erase(0, double_slash_pos + 1);
                       }
                     }
                   }
                   if (*full_so_path.rbegin() != '/')
                     full_so_path += '/';
                   full_so_path += symbol_name;
if (!rpath_paths.empty()) {
 
       for (const auto &rpath_relative_path : rpath_relative_paths) {
         for (const auto &rpath : rpath_paths) {
           std::string path = rpath;
           path += rpath_relative_path;
           // It is OK to resolve this path because we must find a file on disk
           // for us to accept it anyway if it is rpath relative.
           FileSpec file_spec(path, true);
-          if (file_spec.Exists() && files.AppendIfUnique(file_spec)) {
+          if (FileSystem::Instance().Exists(file_spec) &&
+              files.AppendIfUnique(file_spec)) {
             count++;
             break;
           }
         }
       }
     }
 
     // We may have @executable_paths but no RPATHS.  Figure those out here.
     // Only do this if this object file is the executable.  We have no way to
     // get back to the actual executable otherwise, so we won't get the right
     // path.
     if (!at_exec_relative_paths.empty() && CalculateType() == eTypeExecutable) {
       FileSpec exec_dir = this_file_spec.CopyByRemovingLastPathComponent();
       for (const auto &at_exec_relative_path : at_exec_relative_paths) {
         FileSpec file_spec = 
             exec_dir.CopyByAppendingPathComponent(at_exec_relative_path);
-        if (file_spec.Exists() && files.AppendIfUnique(file_spec))
+        if (FileSystem::Instance().Exists(file_spec) &&
+            files.AppendIfUnique(file_spec))
           count++;
       }
     }
   }
   return count;
 }
 
 lldb_private::Address ObjectFileMachO::GetEntryPointAddress() {

source/Plugins/OperatingSystem/Python/OperatingSystemPython.cpp

void OperatingSystemPython::Terminate() {
   PluginManager::UnregisterPlugin(CreateInstance);
 }
 
 OperatingSystem *OperatingSystemPython::CreateInstance(Process *process,
                                                        bool force) {
   // Python OperatingSystem plug-ins must be requested by name, so force must
   // be true
   FileSpec python_os_plugin_spec(process->GetPythonOSPluginPath());
-  if (python_os_plugin_spec && python_os_plugin_spec.Exists()) {
+  if (python_os_plugin_spec &&
+      FileSystem::Instance().Exists(python_os_plugin_spec)) {
     std::unique_ptr<OperatingSystemPython> os_ap(
         new OperatingSystemPython(process, python_os_plugin_spec));
     if (os_ap.get() && os_ap->IsValid())
       return os_ap.release();
   }
   return NULL;
 }
 

source/Plugins/Platform/MacOSX/PlatformAppleTVSimulator.cpp

Status PlatformAppleTVSimulator::ResolveExecutable(
   //    if (!resolved_exe_file.Exists())
   //        resolved_exe_file.ResolveExecutableLocation ();
 
   // Resolve any executable within a bundle on MacOSX
   // TODO: verify that this handles shallow bundles, if not then implement one
   // ourselves
   Host::ResolveExecutableInBundle(resolved_module_spec.GetFileSpec());
 
-  if (resolved_module_spec.GetFileSpec().Exists()) {
+  if (FileSystem::Instance().Exists(resolved_module_spec.GetFileSpec())) {
     if (resolved_module_spec.GetArchitecture().IsValid()) {
       error = ModuleList::GetSharedModule(resolved_module_spec, exe_module_sp,
                                           NULL, NULL, NULL);
 
       if (exe_module_sp && exe_module_sp->GetObjectFile())
         return error;
       exe_module_sp.reset();
     }
if (platform_file.GetPath(platform_file_path, sizeof(platform_file_path))) {
 
     const char *sdk_dir = GetSDKDirectoryAsCString();
     if (sdk_dir) {
       ::snprintf(resolved_path, sizeof(resolved_path), "%s/%s", sdk_dir,
                  platform_file_path);
 
       // First try in the SDK and see if the file is in there
       local_file.SetFile(resolved_path, true, FileSpec::Style::native);
-      if (local_file.Exists())
+      if (FileSystem::Instance().Exists(local_file))
         return error;
 
       // Else fall back to the actual path itself
       local_file.SetFile(platform_file_path, true, FileSpec::Style::native);
-      if (local_file.Exists())
+      if (FileSystem::Instance().Exists(local_file))
         return error;
     }
     error.SetErrorStringWithFormat(
         "unable to locate a platform file for '%s' in platform '%s'",
         platform_file_path, GetPluginName().GetCString());
   } else {
     error.SetErrorString("invalid platform file argument");
   }

source/Plugins/Platform/MacOSX/PlatformAppleWatchSimulator.cpp

Status PlatformAppleWatchSimulator::ResolveExecutable(
   //    if (!resolved_exe_file.Exists())
   //        resolved_exe_file.ResolveExecutableLocation ();
 
   // Resolve any executable within a bundle on MacOSX
   // TODO: verify that this handles shallow bundles, if not then implement one
   // ourselves
   Host::ResolveExecutableInBundle(resolved_module_spec.GetFileSpec());
 
-  if (resolved_module_spec.GetFileSpec().Exists()) {
+  if (FileSystem::Instance().Exists(resolved_module_spec.GetFileSpec())) {
     if (resolved_module_spec.GetArchitecture().IsValid()) {
       error = ModuleList::GetSharedModule(resolved_module_spec, exe_module_sp,
                                           NULL, NULL, NULL);
 
       if (exe_module_sp && exe_module_sp->GetObjectFile())
         return error;
       exe_module_sp.reset();
     }
if (platform_file.GetPath(platform_file_path, sizeof(platform_file_path))) {
 
     const char *sdk_dir = GetSDKDirectoryAsCString();
     if (sdk_dir) {
       ::snprintf(resolved_path, sizeof(resolved_path), "%s/%s", sdk_dir,
                  platform_file_path);
 
       // First try in the SDK and see if the file is in there
       local_file.SetFile(resolved_path, true, FileSpec::Style::native);
-      if (local_file.Exists())
+      if (FileSystem::Instance().Exists(local_file))
         return error;
 
       // Else fall back to the actual path itself
       local_file.SetFile(platform_file_path, true, FileSpec::Style::native);
-      if (local_file.Exists())
+      if (FileSystem::Instance().Exists(local_file))
         return error;
     }
     error.SetErrorStringWithFormat(
         "unable to locate a platform file for '%s' in platform '%s'",
         platform_file_path, GetPluginName().GetCString());
   } else {
     error.SetErrorString("invalid platform file argument");
   }

source/Plugins/Platform/MacOSX/PlatformDarwin.cpp

if (target &&
     if (module_spec) {
       SymbolVendor *symbols = module.GetSymbolVendor();
       if (symbols) {
         SymbolFile *symfile = symbols->GetSymbolFile();
         if (symfile) {
           ObjectFile *objfile = symfile->GetObjectFile();
           if (objfile) {
             FileSpec symfile_spec(objfile->GetFileSpec());
-            if (symfile_spec && symfile_spec.Exists()) {
+            if (symfile_spec && FileSystem::Instance().Exists(symfile_spec)) {
               while (module_spec.GetFilename()) {
                 std::string module_basename(
                     module_spec.GetFilename().GetCString());
                 std::string original_module_basename(module_basename);
 
                 bool was_keyword = false;
 
                 // FIXME: for Python, we cannot allow certain characters in
if (module_spec) {
                 FileSpec orig_script_fspec(original_path_string.GetString(),
                                            true);
 
                 // if we did some replacements of reserved characters, and a
                 // file with the untampered name exists, then warn the user
                 // that the file as-is shall not be loaded
                 if (feedback_stream) {
                   if (module_basename != original_module_basename &&
-                      orig_script_fspec.Exists()) {
+                      FileSystem::Instance().Exists(orig_script_fspec)) {
                     const char *reason_for_complaint =
                         was_keyword ? "conflicts with a keyword"
                                     : "contains reserved characters";
-                    if (script_fspec.Exists())
+                    if (FileSystem::Instance().Exists(script_fspec))
                       feedback_stream->Printf(
                           "warning: the symbol file '%s' contains a debug "
                           "script. However, its name"
                           " '%s' %s and as such cannot be loaded. LLDB will"
                           " load '%s' instead. Consider removing the file with "
                           "the malformed name to"
                           " eliminate this warning.\n",
                           symfile_spec.GetPath().c_str(),
                           original_path_string.GetData(), reason_for_complaint,
                           path_string.GetData());
                     else
                       feedback_stream->Printf(
                           "warning: the symbol file '%s' contains a debug "
                           "script. However, its name"
                           " %s and as such cannot be loaded. If you intend"
                           " to have this script loaded, please rename '%s' to "
                           "'%s' and retry.\n",
                           symfile_spec.GetPath().c_str(), reason_for_complaint,
                           original_path_string.GetData(),
                           path_string.GetData());
                   }
                 }
 
-                if (script_fspec.Exists()) {
+                if (FileSystem::Instance().Exists(script_fspec)) {
                   file_list.Append(script_fspec);
                   break;
                 }
 
                 // If we didn't find the python file, then keep stripping the
                 // extensions and try again
                 ConstString filename_no_extension(
                     module_spec.GetFileNameStrippingExtension());
if (!cache_path.empty()) {
 
       // if rsync is supported, always bring in the file - rsync will be very
       // efficient when files are the same on the local and remote end of the
       // connection
       if (this->GetSupportsRSync()) {
         err = BringInRemoteFile(this, module_spec, module_cache_spec);
         if (err.Fail())
           return err;
-        if (module_cache_spec.Exists()) {
+        if (FileSystem::Instance().Exists(module_cache_spec)) {
           Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PLATFORM));
           if (log)
             log->Printf("[%s] module %s/%s was rsynced and is now there",
                         (IsHost() ? "host" : "remote"),
                         module_spec.GetFileSpec().GetDirectory().AsCString(),
                         module_spec.GetFileSpec().GetFilename().AsCString());
           ModuleSpec local_spec(module_cache_spec,
                                 module_spec.GetArchitecture());
           module_sp.reset(new Module(local_spec));
           module_sp->SetPlatformFileSpec(module_spec.GetFileSpec());
           return Status();
         }
       }
 
       // try to find the module in the cache
-      if (module_cache_spec.Exists()) {
+      if (FileSystem::Instance().Exists(module_cache_spec)) {
         // get the local and remote MD5 and compare
         if (m_remote_platform_sp) {
           // when going over the *slow* GDB remote transfer mechanism we first
           // check the hashes of the files - and only do the actual transfer if
           // they differ
           uint64_t high_local, high_remote, low_local, low_remote;
           auto MD5 = llvm::sys::fs::md5_contents(module_cache_spec.GetPath());
           if (!MD5)
if (!cache_path.empty()) {
       if (log)
         log->Printf("[%s] module %s/%s needs to come in remotely",
                     (IsHost() ? "host" : "remote"),
                     module_spec.GetFileSpec().GetDirectory().AsCString(),
                     module_spec.GetFileSpec().GetFilename().AsCString());
       Status err = BringInRemoteFile(this, module_spec, module_cache_spec);
       if (err.Fail())
         return err;
-      if (module_cache_spec.Exists()) {
+      if (FileSystem::Instance().Exists(module_cache_spec)) {
         Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PLATFORM));
         if (log)
           log->Printf("[%s] module %s/%s is now cached and fine",
                       (IsHost() ? "host" : "remote"),
                       module_spec.GetFileSpec().GetDirectory().AsCString(),
                       module_spec.GetFileSpec().GetFilename().AsCString());
         ModuleSpec local_spec(module_cache_spec, module_spec.GetArchitecture());
         module_sp.reset(new Module(local_spec));
if (!module_sp && module_search_paths_ptr && platform_file) {
             const size_t search_path_len =
                 module_search_paths_ptr->GetFileSpecAtIndex(i).GetPath(
                     new_path, sizeof(new_path));
             if (search_path_len < sizeof(new_path)) {
               snprintf(new_path + search_path_len,
                        sizeof(new_path) - search_path_len, "/%s",
                        platform_path + bundle_directory_len);
               FileSpec new_file_spec(new_path, false);
-              if (new_file_spec.Exists()) {
+              if (FileSystem::Instance().Exists(new_file_spec)) {
                 ModuleSpec new_module_spec(module_spec);
                 new_module_spec.GetFileSpec() = new_file_spec;
                 Status new_error(Platform::GetSharedModule(
                     new_module_spec, process, module_sp, NULL,
                     old_module_sp_ptr, did_create_ptr));
 
                 if (module_sp) {
                   module_sp->SetPlatformFileSpec(new_file_spec);
if (!developer_dir_path_valid) {
         ::memcpy(developer_dir_path, path_ref.data(), path_ref.size());
         developer_dir_path[path_ref.size()] = '\0';
         developer_dir_path_valid = true;
       }
     }
 
     if (!developer_dir_path_valid) {
       FileSpec xcode_select_cmd("/usr/bin/xcode-select", false);
-      if (xcode_select_cmd.Exists()) {
+      if (FileSystem::Instance().Exists(xcode_select_cmd)) {
         int exit_status = -1;
         int signo = -1;
         std::string command_output;
         Status error =
             Host::RunShellCommand("/usr/bin/xcode-select --print-path",
                                   NULL, // current working directory
                                   &exit_status, &signo, &command_output,
                                   std::chrono::seconds(2), // short timeout
if (!developer_dir_path_valid) {
           }
         }
       }
     }
 
     if (developer_dir_path_valid) {
       temp_file_spec.SetFile(developer_dir_path, false,
                              FileSpec::Style::native);
-      if (temp_file_spec.Exists()) {
+      if (FileSystem::Instance().Exists(temp_file_spec)) {
         m_developer_directory.assign(developer_dir_path);
         return m_developer_directory.c_str();
       }
     }
     // Assign a single NULL character so we know we tried to find the device
     // support directory and we don't keep trying to find it over and over.
     m_developer_directory.assign(1, '\0');
   }
void PlatformDarwin::CalculateTrapHandlerSymbolNames() {
   m_trap_handlers.push_back(ConstString("_sigtramp"));
 }
 
 static const char *const sdk_strings[] = {
     "MacOSX", "iPhoneSimulator", "iPhoneOS",
 };
 
 static FileSpec CheckPathForXcode(const FileSpec &fspec) {
-  if (fspec.Exists()) {
+  if (FileSystem::Instance().Exists(fspec)) {
     const char substr[] = ".app/Contents";
 
     std::string path_to_shlib = fspec.GetPath();
     size_t pos = path_to_shlib.rfind(substr);
     if (pos != std::string::npos) {
       path_to_shlib.erase(pos + strlen(substr));
       FileSpec ret(path_to_shlib, false);
 
       FileSpec xcode_binary_path = ret;
       xcode_binary_path.AppendPathComponent("MacOS");
       xcode_binary_path.AppendPathComponent("Xcode");
 
-      if (xcode_binary_path.Exists()) {
+      if (FileSystem::Instance().Exists(xcode_binary_path)) {
         return ret;
       }
     }
   }
   return FileSpec();
 }
 
 static FileSpec GetXcodeContentsPath() {
if (!version.empty()) {
         // there.
 
         FileSpec native_sdk_spec = sdks_spec;
         StreamString native_sdk_name;
         native_sdk_name.Printf("MacOSX%u.%u.sdk", version.getMajor(),
                                version.getMinor().getValueOr(0));
         native_sdk_spec.AppendPathComponent(native_sdk_name.GetString());
 
-        if (native_sdk_spec.Exists()) {
+        if (FileSystem::Instance().Exists(native_sdk_spec)) {
           return native_sdk_spec;
         }
       }
     }
   }
 
   return FindSDKInXcodeForModules(sdk_type, sdks_spec);
 }
llvm::call_once(g_once_flag, []() {
 
     // When locating executables, trust the DEVELOPER_DIR first if it is set
     FileSpec xcode_contents_dir = GetXcodeContentsPath();
     if (xcode_contents_dir) {
       FileSpec xcode_lldb_resources = xcode_contents_dir;
       xcode_lldb_resources.AppendPathComponent("SharedFrameworks");
       xcode_lldb_resources.AppendPathComponent("LLDB.framework");
       xcode_lldb_resources.AppendPathComponent("Resources");
-      if (xcode_lldb_resources.Exists()) {
+      if (FileSystem::Instance().Exists(xcode_lldb_resources)) {
         FileSpec dir;
         dir.GetDirectory().SetCString(xcode_lldb_resources.GetPath().c_str());
         g_executable_dirs.push_back(dir);
       }
     }
   });
 
   // Now search the global list of executable directories for the executable we
   // are looking for
   for (const auto &executable_dir : g_executable_dirs) {
     FileSpec executable_file;
     executable_file.GetDirectory() = executable_dir.GetDirectory();
     executable_file.GetFilename().SetCString(basename);
-    if (executable_file.Exists())
+    if (FileSystem::Instance().Exists(executable_file))
       return executable_file;
   }
 
   return FileSpec();
 }
 
 lldb_private::Status
 PlatformDarwin::LaunchProcess(lldb_private::ProcessLaunchInfo &launch_info) {
for (size_t i = 0; i < num_module_search_paths; ++i) {
         // and if 'j' is 2, we want to append path_parts[1] and then
         // path_parts[0], aka 'UIFoundation.framework/UIFoundation', to the
         // module_search_paths_ptr path.
 
         for (int k = j; k >= 0; --k) {
           path_to_try.AppendPathComponent(path_parts[k]);
         }
 
-        if (path_to_try.Exists()) {
+        if (FileSystem::Instance().Exists(path_to_try)) {
           ModuleSpec new_module_spec(module_spec);
           new_module_spec.GetFileSpec() = path_to_try;
           Status new_error(Platform::GetSharedModule(
               new_module_spec, process, module_sp, NULL, old_module_sp_ptr,
               did_create_ptr));
 
           if (module_sp) {
             module_sp->SetPlatformFileSpec(path_to_try);
             return new_error;
           }
         }
       }
     }
   }
   return Status();
 }

source/Plugins/Platform/MacOSX/PlatformDarwinKernel.cpp

if (m_name_to_kext_path_map_without_dsyms.count(kext_bundle_cs) > 0) {
       }
     }
   }
 
   if (kext_bundle_id.compare("mach_kernel") == 0 &&
       module_spec.GetUUID().IsValid()) {
     // First try all kernel binaries that have a dSYM next to them
     for (auto possible_kernel : m_kernel_binaries_with_dsyms) {
-      if (possible_kernel.Exists()) {
+      if (FileSystem::Instance().Exists(possible_kernel)) {
         ModuleSpec kern_spec(possible_kernel);
         kern_spec.GetUUID() = module_spec.GetUUID();
         ModuleSP module_sp(new Module(kern_spec));
         if (module_sp && module_sp->GetObjectFile() &&
             module_sp->MatchesModuleSpec(kern_spec)) {
           // module_sp is an actual kernel binary we want to add.
           if (process) {
             process->GetTarget().GetImages().AppendIfNeeded(module_sp);
error = PlatformDarwin::GetSharedModule(module_spec, process, module_sp,
                                             module_search_paths_ptr,
                                             old_module_sp_ptr, did_create_ptr);
     if (error.Success() && module_sp.get()) {
       return error;
     }
 
     // Next try all kernel binaries that don't have a dSYM
     for (auto possible_kernel : m_kernel_binaries_without_dsyms) {
-      if (possible_kernel.Exists()) {
+      if (FileSystem::Instance().Exists(possible_kernel)) {
         ModuleSpec kern_spec(possible_kernel);
         kern_spec.GetUUID() = module_spec.GetUUID();
         ModuleSP module_sp(new Module(kern_spec));
         if (module_sp && module_sp->GetObjectFile() &&
             module_sp->MatchesModuleSpec(kern_spec)) {
           // module_sp is an actual kernel binary we want to add.
           if (process) {
             process->GetTarget().GetImages().AppendIfNeeded(module_sp);
PlatformDarwinKernel::SearchForExecutablesRecursively(const std::string &dir) {
   return executables;
 }
 
 Status PlatformDarwinKernel::ExamineKextForMatchingUUID(
     const FileSpec &kext_bundle_path, const lldb_private::UUID &uuid,
     const ArchSpec &arch, ModuleSP &exe_module_sp) {
   for (const auto &exe_file :
        SearchForExecutablesRecursively(kext_bundle_path.GetPath())) {
-    if (exe_file.Exists()) {
+    if (FileSystem::Instance().Exists(exe_file)) {
       ModuleSpec exe_spec(exe_file);
       exe_spec.GetUUID() = uuid;
       if (!uuid.IsValid()) {
         exe_spec.GetArchitecture() = arch;
       }
 
       // First try to create a ModuleSP with the file / arch and see if the UUID
       // matches. If that fails (this exec file doesn't have the correct uuid),

source/Plugins/Platform/MacOSX/PlatformMacOSX.cpp

if (objfile) {
 
         if (!xcode_contents_path.empty()) {
           StreamString sdk_path;
           sdk_path.Printf("%sDeveloper/Platforms/MacOSX.platform/Developer/"
                           "SDKs/MacOSX%u.%u.sdk",
                           xcode_contents_path.c_str(), versions[0],
                           versions[1]);
           fspec.SetFile(sdk_path.GetString(), false, FileSpec::Style::native);
-          if (fspec.Exists())
+          if (FileSystem::Instance().Exists(fspec))
             return ConstString(sdk_path.GetString());
         }
 
         if (!default_xcode_sdk.empty()) {
           fspec.SetFile(default_xcode_sdk, false, FileSpec::Style::native);
-          if (fspec.Exists())
+          if (FileSystem::Instance().Exists(fspec))
             return ConstString(default_xcode_sdk);
         }
       }
     }
   }
   return ConstString();
 }
 
if (local_os_build.compare(remote_os_build) == 0) {
       local_file = platform_file;
       return Status();
     } else {
       // try to find the file in the cache
       std::string cache_path(GetLocalCacheDirectory());
       std::string module_path(platform_file.GetPath());
       cache_path.append(module_path);
       FileSpec module_cache_spec(cache_path, false);
-      if (module_cache_spec.Exists()) {
+      if (FileSystem::Instance().Exists(module_cache_spec)) {
         local_file = module_cache_spec;
         return Status();
       }
       // bring in the remote module file
       FileSpec module_cache_folder =
           module_cache_spec.CopyByRemovingLastPathComponent();
       // try to make the local directory first
       Status err(
           llvm::sys::fs::create_directory(module_cache_folder.GetPath()));
       if (err.Fail())
         return err;
       err = GetFile(platform_file, module_cache_spec);
       if (err.Fail())
         return err;
-      if (module_cache_spec.Exists()) {
+      if (FileSystem::Instance().Exists(module_cache_spec)) {
         local_file = module_cache_spec;
         return Status();
       } else
         return Status("unable to obtain valid module file");
     }
   }
   local_file = platform_file;
   return Status();

source/Plugins/Platform/MacOSX/PlatformRemoteDarwinDevice.cpp

 // C++ Includes
 // Other libraries and framework includes
 // Project includes
 #include "lldb/Breakpoint/BreakpointLocation.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleList.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/PluginManager.h"
+#include "lldb/Host/FileSystem.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/StreamString.h"
 
Status PlatformRemoteDarwinDevice::ResolveExecutable(
 
   ModuleSpec resolved_module_spec(ms);
 
   // Resolve any executable within a bundle on MacOSX
   // TODO: verify that this handles shallow bundles, if not then implement one
   // ourselves
   Host::ResolveExecutableInBundle(resolved_module_spec.GetFileSpec());
 
-  if (resolved_module_spec.GetFileSpec().Exists()) {
+  if (FileSystem::Instance().Exists(resolved_module_spec.GetFileSpec())) {
     if (resolved_module_spec.GetArchitecture().IsValid() ||
         resolved_module_spec.GetUUID().IsValid()) {
       error = ModuleList::GetSharedModule(resolved_module_spec, exe_module_sp,
                                           NULL, NULL, NULL);
 
       if (exe_module_sp && exe_module_sp->GetObjectFile())
         return error;
       exe_module_sp.reset();
if (device_support_dir) {
 
       // 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 (sdk_symbols_symlink_fspec.Exists()) {
+        if (FileSystem::Instance().Exists(sdk_symbols_symlink_fspec)) {
           m_sdk_directory_infos.push_back(sdk_directory_info);
           if (log) {
             log->Printf("PlatformRemoteDarwinDevice::UpdateSDKDirectoryInfosIfNeeded "
                         "added builtin SDK directory %s",
                         sdk_symbols_symlink_fspec.GetPath().c_str());
           }
         }
       }
 
       std::vector<std::string>  device_support_dirnames;
       GetDeviceSupportDirectoryNames (device_support_dirnames);
 
       for (std::string &dirname : device_support_dirnames)
       {
         const uint32_t num_installed = m_sdk_directory_infos.size();
         std::string local_sdk_cache_str = "~/Library/Developer/Xcode/";
         local_sdk_cache_str += dirname;
         FileSpec local_sdk_cache(local_sdk_cache_str.c_str(), true);
-        if (local_sdk_cache.Exists()) {
-            if (log) {
+        if (FileSystem::Instance().Exists(local_sdk_cache)) {
             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))) {
               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
if (device_support_dir) {
         FileSystem::Instance().EnumerateDirectory(
             addtional_platform_dirs, find_directories, find_files, find_other,
             GetContainedFilesIntoVectorOfStringsCallback,
             &env_var_sdk_directory_infos);
         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()) {
+          if (FileSystem::Instance().Exists(sdk_symbols_symlink_fspec)) {
             m_sdk_directory_infos.push_back(sdk_directory_info);
             if (log) {
               log->Printf("PlatformRemoteDarwinDevice::UpdateSDKDirectoryInfosIfNeeded "
                           "added env var SDK directory %s",
                           sdk_symbols_symlink_fspec.GetPath().c_str());
             }
           }
         }
if (!sdkroot_path.empty() && platform_file_path && platform_file_path[0]) {
 
       const char *paths_to_try[] = {"Symbols", "", "Symbols.Internal", nullptr};
       for (size_t i = 0; paths_to_try[i] != nullptr; i++) {
         local_file.SetFile(sdkroot_path, false, FileSpec::Style::native);
         if (paths_to_try[i][0] != '\0')
           local_file.AppendPathComponent(paths_to_try[i]);
         local_file.AppendPathComponent(platform_file_path);
         local_file.ResolvePath();
-        if (local_file.Exists()) {
+        if (FileSystem::Instance().Exists(local_file)) {
           if (log)
             log->Printf("Found a copy of %s in the SDK dir %s/%s",
                         platform_file_path, sdkroot_path.c_str(),
                         paths_to_try[i]);
           return true;
         }
         local_file.Clear();
       }
if (platform_file.GetPath(platform_file_path, sizeof(platform_file_path))) {
     char resolved_path[PATH_MAX];
 
     const char *os_version_dir = GetDeviceSupportDirectoryForOSVersion();
     if (os_version_dir) {
       ::snprintf(resolved_path, sizeof(resolved_path), "%s/%s", os_version_dir,
                  platform_file_path);
 
       local_file.SetFile(resolved_path, true, FileSpec::Style::native);
-      if (local_file.Exists()) {
+      if (FileSystem::Instance().Exists(local_file)) {
         if (log) {
           log->Printf("Found a copy of %s in the DeviceSupport dir %s",
                       platform_file_path, os_version_dir);
         }
         return error;
       }
 
       ::snprintf(resolved_path, sizeof(resolved_path), "%s/Symbols.Internal/%s",
                  os_version_dir, platform_file_path);
 
       local_file.SetFile(resolved_path, true, FileSpec::Style::native);
-      if (local_file.Exists()) {
+      if (FileSystem::Instance().Exists(local_file)) {
         if (log) {
           log->Printf(
               "Found a copy of %s in the DeviceSupport dir %s/Symbols.Internal",
               platform_file_path, os_version_dir);
         }
         return error;
       }
       ::snprintf(resolved_path, sizeof(resolved_path), "%s/Symbols/%s",
                  os_version_dir, platform_file_path);
 
       local_file.SetFile(resolved_path, true, FileSpec::Style::native);
-      if (local_file.Exists()) {
+      if (FileSystem::Instance().Exists(local_file)) {
         if (log) {
           log->Printf("Found a copy of %s in the DeviceSupport dir %s/Symbols",
                       platform_file_path, os_version_dir);
         }
         return error;
       }
     }
     local_file = platform_file;
-    if (local_file.Exists())
+    if (FileSystem::Instance().Exists(local_file))
       return error;
 
     error.SetErrorStringWithFormat(
         "unable to locate a platform file for '%s' in platform '%s'",
         platform_file_path, GetPluginName().GetCString());
   } else {
     error.SetErrorString("invalid platform file argument");
   }

source/Plugins/Platform/MacOSX/PlatformiOSSimulator.cpp

Status PlatformiOSSimulator::ResolveExecutable(
   //    if (!resolved_exe_file.Exists())
   //        resolved_exe_file.ResolveExecutableLocation ();
 
   // Resolve any executable within a bundle on MacOSX
   // TODO: verify that this handles shallow bundles, if not then implement one
   // ourselves
   Host::ResolveExecutableInBundle(resolved_module_spec.GetFileSpec());
 
-  if (resolved_module_spec.GetFileSpec().Exists()) {
+  if (FileSystem::Instance().Exists(resolved_module_spec.GetFileSpec())) {
     if (resolved_module_spec.GetArchitecture().IsValid()) {
       error = ModuleList::GetSharedModule(resolved_module_spec, exe_module_sp,
                                           NULL, NULL, NULL);
 
       if (exe_module_sp && exe_module_sp->GetObjectFile())
         return error;
       exe_module_sp.reset();
     }
if (platform_file.GetPath(platform_file_path, sizeof(platform_file_path))) {
 
     const char *sdk_dir = GetSDKDirectoryAsCString();
     if (sdk_dir) {
       ::snprintf(resolved_path, sizeof(resolved_path), "%s/%s", sdk_dir,
                  platform_file_path);
 
       // First try in the SDK and see if the file is in there
       local_file.SetFile(resolved_path, true, FileSpec::Style::native);
-      if (local_file.Exists())
+      if (FileSystem::Instance().Exists(local_file))
         return error;
 
       // Else fall back to the actual path itself
       local_file.SetFile(platform_file_path, true, FileSpec::Style::native);
-      if (local_file.Exists())
+      if (FileSystem::Instance().Exists(local_file))
         return error;
     }
     error.SetErrorStringWithFormat(
         "unable to locate a platform file for '%s' in platform '%s'",
         platform_file_path, GetPluginName().GetCString());
   } else {
     error.SetErrorString("invalid platform file argument");
   }

source/Plugins/Platform/POSIX/PlatformPOSIX.cpp

PlatformPOSIX::ResolveExecutable(const ModuleSpec &module_spec,
   // Nothing special to do here, just use the actual file and architecture
 
   char exe_path[PATH_MAX];
   ModuleSpec resolved_module_spec(module_spec);
 
   if (IsHost()) {
     // If we have "ls" as the exe_file, resolve the executable location based
     // on the current path variables
-    if (!resolved_module_spec.GetFileSpec().Exists()) {
+    if (!FileSystem::Instance().Exists(resolved_module_spec.GetFileSpec())) {
       resolved_module_spec.GetFileSpec().GetPath(exe_path, sizeof(exe_path));
       resolved_module_spec.GetFileSpec().SetFile(exe_path, true,
                                                  FileSpec::Style::native);
     }
 
-    if (!resolved_module_spec.GetFileSpec().Exists())
+    if (!FileSystem::Instance().Exists(resolved_module_spec.GetFileSpec()))
       FileSystem::Instance().ResolveFileLocation(
           resolved_module_spec.GetFileSpec());
 
     // Resolve any executable within a bundle on MacOSX
     Host::ResolveExecutableInBundle(resolved_module_spec.GetFileSpec());
 
-    if (resolved_module_spec.GetFileSpec().Exists())
+    if (FileSystem::Instance().Exists(resolved_module_spec.GetFileSpec()))
       error.Clear();
     else {
       const uint32_t permissions = FileSystem::Instance().GetPermissions(
           resolved_module_spec.GetFileSpec());
       if (permissions && (permissions & eFilePermissionsEveryoneR) == 0)
         error.SetErrorStringWithFormat(
             "executable '%s' is not readable",
             resolved_module_spec.GetFileSpec().GetPath().c_str());
if (m_remote_platform_sp) {
                               module_search_paths_ptr, *m_remote_platform_sp);
     } else {
       // We may connect to a process and use the provided executable (Don't use
       // local $PATH).
 
       // Resolve any executable within a bundle on MacOSX
       Host::ResolveExecutableInBundle(resolved_module_spec.GetFileSpec());
 
-      if (resolved_module_spec.GetFileSpec().Exists())
+      if (FileSystem::Instance().Exists(resolved_module_spec.GetFileSpec()))
         error.Clear();
       else
         error.SetErrorStringWithFormat("the platform is not currently "
                                        "connected, and '%s' doesn't exist in "
                                        "the system root.",
                                        exe_path);
     }
   }
Status PlatformPOSIX::CreateSymlink(const FileSpec &src, const FileSpec &dst) {
   else if (m_remote_platform_sp)
     return m_remote_platform_sp->CreateSymlink(src, dst);
   else
     return Platform::CreateSymlink(src, dst);
 }
 
 bool PlatformPOSIX::GetFileExists(const FileSpec &file_spec) {
   if (IsHost())
-    return file_spec.Exists();
+    return FileSystem::Instance().Exists(file_spec);
   else if (m_remote_platform_sp)
     return m_remote_platform_sp->GetFileExists(file_spec);
   else
     return Platform::GetFileExists(file_spec);
 }
 
 Status PlatformPOSIX::Unlink(const FileSpec &file_spec) {
   if (IsHost())

source/Plugins/Platform/Windows/PlatformWindows.cpp

Status PlatformWindows::ResolveExecutable(
   // Nothing special to do here, just use the actual file and architecture
 
   char exe_path[PATH_MAX];
   ModuleSpec resolved_module_spec(ms);
 
   if (IsHost()) {
     // if we cant resolve the executable loation based on the current path
     // variables
-    if (!resolved_module_spec.GetFileSpec().Exists()) {
+    if (!FileSystem::Instance().Exists(resolved_module_spec.GetFileSpec())) {
       resolved_module_spec.GetFileSpec().GetPath(exe_path, sizeof(exe_path));
       resolved_module_spec.GetFileSpec().SetFile(exe_path, true,
                                                  FileSpec::Style::native);
     }
 
-    if (!resolved_module_spec.GetFileSpec().Exists())
+    if (!FileSystem::Instance().Exists(resolved_module_spec.GetFileSpec()))
       FileSystem::Instance().ResolveFileLocation(
           resolved_module_spec.GetFileSpec());
 
-    if (resolved_module_spec.GetFileSpec().Exists())
+    if (FileSystem::Instance().Exists(resolved_module_spec.GetFileSpec()))
       error.Clear();
     else {
       ms.GetFileSpec().GetPath(exe_path, sizeof(exe_path));
       error.SetErrorStringWithFormat("unable to find executable for '%s'",
                                      exe_path);
     }
   } else {
     if (m_remote_platform_sp) {
       error = GetCachedExecutable(resolved_module_spec, exe_module_sp, nullptr,
                                   *m_remote_platform_sp);
     } else {
       // We may connect to a process and use the provided executable (Don't use
       // local $PATH).
-      if (resolved_module_spec.GetFileSpec().Exists())
+      if (FileSystem::Instance().Exists(resolved_module_spec.GetFileSpec()))
         error.Clear();
       else
         error.SetErrorStringWithFormat("the platform is not currently "
                                        "connected, and '%s' doesn't exist in "
                                        "the system root.",
                                        exe_path);
     }
   }

source/Plugins/Platform/gdb-server/PlatformRemoteGDBServer.cpp

Status PlatformRemoteGDBServer::ResolveExecutable(
   Status error;
   // Nothing special to do here, just use the actual file and architecture
 
   ModuleSpec resolved_module_spec(module_spec);
 
   // Resolve any executable within an apk on Android?
   // Host::ResolveExecutableInBundle (resolved_module_spec.GetFileSpec());
 
-  if (resolved_module_spec.GetFileSpec().Exists() ||
+  if (FileSystem::Instance().Exists(resolved_module_spec.GetFileSpec()) ||
       module_spec.GetUUID().IsValid()) {
     if (resolved_module_spec.GetArchitecture().IsValid() ||
         resolved_module_spec.GetUUID().IsValid()) {
       error = ModuleList::GetSharedModule(resolved_module_spec, exe_module_sp,
                                           module_search_paths_ptr, NULL, NULL);
 
       if (exe_module_sp && exe_module_sp->GetObjectFile())
         return error;

source/Plugins/Process/MacOSX-Kernel/ProcessKDP.cpp

if (reply_port != 0) {
               module_spec.GetArchitecture() = target.GetArchitecture();
 
               // Lookup UUID locally, before attempting dsymForUUID like action
               module_spec.GetSymbolFileSpec() =
                   Symbols::LocateExecutableSymbolFile(module_spec);
               if (module_spec.GetSymbolFileSpec()) {
                 ModuleSpec executable_module_spec =
                     Symbols::LocateExecutableObjectFile(module_spec);
-                if (executable_module_spec.GetFileSpec().Exists()) {
+                if (FileSystem::Instance().Exists(
+                        executable_module_spec.GetFileSpec())) {
                   module_spec.GetFileSpec() =
                       executable_module_spec.GetFileSpec();
                 }
               }
               if (!module_spec.GetSymbolFileSpec() ||
                   !module_spec.GetSymbolFileSpec())
                 Symbols::DownloadObjectAndSymbolFile(module_spec, true);
 
-              if (module_spec.GetFileSpec().Exists()) {
+              if (FileSystem::Instance().Exists(module_spec.GetFileSpec())) {
                 ModuleSP module_sp(new Module(module_spec));
                 if (module_sp.get() && module_sp->GetObjectFile()) {
                   // Get the current target executable
                   ModuleSP exe_module_sp(target.GetExecutableModule());
 
                   // Make sure you don't already have the right module loaded
                   // and they will be uniqued
                   if (exe_module_sp.get() != module_sp.get())

source/Plugins/Process/elf-core/ProcessElfCore.cpp

if (crash_file) {
     }
   }
   return process_sp;
 }
 
 bool ProcessElfCore::CanDebug(lldb::TargetSP target_sp,
                               bool plugin_specified_by_name) {
   // For now we are just making sure the file exists for a given module
-  if (!m_core_module_sp && m_core_file.Exists()) {
+  if (!m_core_module_sp && FileSystem::Instance().Exists(m_core_file)) {
     ModuleSpec core_module_spec(m_core_file, target_sp->GetArchitecture());
     Status error(ModuleList::GetSharedModule(core_module_spec, m_core_module_sp,
                                              NULL, NULL, NULL));
     if (m_core_module_sp) {
       ObjectFile *core_objfile = m_core_module_sp->GetObjectFile();
       if (core_objfile && core_objfile->GetType() == ObjectFile::eTypeCoreFile)
         return true;
     }

source/Plugins/Process/gdb-remote/GDBRemoteCommunication.cpp

 #include <limits.h>
 #include <string.h>
 #include <sys/stat.h>
 
 // C++ Includes
 // Other libraries and framework includes
 #include "lldb/Core/StreamFile.h"
 #include "lldb/Host/ConnectionFileDescriptor.h"
+#include "lldb/Host/FileSystem.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Host/HostInfo.h"
 #include "lldb/Host/Pipe.h"
 #include "lldb/Host/Socket.h"
 #include "lldb/Host/StringConvert.h"
 #include "lldb/Host/ThreadLauncher.h"
 #include "lldb/Target/Platform.h"
 #include "lldb/Target/Process.h"
if (env_debugserver_path) {
     debugserver_file_spec.SetFile(env_debugserver_path, false,
                                   FileSpec::Style::native);
     if (log)
       log->Printf("GDBRemoteCommunication::%s() gdb-remote stub exe path set "
                   "from environment variable: %s",
                   __FUNCTION__, env_debugserver_path);
   } else
     debugserver_file_spec = g_debugserver_file_spec;
-  bool debugserver_exists = debugserver_file_spec.Exists();
+  bool debugserver_exists =
+      FileSystem::Instance().Exists(debugserver_file_spec);
   if (!debugserver_exists) {
     // The debugserver binary is in the LLDB.framework/Resources directory.
     debugserver_file_spec = HostInfo::GetSupportExeDir();
     if (debugserver_file_spec) {
       debugserver_file_spec.AppendPathComponent(DEBUGSERVER_BASENAME);
-      debugserver_exists = debugserver_file_spec.Exists();
+      debugserver_exists = FileSystem::Instance().Exists(debugserver_file_spec);
       if (debugserver_exists) {
         if (log)
           log->Printf(
               "GDBRemoteCommunication::%s() found gdb-remote stub exe '%s'",
               __FUNCTION__, debugserver_file_spec.GetPath().c_str());
 
         g_debugserver_file_spec = debugserver_file_spec;
       } else {

source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp

 FileSpec
 GDBRemoteCommunicationServerLLGS::FindModuleFile(const std::string &module_path,
                                                  const ArchSpec &arch) {
   if (m_debugged_process_up) {
     FileSpec file_spec;
     if (m_debugged_process_up
             ->GetLoadedModuleFileSpec(module_path.c_str(), file_spec)
             .Success()) {
-      if (file_spec.Exists())
+      if (FileSystem::Instance().Exists(file_spec))
         return file_spec;
     }
   }
 
   return GDBRemoteCommunicationServerCommon::FindModuleFile(module_path, arch);
 }

source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp

if (exe_module) {
     case ObjectFile::eTypeStubLibrary:
     case ObjectFile::eTypeJIT:
       return false;
     case ObjectFile::eTypeExecutable:
     case ObjectFile::eTypeDynamicLinker:
     case ObjectFile::eTypeUnknown:
       break;
     }
-    return exe_module->GetFileSpec().Exists();
+    return FileSystem::Instance().Exists(exe_module->GetFileSpec());
   }
   // However, if there is no executable module, we return true since we might
   // be preparing to attach.
   return true;
 }
 
 //----------------------------------------------------------------------
 // ProcessGDBRemote constructor
void ProcessGDBRemote::BuildDynamicRegisterInfo(bool force) {
   // Register info search order:
   //     1 - Use the target definition python file if one is specified.
   //     2 - If the target definition doesn't have any of the info from the
   //     target.xml (registers) then proceed to read the target.xml.
   //     3 - Fall back on the qRegisterInfo packets.
 
   FileSpec target_definition_fspec =
       GetGlobalPluginProperties()->GetTargetDefinitionFile();
-  if (!target_definition_fspec.Exists()) {
+  if (!FileSystem::Instance().Exists(target_definition_fspec)) {
     // If the filename doesn't exist, it may be a ~ not having been expanded -
     // try to resolve it.
     target_definition_fspec.ResolvePath();
   }
   if (target_definition_fspec) {
     // See if we can get register definitions from a python file
     if (ParsePythonTargetDefinition(target_definition_fspec)) {
       return;

source/Plugins/Process/mach-core/ProcessMachCore.cpp

 }
 
 bool ProcessMachCore::CanDebug(lldb::TargetSP target_sp,
                                bool plugin_specified_by_name) {
   if (plugin_specified_by_name)
     return true;
 
   // For now we are just making sure the file exists for a given module
-  if (!m_core_module_sp && m_core_file.Exists()) {
+  if (!m_core_module_sp && FileSystem::Instance().Exists(m_core_file)) {
     // Don't add the Target's architecture to the ModuleSpec - we may be
     // working with a core file that doesn't have the correct cpusubtype in the
     // header but we should still try to use it -
     // ModuleSpecList::FindMatchingModuleSpec enforces a strict arch mach.
     ModuleSpec core_module_spec(m_core_file);
     Status error(ModuleList::GetSharedModule(core_module_spec, m_core_module_sp,
                                              NULL, NULL, NULL));
 

source/Plugins/ScriptInterpreter/Python/ScriptInterpreterPython.cpp

if (depth_as_int <= lldb::kLastSearchDepthKind)
     return (lldb::SearchDepth) depth_as_int;
   else
     return lldb::eSearchDepthModule;
 }
 
 StructuredData::ObjectSP
 ScriptInterpreterPython::LoadPluginModule(const FileSpec &file_spec,
                                           lldb_private::Status &error) {
-  if (!file_spec.Exists()) {
+  if (!FileSystem::Instance().Exists(file_spec)) {
     error.SetErrorString("no such file");
     return StructuredData::ObjectSP();
   }
 
   StructuredData::ObjectSP module_sp;
 
   if (LoadScriptingModule(file_spec.GetPath().c_str(), true, true, error,
                           &module_sp))

source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

const char *comp_dir = cu_die.GetAttributeValueAsString(
         this, &dwarf_cu, DW_AT_comp_dir, nullptr);
     if (!comp_dir)
       return nullptr;
 
     dwo_file.SetFile(comp_dir, true, FileSpec::Style::native);
     dwo_file.AppendPathComponent(dwo_name);
   }
 
-  if (!dwo_file.Exists())
+  if (!FileSystem::Instance().Exists(dwo_file))
     return nullptr;
 
   const lldb::offset_t file_offset = 0;
   DataBufferSP dwo_file_data_sp;
   lldb::offset_t dwo_file_data_offset = 0;
   ObjectFileSP dwo_obj_file = ObjectFile::FindPlugin(
       GetObjectFile()->GetModule(), &dwo_file, file_offset,
       FileSystem::Instance().GetByteSize(dwo_file), dwo_file_data_sp,

 
 SymbolFileDWARFDwp *SymbolFileDWARF::GetDwpSymbolFile() {
   llvm::call_once(m_dwp_symfile_once_flag, [this]() {
     ModuleSpec module_spec;
     module_spec.GetFileSpec() = m_obj_file->GetFileSpec();
     module_spec.GetSymbolFileSpec() =
         FileSpec(m_obj_file->GetFileSpec().GetPath() + ".dwp", false);
     FileSpec dwp_filespec = Symbols::LocateExecutableSymbolFile(module_spec);
-    if (dwp_filespec.Exists()) {
+    if (FileSystem::Instance().Exists(dwp_filespec)) {
       m_dwp_symfile = SymbolFileDWARFDwp::Create(GetObjectFile()->GetModule(),
                                                  dwp_filespec);
     }
   });
   return m_dwp_symfile.get();
 }

source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDebugMap.cpp

if (!comp_unit_info->oso_sp) {
     } else {
       ObjectFile *obj_file = GetObjectFile();
       comp_unit_info->oso_sp.reset(new OSOInfo());
       m_oso_map[{comp_unit_info->oso_path, comp_unit_info->oso_mod_time}] =
           comp_unit_info->oso_sp;
       const char *oso_path = comp_unit_info->oso_path.GetCString();
       FileSpec oso_file(oso_path, false);
       ConstString oso_object;
-      if (oso_file.Exists()) {
+      if (FileSystem::Instance().Exists(oso_file)) {
         auto oso_mod_time = FileSystem::Instance().GetModificationTime(oso_file);
         if (oso_mod_time != comp_unit_info->oso_mod_time) {
           obj_file->GetModule()->ReportError(
               "debug map object file '%s' has changed (actual time is "
               "%s, debug map time is %s"
               ") since this executable was linked, file will be ignored",
               oso_file.GetPath().c_str(), llvm::to_string(oso_mod_time).c_str(),
               llvm::to_string(comp_unit_info->oso_mod_time).c_str());

source/Plugins/SymbolVendor/MacOSX/SymbolVendorMacOSX.cpp

if (dsym_fspec) {
               if (!uuid_str.empty()) {
                 char *resources = strstr(dsym_path, "/Contents/Resources/");
                 if (resources) {
                   char dsym_uuid_plist_path[PATH_MAX];
                   resources[strlen("/Contents/Resources/")] = '\0';
                   snprintf(dsym_uuid_plist_path, sizeof(dsym_uuid_plist_path),
                            "%s%s.plist", dsym_path, uuid_str.c_str());
                   FileSpec dsym_uuid_plist_spec(dsym_uuid_plist_path, false);
-                  if (dsym_uuid_plist_spec.Exists()) {
+                  if (FileSystem::Instance().Exists(dsym_uuid_plist_spec)) {
                     ApplePropertyList plist(dsym_uuid_plist_path);
                     if (plist) {
                       std::string DBGBuildSourcePath;
                       std::string DBGSourcePath;
 
                       // DBGSourcePathRemapping is a dictionary in the plist
                       // with keys which are DBGBuildSourcePath file paths and
                       // values which are DBGSourcePath file paths

source/Symbol/ObjectFile.cpp

Timer scoped_timer(
         "0x%8.8" PRIx64 ", file_size = 0x%8.8" PRIx64 ")",
         module_sp->GetFileSpec().GetPath().c_str(),
         static_cast<const void *>(file), static_cast<uint64_t>(file_offset),
         static_cast<uint64_t>(file_size));
     if (file) {
       FileSpec archive_file;
       ObjectContainerCreateInstance create_object_container_callback;
 
-      const bool file_exists = file->Exists();
+      const bool file_exists = FileSystem::Instance().Exists(*file);
       if (!data_sp) {
         // We have an object name which most likely means we have a .o file in
         // a static archive (.a file). Try and see if we have a cached archive
         // first without reading any data first
         if (file_exists && module_sp->GetObjectName()) {
           for (uint32_t idx = 0;
                (create_object_container_callback =
                     PluginManager::GetObjectContainerCreateCallbackAtIndex(
bool ObjectFile::SplitArchivePathWithObject(const char *path_with_object,
   if (g_object_regex.Execute(llvm::StringRef::withNullAsEmpty(path_with_object),
                              &regex_match)) {
     std::string path;
     std::string obj;
     if (regex_match.GetMatchAtIndex(path_with_object, 1, path) &&
         regex_match.GetMatchAtIndex(path_with_object, 2, obj)) {
       archive_file.SetFile(path, false, FileSpec::Style::native);
       archive_object.SetCString(obj.c_str());
-      if (must_exist && !archive_file.Exists())
+      if (must_exist && !FileSystem::Instance().Exists(archive_file))
         return false;
       return true;
     }
   }
   return false;
 }
 
 void ObjectFile::ClearSymtab() {

source/Target/ModuleCache.cpp

 Status CreateHostSysRootModuleLink(const FileSpec &root_dir_spec,
                                    const char *hostname,
                                    const FileSpec &platform_module_spec,
                                    const FileSpec &local_module_spec,
                                    bool delete_existing) {
   const auto sysroot_module_path_spec =
       JoinPath(JoinPath(root_dir_spec, hostname),
                platform_module_spec.GetPath().c_str());
-  if (sysroot_module_path_spec.Exists()) {
+  if (FileSystem::Instance().Exists(sysroot_module_path_spec)) {
     if (!delete_existing)
       return Status();
 
     DecrementRefExistingModule(root_dir_spec, sysroot_module_path_spec);
   }
 
   const auto error = MakeDirectory(
       FileSpec(sysroot_module_path_spec.GetDirectory().AsCString(), false));
if (find_it != m_loaded_modules.end()) {
     m_loaded_modules.erase(find_it);
   }
 
   const auto module_spec_dir =
       GetModuleDirectory(root_dir_spec, module_spec.GetUUID());
   const auto module_file_path = JoinPath(
       module_spec_dir, module_spec.GetFileSpec().GetFilename().AsCString());
 
-  if (!module_file_path.Exists())
+  if (!FileSystem::Instance().Exists(module_file_path))
     return Status("Module %s not found", module_file_path.GetPath().c_str());
   if (FileSystem::Instance().GetByteSize(module_file_path) !=
       module_spec.GetObjectSize())
     return Status("Module %s has invalid file size",
                   module_file_path.GetPath().c_str());
 
   // We may have already cached module but downloaded from an another host - in
   // this case let's create a link to it.
Status ModuleCache::Get(const FileSpec &root_dir_spec, const char *hostname,
   cached_module_spec.GetPlatformFileSpec() = module_spec.GetFileSpec();
 
   error = ModuleList::GetSharedModule(cached_module_spec, cached_module_sp,
                                       nullptr, nullptr, did_create_ptr, false);
   if (error.Fail())
     return error;
 
   FileSpec symfile_spec = GetSymbolFileSpec(cached_module_sp->GetFileSpec());
-  if (symfile_spec.Exists())
+  if (FileSystem::Instance().Exists(symfile_spec))
     cached_module_sp->SetSymbolFileFileSpec(symfile_spec);
 
   m_loaded_modules.insert(
       std::make_pair(module_spec.GetUUID().GetAsString(), cached_module_sp));
 
   return Status();
 }
 

source/Target/PathMappingList.cpp

 //===-- PathMappingList.cpp -------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // C Includes
 // C++ Includes
 #include <climits>
 #include <cstring>
 
 // Other libraries and framework includes
 // Project includes
-#include "lldb/lldb-private-enumerations.h"
+#include "lldb/Host/FileSystem.h"
 #include "lldb/Host/PosixApi.h"
 #include "lldb/Target/PathMappingList.h"
 #include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/Stream.h"
+#include "lldb/lldb-private-enumerations.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 namespace {
   // We must normalize our path pairs that we store because if we don't then
   // things won't always work. We found a case where if we did:
   // (lldb) settings set target.source-map . /tmp
if (orig_path_len > 0) {
       for (pos = m_pairs.begin(); pos != end; ++pos) {
         const size_t prefix_len = pos->first.GetLength();
 
         if (orig_path_len >= prefix_len) {
           if (::strncmp(pos->first.GetCString(), orig_path, prefix_len) == 0) {
             new_spec.SetFile(pos->second.GetCString(), false,
                              FileSpec::Style::native);
             new_spec.AppendPathComponent(orig_path + prefix_len);
-            if (new_spec.Exists())
+            if (FileSystem::Instance().Exists(new_spec))
               return true;
           }
         }
       }
     }
   }
   new_spec.Clear();
   return false;

source/Target/Platform.cpp

bool Platform::SetOSVersion(llvm::VersionTuple version) {
   return false;
 }
 
 Status
 Platform::ResolveExecutable(const ModuleSpec &module_spec,
                             lldb::ModuleSP &exe_module_sp,
                             const FileSpecList *module_search_paths_ptr) {
   Status error;
-  if (module_spec.GetFileSpec().Exists()) {
+  if (FileSystem::Instance().Exists(module_spec.GetFileSpec())) {
     if (module_spec.GetArchitecture().IsValid()) {
       error = ModuleList::GetSharedModule(module_spec, exe_module_sp,
                                           module_search_paths_ptr, nullptr,
                                           nullptr);
     } else {
       // No valid architecture was specified, ask the platform for the
       // architectures that we should be using (in the correct order) and see
       // if we can find a match that way
error.SetErrorStringWithFormat("'%s' does not exist",
                                    module_spec.GetFileSpec().GetPath().c_str());
   }
   return error;
 }
 
 Status Platform::ResolveSymbolFile(Target &target, const ModuleSpec &sym_spec,
                                    FileSpec &sym_file) {
   Status error;
-  if (sym_spec.GetSymbolFileSpec().Exists())
+  if (FileSystem::Instance().Exists(sym_spec.GetSymbolFileSpec()))
     sym_file = sym_spec.GetSymbolFileSpec();
   else
     error.SetErrorString("unable to resolve symbol file");
   return error;
 }
 
 bool Platform::ResolveRemotePath(const FileSpec &platform_path,
                                  FileSpec &resolved_platform_path) {

source/Target/Process.cpp

Status Process::Launch(ProcessLaunchInfo &launch_info) {
   Module *exe_module = GetTarget().GetExecutableModulePointer();
   if (exe_module) {
     char local_exec_file_path[PATH_MAX];
     char platform_exec_file_path[PATH_MAX];
     exe_module->GetFileSpec().GetPath(local_exec_file_path,
                                       sizeof(local_exec_file_path));
     exe_module->GetPlatformFileSpec().GetPath(platform_exec_file_path,
                                               sizeof(platform_exec_file_path));
-    if (exe_module->GetFileSpec().Exists()) {
+    if (FileSystem::Instance().Exists(exe_module->GetFileSpec())) {
       // Install anything that might need to be installed prior to launching.
       // For host systems, this will do nothing, but if we are connected to a
       // remote platform it will install any needed binaries
       error = GetTarget().Install(&launch_info);
       if (error.Fail())
         return error;
 
       if (PrivateStateThreadIsValid())

source/Target/TargetList.cpp

Status TargetList::CreateTargetInternal(Debugger &debugger,
 
   if (!platform_sp)
     platform_sp = debugger.GetPlatformList().GetSelectedPlatform();
 
   if (!arch.IsValid())
     arch = specified_arch;
 
   FileSpec file(user_exe_path, false);
-  if (!file.Exists() && user_exe_path.startswith("~")) {
+  if (!FileSystem::Instance().Exists(file) && user_exe_path.startswith("~")) {
     // we want to expand the tilde but we don't want to resolve any symbolic
     // links so we can't use the FileSpec constructor's resolve flag
     llvm::SmallString<64> unglobbed_path;
     StandardTildeExpressionResolver Resolver;
     Resolver.ResolveFullPath(user_exe_path, unglobbed_path);
 
     if (unglobbed_path.empty())
       file = FileSpec(user_exe_path, false);
     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 (llvm::sys::fs::is_directory(file.GetPath()))
       user_exe_path_is_bundle = true;
 
     if (file.IsRelative() && !user_exe_path.empty()) {
       llvm::SmallString<64> cwd;
       if (! llvm::sys::fs::current_path(cwd)) {
         FileSpec cwd_file(cwd.c_str(), false);
         cwd_file.AppendPathComponent(file);
-        if (cwd_file.Exists())
+        if (FileSystem::Instance().Exists(cwd_file))
           file = cwd_file;
       }
     }
 
     ModuleSP exe_module_sp;
     if (platform_sp) {
       FileSpecList executable_search_paths(
           Target::GetDefaultExecutableSearchPaths());

source/Utility/FileSpec.cpp

if (s) {
     std::string path{GetPath(true)};
     s->PutCString(path);
     char path_separator = GetPreferredPathSeparator(m_style);
     if (!m_filename && !path.empty() && path.back() != path_separator)
       s->PutChar(path_separator);
   }
 }
 
-//------------------------------------------------------------------
-// Returns true if the file exists.
-//------------------------------------------------------------------
-bool FileSpec::Exists() const { return llvm::sys::fs::exists(GetPath()); }
-
 bool FileSpec::ResolvePath() {
   if (m_is_resolved)
     return true; // We have already resolved this path
 
   // SetFile(...) will set m_is_resolved correctly if it can resolve the path
   SetFile(GetPath(false), true);
   return m_is_resolved;
 }

source/Utility/StructuredData.cpp

 //----------------------------------------------------------------------
 static StructuredData::ObjectSP ParseJSONValue(JSONParser &json_parser);
 static StructuredData::ObjectSP ParseJSONObject(JSONParser &json_parser);
 static StructuredData::ObjectSP ParseJSONArray(JSONParser &json_parser);
 
 StructuredData::ObjectSP
 StructuredData::ParseJSONFromFile(const FileSpec &input_spec, Status &error) {
   StructuredData::ObjectSP return_sp;
-  if (!input_spec.Exists()) {
-    error.SetErrorStringWithFormatv("input file {0} does not exist.",
-                                    input_spec);
-    return return_sp;
-  }
 
   auto buffer_or_error = llvm::MemoryBuffer::getFile(input_spec.GetPath());
   if (!buffer_or_error) {
     error.SetErrorStringWithFormatv("could not open input file: {0} - {1}.",
                                     input_spec.GetPath(),
                                     buffer_or_error.getError().message());
     return return_sp;
   }

unittests/Target/ModuleCacheTest.cpp

 
 void ModuleCacheTest::TearDownTestCase() {
   ObjectFileELF::Terminate();
   HostInfo::Terminate();
 }
 
 static void VerifyDiskState(const FileSpec &cache_dir, const char *hostname) {
   FileSpec uuid_view = GetUuidView(cache_dir);
-  EXPECT_TRUE(uuid_view.Exists()) << "uuid_view is: " << uuid_view.GetCString();
+  EXPECT_TRUE(FileSystem::Instance().Exists(uuid_view))
+      << "uuid_view is: " << uuid_view.GetCString();
   EXPECT_EQ(module_size, FileSystem::Instance().GetByteSize(uuid_view));
 
   FileSpec sysroot_view = GetSysrootView(cache_dir, hostname);
-  EXPECT_TRUE(sysroot_view.Exists()) << "sysroot_view is: "
-                                     << sysroot_view.GetCString();
+  EXPECT_TRUE(FileSystem::Instance().Exists(sysroot_view))
+      << "sysroot_view is: " << sysroot_view.GetCString();
   EXPECT_EQ(module_size, FileSystem::Instance().GetByteSize(sysroot_view));
 }
 
 void ModuleCacheTest::TryGetAndPut(const FileSpec &cache_dir,
                                    const char *hostname, bool expect_download) {
   ModuleCache mc;
   ModuleSpec module_spec;
   module_spec.GetFileSpec() = GetDummyRemotePath();