[FileSystem] Move resolve logic out of FileSpec

[JDevlieghere]

Summary

This patch removes the logic for resolving paths out of FileSpec and updates call sites to rely on the FileSystem class instead.

[aleksandr.urakov]

This commit breaks the Windows build.

[aleksandr.urakov]

It's ok, I was able to fix it myself. Here is the commit: r345956

[stella.stamenova]

Some of the file spec changes caused a bunch of failures on Windows. We know have a silent Buildbot that you can see the failures on as well:

http://lab.llvm.org:8014/builders/lldb-x64-windows-ninja/builds/1128/steps/test/logs/stdio

Let me know if you need anything else. Once all the tests are green again we're going to make the Buildbot no longer silent, so this should be easier to catch.

include/lldb/Target/Process.h

public:
   ProcessInstanceInfoMatch()
       : m_match_info(), m_name_match_type(NameMatch::Ignore),
         m_match_all_users(false) {}
 
   ProcessInstanceInfoMatch(const char *process_name,
                            NameMatch process_name_match_type)
       : m_match_info(), m_name_match_type(process_name_match_type),
         m_match_all_users(false) {
-    m_match_info.GetExecutableFile().SetFile(process_name, false,
+    m_match_info.GetExecutableFile().SetFile(process_name,
                                              FileSpec::Style::native);
   }
 
   ProcessInstanceInfo &GetProcessInfo() { return m_match_info; }
 
   const ProcessInstanceInfo &GetProcessInfo() const { return m_match_info; }
 
   bool GetMatchAllUsers() const { return m_match_all_users; }

include/lldb/Utility/FileSpec.h

public:
 
   FileSpec();
 
   //------------------------------------------------------------------
   /// Constructor with path.
   ///
   /// Takes a path to a file which can be just a filename, or a full path. If
   /// \a path is not nullptr or empty, this function will call
-  /// FileSpec::SetFile (const char *path, bool resolve).
+  /// FileSpec::SetFile (const char *path).
   ///
   /// @param[in] path
   ///     The full or partial path to a file.
   ///
-  /// @param[in] resolve_path
-  ///     If \b true, then we resolve the path, removing stray ../.. and so
-  ///     forth,
-  ///     if \b false we trust the path is in canonical form already.
+  /// @param[in] style
+  ///     The style of the path
   ///
-  /// @see FileSpec::SetFile (const char *path, bool resolve)
+  /// @see FileSpec::SetFile (const char *path)
   //------------------------------------------------------------------
-  explicit FileSpec(llvm::StringRef path, bool resolve_path,
-                    Style style = Style::native);
+  explicit FileSpec(llvm::StringRef path, Style style = Style::native);
 
-  explicit FileSpec(llvm::StringRef path, bool resolve_path,
-                    const llvm::Triple &Triple);
+  explicit FileSpec(llvm::StringRef path, const llvm::Triple &Triple);
 
   //------------------------------------------------------------------
   /// Copy constructor
   ///
   /// Makes a copy of the uniqued directory and filename strings from \a rhs.
   ///
   /// @param[in] rhs
   ///     A const FileSpec object reference to copy.
public:
   /// valid directory name, it will be displayed followed by a directory
   /// delimiter, and the filename.
   ///
   /// @param[in] s
   ///     The stream to which to dump the object description.
   //------------------------------------------------------------------
   void Dump(Stream *s) 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;
 
   //------------------------------------------------------------------
   /// Directory string get accessor.
   ///
   /// @return
   ///     A reference to the directory string object.
   //------------------------------------------------------------------
public:
   ///
   /// @return
   ///     \b true if the filespec represents an absolute path,
   ///     \b false otherwise.
   //------------------------------------------------------------------
   bool IsAbsolute() const;
 
   /// Temporary helper for FileSystem change.
-  void SetPath(llvm::StringRef p) { SetFile(p, false); }
+  void SetPath(llvm::StringRef p) { SetFile(p); }
 
   //------------------------------------------------------------------
   /// Extract the full path to the file.
   ///
   /// Extract the directory and path into a fixed buffer. This is needed as
   /// the directory and path are stored in separate string values.
   ///
   /// @param[out] path
public:
   ///
   /// @param[in] path
   ///     A full, partial, or relative path to a file.
   ///
   /// @param[in] resolve_path
   ///     If \b true, then we will try to resolve links the path using
   ///     the static FileSpec::Resolve.
   //------------------------------------------------------------------
-  void SetFile(llvm::StringRef path, bool resolve_path, Style style);
+  void SetFile(llvm::StringRef path, Style style);
 
-  void SetFile(llvm::StringRef path, bool resolve_path,
-               const llvm::Triple &Triple);
+  void SetFile(llvm::StringRef path, const llvm::Triple &Triple);
 
   bool IsResolved() const { return m_is_resolved; }
 
   //------------------------------------------------------------------
   /// Set if the file path has been resolved or not.
   ///
   /// If you know a file path is already resolved and avoided passing a \b
   /// true parameter for any functions that take a "bool resolve_path"
   /// parameter, you can set the value manually using this call to make sure
   /// we don't try and resolve it later, or try and resolve a path that has
   /// already been resolved.
   ///
   /// @param[in] is_resolved
   ///     A boolean value that will replace the current value that
   ///     indicates if the paths in this object have been resolved.
   //------------------------------------------------------------------
   void SetIsResolved(bool is_resolved) { m_is_resolved = is_resolved; }
 
-  //------------------------------------------------------------------
-  /// Resolves user name and links in \a path, and overwrites the input
-  /// argument with the resolved path.
-  ///
-  /// @param[in] path
-  ///     Input path to be resolved, in the form of a llvm::SmallString or
-  ///     similar.
-  //------------------------------------------------------------------
-  static void Resolve(llvm::SmallVectorImpl<char> &path);
-
   FileSpec CopyByAppendingPathComponent(llvm::StringRef component) const;
   FileSpec CopyByRemovingLastPathComponent() const;
 
   void PrependPathComponent(llvm::StringRef component);
   void PrependPathComponent(const FileSpec &new_path);
 
   void AppendPathComponent(llvm::StringRef component);
   void AppendPathComponent(const FileSpec &new_path);
 
   //------------------------------------------------------------------
   /// Removes the last path component by replacing the current path with its
   /// parent. When the current path has no parent, this is a no-op.
   ///
   /// @return
   ///     A boolean value indicating whether the path was updated.
   //------------------------------------------------------------------
   bool RemoveLastPathComponent();
 
   ConstString GetLastPathComponent() const;
 
 protected:
   //------------------------------------------------------------------
   // Convenience method for setting the file without changing the style.
   //------------------------------------------------------------------
-  void SetFile(llvm::StringRef path, bool resolve_path);
+  void SetFile(llvm::StringRef path);
 
   //------------------------------------------------------------------
   // Member variables
   //------------------------------------------------------------------
   ConstString m_directory;            ///< The uniqued directory path
   ConstString m_filename;             ///< The uniqued filename path
   mutable bool m_is_resolved = false; ///< True if this path has been resolved.
   Style m_style; ///< The syntax that this path uses (e.g. Windows / Posix)

source/API/SBAttachInfo.cpp

 SBAttachInfo::SBAttachInfo(lldb::pid_t pid)
     : m_opaque_sp(new ProcessAttachInfo()) {
   m_opaque_sp->SetProcessID(pid);
 }
 
 SBAttachInfo::SBAttachInfo(const char *path, bool wait_for)
     : m_opaque_sp(new ProcessAttachInfo()) {
   if (path && path[0])
-    m_opaque_sp->GetExecutableFile().SetFile(path, false,
-                                             FileSpec::Style::native);
+    m_opaque_sp->GetExecutableFile().SetFile(path, FileSpec::Style::native);
   m_opaque_sp->SetWaitForLaunch(wait_for);
 }
 
 SBAttachInfo::SBAttachInfo(const char *path, bool wait_for, bool async)
     : m_opaque_sp(new ProcessAttachInfo()) {
   if (path && path[0])
-    m_opaque_sp->GetExecutableFile().SetFile(path, false,
-                                             FileSpec::Style::native);
+    m_opaque_sp->GetExecutableFile().SetFile(path, FileSpec::Style::native);
   m_opaque_sp->SetWaitForLaunch(wait_for);
   m_opaque_sp->SetAsync(async);
 }
 
 SBAttachInfo::SBAttachInfo(const SBAttachInfo &rhs)
     : m_opaque_sp(new ProcessAttachInfo()) {
   *m_opaque_sp = *rhs.m_opaque_sp;
 }

 }
 
 void SBAttachInfo::SetProcessPluginName(const char *plugin_name) {
   return m_opaque_sp->SetProcessPluginName(plugin_name);
 }
 
 void SBAttachInfo::SetExecutable(const char *path) {
   if (path && path[0])
-    m_opaque_sp->GetExecutableFile().SetFile(path, false,
-                                             FileSpec::Style::native);
+    m_opaque_sp->GetExecutableFile().SetFile(path, FileSpec::Style::native);
   else
     m_opaque_sp->GetExecutableFile().Clear();
 }
 
 void SBAttachInfo::SetExecutable(SBFileSpec exe_file) {
   if (exe_file.IsValid())
     m_opaque_sp->GetExecutableFile() = exe_file.ref();
   else

source/API/SBDebugger.cpp

SBTarget SBDebugger::FindTargetWithFileAndArch(const char *filename,
                                                const char *arch_name) {
   SBTarget sb_target;
   if (m_opaque_sp && filename && filename[0]) {
     // No need to lock, the target list is thread safe
     ArchSpec arch = Platform::GetAugmentedArchSpec(
         m_opaque_sp->GetPlatformList().GetSelectedPlatform().get(), arch_name);
     TargetSP target_sp(
         m_opaque_sp->GetTargetList().FindTargetWithExecutableAndArchitecture(
-            FileSpec(filename, false), arch_name ? &arch : nullptr));
+            FileSpec(filename), arch_name ? &arch : nullptr));
     sb_target.SetSP(target_sp);
   }
   return sb_target;
 }
 
 SBTarget SBDebugger::FindTargetWithLLDBProcess(const ProcessSP &process_sp) {
   SBTarget sb_target;
   if (m_opaque_sp) {

source/API/SBFileSpec.cpp

 
 SBFileSpec::SBFileSpec(const SBFileSpec &rhs)
     : m_opaque_ap(new lldb_private::FileSpec(*rhs.m_opaque_ap)) {}
 
 SBFileSpec::SBFileSpec(const lldb_private::FileSpec &fspec)
     : m_opaque_ap(new lldb_private::FileSpec(fspec)) {}
 
 // Deprecated!!!
-SBFileSpec::SBFileSpec(const char *path)
-    : m_opaque_ap(new FileSpec(path, true)) {}
+SBFileSpec::SBFileSpec(const char *path) : m_opaque_ap(new FileSpec(path)) {
+  FileSystem::Instance().Resolve(*m_opaque_ap);
+}
 
 SBFileSpec::SBFileSpec(const char *path, bool resolve)
-    : m_opaque_ap(new FileSpec(path, resolve)) {}
+    : m_opaque_ap(new FileSpec(path)) {
+  if (resolve)
+    FileSystem::Instance().Resolve(*m_opaque_ap);
+}
 
 SBFileSpec::~SBFileSpec() {}
 
 const SBFileSpec &SBFileSpec::operator=(const SBFileSpec &rhs) {
   if (this != &rhs)
     *m_opaque_ap = *rhs.m_opaque_ap;
   return *this;
 }

 
 bool SBFileSpec::ResolveExecutableLocation() {
   return FileSystem::Instance().ResolveFileLocation(*m_opaque_ap);
 }
 
 int SBFileSpec::ResolvePath(const char *src_path, char *dst_path,
                             size_t dst_len) {
   llvm::SmallString<64> result(src_path);
-  lldb_private::FileSpec::Resolve(result);
+  FileSystem::Instance().Resolve(result);
   ::snprintf(dst_path, dst_len, "%s", result.c_str());
   return std::min(dst_len - 1, result.size());
 }
 
 const char *SBFileSpec::GetFilename() const {
   const char *s = m_opaque_ap->GetFilename().AsCString();
 
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));

source/API/SBHostOS.cpp

 //===-- SBHostOS.cpp --------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_DISABLE_PYTHON
 #include "Plugins/ScriptInterpreter/Python/lldb-python.h"
 #endif
 
-#include "lldb/API/SBHostOS.h"
 #include "lldb/API/SBError.h"
+#include "lldb/API/SBHostOS.h"
+#include "lldb/Host/FileSystem.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Host/HostInfo.h"
 #include "lldb/Host/HostNativeThread.h"
 #include "lldb/Host/HostThread.h"
 #include "lldb/Host/ThreadLauncher.h"
 #include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/Log.h"
 
#endif
   return sb_fspec;
 }
 
 SBFileSpec SBHostOS::GetUserHomeDirectory() {
   SBFileSpec sb_fspec;
 
   llvm::SmallString<64> home_dir_path;
   llvm::sys::path::home_directory(home_dir_path);
-  FileSpec homedir(home_dir_path.c_str(), true);
+  FileSpec homedir(home_dir_path.c_str());
+  FileSystem::Instance().Resolve(homedir);
 
   sb_fspec.SetFileSpec(homedir);
   return sb_fspec;
 }
 
 lldb::thread_t SBHostOS::ThreadCreate(const char *name,
                                       lldb::thread_func_t thread_function,
                                       void *thread_arg, SBError *error_ptr) {

source/API/SBLaunchInfo.cpp

 
 void SBLaunchInfo::Clear() { m_opaque_sp->Clear(); }
 
 const char *SBLaunchInfo::GetWorkingDirectory() const {
   return m_opaque_sp->GetWorkingDirectory().GetCString();
 }
 
 void SBLaunchInfo::SetWorkingDirectory(const char *working_dir) {
-  m_opaque_sp->SetWorkingDirectory(FileSpec{working_dir, false});
+  m_opaque_sp->SetWorkingDirectory(FileSpec(working_dir));
 }
 
 uint32_t SBLaunchInfo::GetLaunchFlags() {
   return m_opaque_sp->GetFlags().Get();
 }
 
 void SBLaunchInfo::SetLaunchFlags(uint32_t flags) {
   m_opaque_sp->GetFlags().Reset(flags);

 const char *SBLaunchInfo::GetShell() {
   // Constify this string so that it is saved in the string pool.  Otherwise it
   // would be freed when this function goes out of scope.
   ConstString shell(m_opaque_sp->GetShell().GetPath().c_str());
   return shell.AsCString();
 }
 
 void SBLaunchInfo::SetShell(const char *path) {
-  m_opaque_sp->SetShell(FileSpec(path, false));
+  m_opaque_sp->SetShell(FileSpec(path));
 }
 
 bool SBLaunchInfo::GetShellExpandArguments() {
   return m_opaque_sp->GetShellExpandArguments();
 }
 
 void SBLaunchInfo::SetShellExpandArguments(bool expand) {
   m_opaque_sp->SetShellExpandArguments(expand);

 }
 
 bool SBLaunchInfo::AddDuplicateFileAction(int fd, int dup_fd) {
   return m_opaque_sp->AppendDuplicateFileAction(fd, dup_fd);
 }
 
 bool SBLaunchInfo::AddOpenFileAction(int fd, const char *path, bool read,
                                      bool write) {
-  return m_opaque_sp->AppendOpenFileAction(fd, FileSpec{path, false}, read,
-                                           write);
+  return m_opaque_sp->AppendOpenFileAction(fd, FileSpec(path), read, write);
 }
 
 bool SBLaunchInfo::AddSuppressFileAction(int fd, bool read, bool write) {
   return m_opaque_sp->AppendSuppressFileAction(fd, read, write);
 }
 
 void SBLaunchInfo::SetLaunchEventData(const char *data) {
   m_opaque_sp->SetLaunchEventData(data);

source/API/SBModuleSpec.cpp

if (this != &rhs)
     *m_opaque_ap = *rhs.m_opaque_ap;
   return *this;
 }
 
 SBModuleSpecList::~SBModuleSpecList() {}
 
 SBModuleSpecList SBModuleSpecList::GetModuleSpecifications(const char *path) {
   SBModuleSpecList specs;
-  FileSpec file_spec(path, true);
+  FileSpec file_spec(path);
+  FileSystem::Instance().Resolve(file_spec);
   Host::ResolveExecutableInBundle(file_spec);
   ObjectFile::GetModuleSpecifications(file_spec, 0, 0, *specs.m_opaque_ap);
   return specs;
 }
 
 void SBModuleSpecList::Append(const SBModuleSpec &spec) {
   m_opaque_ap->Append(*spec.m_opaque_ap);
 }

source/API/SBPlatform.cpp

if (platform_sp)
     return platform_sp->GetWorkingDirectory().GetCString();
   return NULL;
 }
 
 bool SBPlatform::SetWorkingDirectory(const char *path) {
   PlatformSP platform_sp(GetSP());
   if (platform_sp) {
     if (path)
-      platform_sp->SetWorkingDirectory(FileSpec{path, false});
+      platform_sp->SetWorkingDirectory(FileSpec(path));
     else
-      platform_sp->SetWorkingDirectory(FileSpec{});
+      platform_sp->SetWorkingDirectory(FileSpec());
     return true;
   }
   return false;
 }
 
 SBError SBPlatform::ConnectRemote(SBPlatformConnectOptions &connect_options) {
   SBError sb_error;
   PlatformSP platform_sp(GetSP());
if (!command)
       return Status("invalid shell command (empty)");
 
     const char *working_dir = shell_command.GetWorkingDirectory();
     if (working_dir == NULL) {
       working_dir = platform_sp->GetWorkingDirectory().GetCString();
       if (working_dir)
         shell_command.SetWorkingDirectory(working_dir);
     }
-    return platform_sp->RunShellCommand(command, FileSpec{working_dir, false},
+    return platform_sp->RunShellCommand(command, FileSpec(working_dir),
                                         &shell_command.m_opaque_ptr->m_status,
                                         &shell_command.m_opaque_ptr->m_signo,
                                         &shell_command.m_opaque_ptr->m_output,
                                         shell_command.m_opaque_ptr->m_timeout);
   });
 }
 
 SBError SBPlatform::Launch(SBLaunchInfo &launch_info) {
SBError SBPlatform::ExecuteConnected(
   return sb_error;
 }
 
 SBError SBPlatform::MakeDirectory(const char *path, uint32_t file_permissions) {
   SBError sb_error;
   PlatformSP platform_sp(GetSP());
   if (platform_sp) {
     sb_error.ref() =
-        platform_sp->MakeDirectory(FileSpec{path, false}, file_permissions);
+        platform_sp->MakeDirectory(FileSpec(path), file_permissions);
   } else {
     sb_error.SetErrorString("invalid platform");
   }
   return sb_error;
 }
 
 uint32_t SBPlatform::GetFilePermissions(const char *path) {
   PlatformSP platform_sp(GetSP());
   if (platform_sp) {
     uint32_t file_permissions = 0;
-    platform_sp->GetFilePermissions(FileSpec{path, false}, file_permissions);
+    platform_sp->GetFilePermissions(FileSpec(path), file_permissions);
     return file_permissions;
   }
   return 0;
 }
 
 SBError SBPlatform::SetFilePermissions(const char *path,
                                        uint32_t file_permissions) {
   SBError sb_error;
   PlatformSP platform_sp(GetSP());
   if (platform_sp) {
-    sb_error.ref() = platform_sp->SetFilePermissions(FileSpec{path, false},
-                                                     file_permissions);
+    sb_error.ref() =
+        platform_sp->SetFilePermissions(FileSpec(path), file_permissions);
   } else {
     sb_error.SetErrorString("invalid platform");
   }
   return sb_error;
 }
 
 SBUnixSignals SBPlatform::GetUnixSignals() const {
   if (auto platform_sp = GetSP())
     return SBUnixSignals{platform_sp};
 
   return {};
 }

source/API/SBProcess.cpp

bool SBProcess::RemoteLaunch(char const **argv, char const **envp,
 
   ProcessSP process_sp(GetSP());
   if (process_sp) {
     std::lock_guard<std::recursive_mutex> guard(
         process_sp->GetTarget().GetAPIMutex());
     if (process_sp->GetState() == eStateConnected) {
       if (stop_at_entry)
         launch_flags |= eLaunchFlagStopAtEntry;
-      ProcessLaunchInfo launch_info(
-          FileSpec{stdin_path, false}, FileSpec{stdout_path, false},
-          FileSpec{stderr_path, false}, FileSpec{working_directory, false},
-          launch_flags);
+      ProcessLaunchInfo launch_info(FileSpec(stdin_path), FileSpec(stdout_path),
+                                    FileSpec(stderr_path),
+                                    FileSpec(working_directory), launch_flags);
       Module *exe_module = process_sp->GetTarget().GetExecutableModulePointer();
       if (exe_module)
         launch_info.SetExecutableFile(exe_module->GetPlatformFileSpec(), true);
       if (argv)
         launch_info.GetArguments().AppendArguments(argv);
       if (envp)
         launch_info.GetEnvironment() = Environment(envp);
       error.SetError(process_sp->Launch(launch_info));
lldb::SBError SBProcess::SaveCore(const char *file_name) {
   std::lock_guard<std::recursive_mutex> guard(
       process_sp->GetTarget().GetAPIMutex());
 
   if (process_sp->GetState() != eStateStopped) {
     error.SetErrorString("the process is not stopped");
     return error;
   }
 
-  FileSpec core_file(file_name, false);
+  FileSpec core_file(file_name);
   error.ref() = PluginManager::SaveCore(process_sp, core_file);
   return error;
 }
 
 lldb::SBError
 SBProcess::GetMemoryRegionInfo(lldb::addr_t load_addr,
                                SBMemoryRegionInfo &sb_region_info) {
   lldb::SBError sb_error;

source/API/SBTarget.cpp

SBProcess SBTarget::LoadCore(const char *core_file) {
   lldb::SBError error; // Ignored
   return LoadCore(core_file, error);
 }
 
 SBProcess SBTarget::LoadCore(const char *core_file, lldb::SBError &error) {
   SBProcess sb_process;
   TargetSP target_sp(GetSP());
   if (target_sp) {
-    FileSpec filespec(core_file, true);
+    FileSpec filespec(core_file);
+    FileSystem::Instance().Resolve(filespec);
     ProcessSP process_sp(target_sp->CreateProcess(
         target_sp->GetDebugger().GetListener(), "", &filespec));
     if (process_sp) {
       error.SetError(process_sp->LoadCore());
       if (error.Success())
         sb_process.SetSP(process_sp);
     } else {
       error.SetErrorString("Failed to create the process");
if (state == eStateConnected) {
                              "pass empty listener");
         return sb_process;
       }
     }
 
     if (getenv("LLDB_LAUNCH_FLAG_DISABLE_STDIO"))
       launch_flags |= eLaunchFlagDisableSTDIO;
 
-    ProcessLaunchInfo launch_info(
-        FileSpec{stdin_path, false}, FileSpec{stdout_path, false},
-        FileSpec{stderr_path, false}, FileSpec{working_directory, false},
-        launch_flags);
+    ProcessLaunchInfo launch_info(FileSpec(stdin_path), FileSpec(stdout_path),
+                                  FileSpec(stderr_path),
+                                  FileSpec(working_directory), launch_flags);
 
     Module *exe_module = target_sp->GetExecutableModulePointer();
     if (exe_module)
       launch_info.SetExecutableFile(exe_module->GetPlatformFileSpec(), true);
     if (argv)
       launch_info.GetArguments().AppendArguments(argv);
     if (envp)
       launch_info.GetEnvironment() = Environment(envp);
lldb::SBProcess SBTarget::AttachToProcessWithName(
 
   if (log)
     log->Printf("SBTarget(%p)::%s (listener, name=%s, wait_for=%s, error)...",
                 static_cast<void *>(target_sp.get()), __FUNCTION__, name,
                 wait_for ? "true" : "false");
 
   if (name && target_sp) {
     ProcessAttachInfo attach_info;
-    attach_info.GetExecutableFile().SetFile(name, false,
-                                            FileSpec::Style::native);
+    attach_info.GetExecutableFile().SetFile(name, FileSpec::Style::native);
     attach_info.SetWaitForLaunch(wait_for);
     if (listener.IsValid())
       attach_info.SetListener(listener.GetSP());
 
     error.SetError(AttachToProcess(attach_info, *target_sp));
     if (error.Success())
       sb_process.SetSP(target_sp->GetProcessSP());
   } else
if (target_sp.get()) {
     std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
 
     const bool internal = false;
     const bool hardware = false;
     const LazyBool skip_prologue = eLazyBoolCalculate;
     const lldb::addr_t offset = 0;
     if (module_name && module_name[0]) {
       FileSpecList module_spec_list;
-      module_spec_list.Append(FileSpec(module_name, false));
+      module_spec_list.Append(FileSpec(module_name));
       sb_bp = target_sp->CreateBreakpoint(
           &module_spec_list, NULL, symbol_name, eFunctionNameTypeAuto,
           eLanguageTypeUnknown, offset, skip_prologue, internal, hardware);
     } else {
       sb_bp = target_sp->CreateBreakpoint(
           NULL, NULL, symbol_name, eFunctionNameTypeAuto, eLanguageTypeUnknown,
           offset, skip_prologue, internal, hardware);
     }
lldb::SBBreakpoint SBTarget::BreakpointCreateByNames(
   return sb_bp;
 }
 
 SBBreakpoint SBTarget::BreakpointCreateByRegex(const char *symbol_name_regex,
                                                const char *module_name) {
   SBFileSpecList module_spec_list;
   SBFileSpecList comp_unit_list;
   if (module_name && module_name[0]) {
-    module_spec_list.Append(FileSpec(module_name, false));
+    module_spec_list.Append(FileSpec(module_name));
   }
   return BreakpointCreateByRegex(symbol_name_regex, eLanguageTypeUnknown,
                                  module_spec_list, comp_unit_list);
 }
 
 lldb::SBBreakpoint
 SBTarget::BreakpointCreateByRegex(const char *symbol_name_regex,
                                   const SBFileSpecList &module_list,

 
 lldb::SBBreakpoint
 SBTarget::BreakpointCreateBySourceRegex(const char *source_regex,
                                         const lldb::SBFileSpec &source_file,
                                         const char *module_name) {
   SBFileSpecList module_spec_list;
 
   if (module_name && module_name[0]) {
-    module_spec_list.Append(FileSpec(module_name, false));
+    module_spec_list.Append(FileSpec(module_name));
   }
 
   SBFileSpecList source_file_list;
   if (source_file.IsValid()) {
     source_file_list.Append(source_file);
   }
 
   return BreakpointCreateBySourceRegex(source_regex, module_spec_list,

 
 lldb::SBModule SBTarget::AddModule(const char *path, const char *triple,
                                    const char *uuid_cstr, const char *symfile) {
   lldb::SBModule sb_module;
   TargetSP target_sp(GetSP());
   if (target_sp) {
     ModuleSpec module_spec;
     if (path)
-      module_spec.GetFileSpec().SetFile(path, false, FileSpec::Style::native);
+      module_spec.GetFileSpec().SetFile(path, FileSpec::Style::native);
 
     if (uuid_cstr)
       module_spec.GetUUID().SetFromStringRef(uuid_cstr);
 
     if (triple)
       module_spec.GetArchitecture() = Platform::GetAugmentedArchSpec(
           target_sp->GetPlatform().get(), triple);
     else
       module_spec.GetArchitecture() = target_sp->GetArchitecture();
 
     if (symfile)
-      module_spec.GetSymbolFileSpec().SetFile(symfile, false,
-                                              FileSpec::Style::native);
+      module_spec.GetSymbolFileSpec().SetFile(symfile, FileSpec::Style::native);
 
     sb_module.SetSP(target_sp->GetSharedModule(module_spec));
   }
   return sb_module;
 }
 
 lldb::SBModule SBTarget::AddModule(const SBModuleSpec &module_spec) {
   lldb::SBModule sb_module;

source/Breakpoint/BreakpointResolverAddress.cpp

BreakpointResolver *BreakpointResolverAddress::CreateFromStructuredData(
   success = options_dict.HasKey(GetKey(OptionNames::ModuleName));
   if (success) {
     success = options_dict.GetValueForKeyAsString(
         GetKey(OptionNames::ModuleName), module_name);
     if (!success) {
       error.SetErrorString("BRA::CFSD: Couldn't read module name entry.");
       return nullptr;
     }
-    module_filespec.SetFile(module_name, false, FileSpec::Style::native);
+    module_filespec.SetFile(module_name, FileSpec::Style::native);
   }
   return new BreakpointResolverAddress(bkpt, address, module_filespec);
 }
 
 StructuredData::ObjectSP
 BreakpointResolverAddress::SerializeToStructuredData() {
   StructuredData::DictionarySP options_dict_sp(
       new StructuredData::Dictionary());

source/Breakpoint/BreakpointResolverFileLine.cpp

BreakpointResolver *BreakpointResolverFileLine::CreateFromStructuredData(
 
   success = options_dict.GetValueForKeyAsBoolean(
       GetKey(OptionNames::ExactMatch), exact_match);
   if (!success) {
     error.SetErrorString("BRFL::CFSD: Couldn't find exact match entry.");
     return nullptr;
   }
 
-  FileSpec file_spec(filename, false);
+  FileSpec file_spec(filename);
 
   return new BreakpointResolverFileLine(bkpt, file_spec, line_no, column,
                                         offset, check_inlines, skip_prologue,
                                         exact_match);
 }
 
 StructuredData::ObjectSP
 BreakpointResolverFileLine::SerializeToStructuredData() {

source/Commands/CommandCompletions.cpp

 // SourceFileCompleter
 //----------------------------------------------------------------------
 
 CommandCompletions::SourceFileCompleter::SourceFileCompleter(
     CommandInterpreter &interpreter, bool include_support_files,
     CompletionRequest &request)
     : CommandCompletions::Completer(interpreter, request),
       m_include_support_files(include_support_files), m_matching_files() {
-  FileSpec partial_spec(m_request.GetCursorArgumentPrefix(), false);
+  FileSpec partial_spec(m_request.GetCursorArgumentPrefix());
   m_file_name = partial_spec.GetFilename().GetCString();
   m_dir_name = partial_spec.GetDirectory().GetCString();
 }
 
 lldb::SearchDepth CommandCompletions::SourceFileCompleter::GetDepth() {
   return lldb::eSearchDepthCompUnit;
 }
 

 }
 
 //----------------------------------------------------------------------
 // ModuleCompleter
 //----------------------------------------------------------------------
 CommandCompletions::ModuleCompleter::ModuleCompleter(
     CommandInterpreter &interpreter, CompletionRequest &request)
     : CommandCompletions::Completer(interpreter, request) {
-  FileSpec partial_spec(m_request.GetCursorArgumentPrefix(), false);
+  FileSpec partial_spec(m_request.GetCursorArgumentPrefix());
   m_file_name = partial_spec.GetFilename().GetCString();
   m_dir_name = partial_spec.GetDirectory().GetCString();
 }
 
 lldb::SearchDepth CommandCompletions::ModuleCompleter::GetDepth() {
   return lldb::eSearchDepthModule;
 }
 

source/Commands/CommandObjectBreakpoint.cpp

Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
         default:
           error.SetErrorStringWithFormat(
               "Unsupported language type: '%s' for exception breakpoint",
               option_arg.str().c_str());
         }
       } break;
 
       case 'f':
-        m_filenames.AppendIfUnique(FileSpec(option_arg, false));
+        m_filenames.AppendIfUnique(FileSpec(option_arg));
         break;
 
       case 'F':
         m_func_names.push_back(option_arg);
         m_func_name_type_mask |= eFunctionNameTypeFull;
         break;
         
       case 'h': {
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
         m_python_class.assign(option_arg);
         break;
 
       case 'r':
         m_func_regexp.assign(option_arg);
         break;
 
       case 's':
-        m_modules.AppendIfUnique(FileSpec(option_arg, false));
+        m_modules.AppendIfUnique(FileSpec(option_arg));
         break;
 
       case 'S':
         m_func_names.push_back(option_arg);
         m_func_name_type_mask |= eFunctionNameTypeSelector;
         break;
 
       case 'v': {
if (target == nullptr) {
       result.AppendError("Invalid target.  No existing target or breakpoints.");
       result.SetStatus(eReturnStatusFailed);
       return false;
     }
 
     std::unique_lock<std::recursive_mutex> lock;
     target->GetBreakpointList().GetListMutex(lock);
 
-    FileSpec input_spec(m_options.m_filename, true);
+    FileSpec input_spec(m_options.m_filename);
+    FileSystem::Instance().Resolve(input_spec);
     BreakpointIDList new_bps;
     Status error = target->CreateBreakpointsFromFile(
         input_spec, m_options.m_names, new_bps);
 
     if (!error.Success()) {
       result.AppendError(error.AsCString());
       result.SetStatus(eReturnStatusFailed);
       return false;
if (!command.empty()) {
           command, target, result, &valid_bp_ids, 
           BreakpointName::Permissions::PermissionKinds::listPerm);
 
       if (!result.Succeeded()) {
         result.SetStatus(eReturnStatusFailed);
         return false;
       }
     }
-    Status error = target->SerializeBreakpointsToFile(
-        FileSpec(m_options.m_filename, true), valid_bp_ids, m_options.m_append);
+    FileSpec file_spec(m_options.m_filename);
+    FileSystem::Instance().Resolve(file_spec);
+    Status error = target->SerializeBreakpointsToFile(file_spec, valid_bp_ids,
+                                                      m_options.m_append);
     if (!error.Success()) {
       result.AppendErrorWithFormat("error serializing breakpoints: %s.",
                                    error.AsCString());
       result.SetStatus(eReturnStatusFailed);
     }
     return result.Succeeded();
   }
 

source/Commands/CommandObjectCommands.cpp

bool DoExecute(Args &command, CommandReturnObject &result) override {
     if (command.GetArgumentCount() != 1) {
       result.AppendErrorWithFormat(
           "'%s' takes exactly one executable filename argument.\n",
           GetCommandName().str().c_str());
       result.SetStatus(eReturnStatusFailed);
       return false;
     }
 
-    FileSpec cmd_file(command[0].ref, true);
+    FileSpec cmd_file(command[0].ref);
+    FileSystem::Instance().Resolve(cmd_file);
     ExecutionContext *exe_ctx = nullptr; // Just use the default context.
 
     // If any options were set, then use them
     if (m_options.m_stop_on_error.OptionWasSet() ||
         m_options.m_silent_run.OptionWasSet() ||
         m_options.m_stop_on_continue.OptionWasSet()) {
       // Use user set settings
       CommandInterpreterRunOptions options;

source/Commands/CommandObjectLog.cpp

public:
 
     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                           ExecutionContext *execution_context) override {
       Status error;
       const int short_option = m_getopt_table[option_idx].val;
 
       switch (short_option) {
       case 'f':
-        log_file.SetFile(option_arg, true, FileSpec::Style::native);
+        log_file.SetFile(option_arg, FileSpec::Style::native);
+        FileSystem::Instance().Resolve(log_file);
         break;
       case 't':
         log_options |= LLDB_LOG_OPTION_THREADSAFE;
         break;
       case 'v':
         log_options |= LLDB_LOG_OPTION_VERBOSE;
         break;
       case 's':

source/Commands/CommandObjectMemory.cpp

public:
     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);
+        m_infile.SetFile(option_value, FileSpec::Style::native);
+        FileSystem::Instance().Resolve(m_infile);
         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': {

source/Commands/CommandObjectPlatform.cpp

if (platform_sp) {
       uint32_t mode;
       const OptionPermissions *options_permissions =
           (const OptionPermissions *)m_options.GetGroupWithOption('r');
       if (options_permissions)
         mode = options_permissions->m_permissions;
       else
         mode = lldb::eFilePermissionsUserRWX | lldb::eFilePermissionsGroupRWX |
                lldb::eFilePermissionsWorldRX;
-      Status error =
-          platform_sp->MakeDirectory(FileSpec{cmd_line, false}, mode);
+      Status error = platform_sp->MakeDirectory(FileSpec(cmd_line), mode);
       if (error.Success()) {
         result.SetStatus(eReturnStatusSuccessFinishResult);
       } else {
         result.AppendError(error.AsCString());
         result.SetStatus(eReturnStatusFailed);
       }
     } else {
       result.AppendError("no platform currently selected\n");
if (platform_sp) {
       const OptionPermissions *options_permissions =
           (const OptionPermissions *)m_options.GetGroupWithOption('r');
       if (options_permissions)
         perms = options_permissions->m_permissions;
       else
         perms = lldb::eFilePermissionsUserRW | lldb::eFilePermissionsGroupRW |
                 lldb::eFilePermissionsWorldRead;
       lldb::user_id_t fd = platform_sp->OpenFile(
-          FileSpec(cmd_line, false),
+          FileSpec(cmd_line),
           File::eOpenOptionRead | File::eOpenOptionWrite |
               File::eOpenOptionAppend | File::eOpenOptionCanCreate,
           perms, error);
       if (error.Success()) {
         result.AppendMessageWithFormat("File Descriptor = %" PRIu64 "\n", fd);
         result.SetStatus(eReturnStatusSuccessFinishResult);
       } else {
         result.AppendError(error.AsCString());
if (args.GetArgumentCount() != 2) {
       return false;
     }
 
     PlatformSP platform_sp(
         m_interpreter.GetDebugger().GetPlatformList().GetSelectedPlatform());
     if (platform_sp) {
       const char *remote_file_path = args.GetArgumentAtIndex(0);
       const char *local_file_path = args.GetArgumentAtIndex(1);
-      Status error = platform_sp->GetFile(FileSpec(remote_file_path, false),
-                                          FileSpec(local_file_path, false));
+      Status error = platform_sp->GetFile(FileSpec(remote_file_path),
+                                          FileSpec(local_file_path));
       if (error.Success()) {
         result.AppendMessageWithFormat(
             "successfully get-file from %s (remote) to %s (host)\n",
             remote_file_path, local_file_path);
         result.SetStatus(eReturnStatusSuccessFinishResult);
       } else {
         result.AppendMessageWithFormat("get-file failed: %s\n",
                                        error.AsCString());
if (args.GetArgumentCount() != 1) {
       result.SetStatus(eReturnStatusFailed);
       return false;
     }
 
     PlatformSP platform_sp(
         m_interpreter.GetDebugger().GetPlatformList().GetSelectedPlatform());
     if (platform_sp) {
       std::string remote_file_path(args.GetArgumentAtIndex(0));
-      user_id_t size =
-          platform_sp->GetFileSize(FileSpec(remote_file_path, false));
+      user_id_t size = platform_sp->GetFileSize(FileSpec(remote_file_path));
       if (size != UINT64_MAX) {
         result.AppendMessageWithFormat("File size of %s (remote): %" PRIu64
                                        "\n",
                                        remote_file_path.c_str(), size);
         result.SetStatus(eReturnStatusSuccessFinishResult);
       } else {
         result.AppendMessageWithFormat(
             "Error getting file size of %s (remote)\n",
public:
   }
 
   ~CommandObjectPlatformPutFile() override = default;
 
   bool DoExecute(Args &args, CommandReturnObject &result) override {
     const char *src = args.GetArgumentAtIndex(0);
     const char *dst = args.GetArgumentAtIndex(1);
 
-    FileSpec src_fs(src, true);
-    FileSpec dst_fs(dst ? dst : src_fs.GetFilename().GetCString(), false);
+    FileSpec src_fs(src);
+    FileSystem::Instance().Resolve(src_fs);
+    FileSpec dst_fs(dst ? dst : src_fs.GetFilename().GetCString());
 
     PlatformSP platform_sp(
         m_interpreter.GetDebugger().GetPlatformList().GetSelectedPlatform());
     if (platform_sp) {
       Status error(platform_sp->PutFile(src_fs, dst_fs));
       if (error.Success()) {
         result.SetStatus(eReturnStatusSuccessFinishNoResult);
       } else {
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
             debugger_sp ? debugger_sp->GetPlatformList().GetSelectedPlatform()
                         : PlatformSP();
         match_info.GetProcessInfo().GetArchitecture() =
             Platform::GetAugmentedArchSpec(platform_sp.get(), option_arg);
       } break;
 
       case 'n':
         match_info.GetProcessInfo().GetExecutableFile().SetFile(
-            option_arg, false, FileSpec::Style::native);
+            option_arg, FileSpec::Style::native);
         match_info.SetNameMatchType(NameMatch::Equals);
         break;
 
       case 'e':
         match_info.GetProcessInfo().GetExecutableFile().SetFile(
-            option_arg, false, FileSpec::Style::native);
+            option_arg, FileSpec::Style::native);
         match_info.SetNameMatchType(NameMatch::EndsWith);
         break;
 
       case 's':
         match_info.GetProcessInfo().GetExecutableFile().SetFile(
-            option_arg, false, FileSpec::Style::native);
+            option_arg, FileSpec::Style::native);
         match_info.SetNameMatchType(NameMatch::StartsWith);
         break;
 
       case 'c':
         match_info.GetProcessInfo().GetExecutableFile().SetFile(
-            option_arg, false, FileSpec::Style::native);
+            option_arg, FileSpec::Style::native);
         match_info.SetNameMatchType(NameMatch::Contains);
         break;
 
       case 'r':
         match_info.GetProcessInfo().GetExecutableFile().SetFile(
-            option_arg, false, FileSpec::Style::native);
+            option_arg, FileSpec::Style::native);
         match_info.SetNameMatchType(NameMatch::RegularExpression);
         break;
 
       case 'A':
         show_args = true;
         break;
 
       case 'v':
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
         }
       } break;
 
       case 'P':
         attach_info.SetProcessPluginName(option_arg);
         break;
 
       case 'n':
-        attach_info.GetExecutableFile().SetFile(option_arg, false,
+        attach_info.GetExecutableFile().SetFile(option_arg,
                                                 FileSpec::Style::native);
         break;
 
       case 'w':
         attach_info.SetWaitForLaunch(true);
         break;
 
       default:
bool HandleOptionArgumentCompletion(
         partial_name = request.GetParsedLine().GetArgumentAtIndex(opt_arg_pos);
 
         PlatformSP platform_sp(interpreter.GetPlatform(true));
         if (platform_sp) {
           ProcessInstanceInfoList process_infos;
           ProcessInstanceInfoMatch match_info;
           if (partial_name) {
             match_info.GetProcessInfo().GetExecutableFile().SetFile(
-                partial_name, false, FileSpec::Style::native);
+                partial_name, FileSpec::Style::native);
             match_info.SetNameMatchType(NameMatch::StartsWith);
           }
           platform_sp->FindProcesses(match_info, process_infos);
           const uint32_t num_matches = process_infos.GetSize();
           if (num_matches > 0) {
             for (uint32_t i = 0; i < num_matches; ++i) {
               request.AddCompletion(llvm::StringRef(
                   process_infos.GetProcessNameAtIndex(i),
public:
 
   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);
+    FileSpec src(args.GetArgumentAtIndex(0));
+    FileSystem::Instance().Resolve(src);
+    FileSpec dst(args.GetArgumentAtIndex(1));
     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) {

source/Commands/CommandObjectPlugin.cpp

bool DoExecute(Args &command, CommandReturnObject &result) override {
     if (argc != 1) {
       result.AppendError("'plugin load' requires one argument");
       result.SetStatus(eReturnStatusFailed);
       return false;
     }
 
     Status error;
 
-    FileSpec dylib_fspec(command[0].ref, true);
+    FileSpec dylib_fspec(command[0].ref);
+    FileSystem::Instance().Resolve(dylib_fspec);
 
     if (m_interpreter.GetDebugger().LoadPlugin(dylib_fspec, error))
       result.SetStatus(eReturnStatusSuccessFinishResult);
     else {
       result.AppendError(error.AsCString());
       result.SetStatus(eReturnStatusFailed);
     }
 

source/Commands/CommandObjectProcess.cpp

Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
         }
       } break;
 
       case 'P':
         attach_info.SetProcessPluginName(option_arg);
         break;
 
       case 'n':
-        attach_info.GetExecutableFile().SetFile(option_arg, false,
+        attach_info.GetExecutableFile().SetFile(option_arg,
                                                 FileSpec::Style::native);
         break;
 
       case 'w':
         attach_info.SetWaitForLaunch(true);
         break;
 
       case 'i':
bool HandleOptionArgumentCompletion(
         partial_name = request.GetParsedLine().GetArgumentAtIndex(opt_arg_pos);
 
         PlatformSP platform_sp(interpreter.GetPlatform(true));
         if (platform_sp) {
           ProcessInstanceInfoList process_infos;
           ProcessInstanceInfoMatch match_info;
           if (partial_name) {
             match_info.GetProcessInfo().GetExecutableFile().SetFile(
-                partial_name, false, FileSpec::Style::native);
+                partial_name, FileSpec::Style::native);
             match_info.SetNameMatchType(NameMatch::StartsWith);
           }
           platform_sp->FindProcesses(match_info, process_infos);
           const size_t num_matches = process_infos.GetSize();
           if (num_matches > 0) {
             for (size_t i = 0; i < num_matches; ++i) {
               request.AddCompletion(llvm::StringRef(
                   process_infos.GetProcessNameAtIndex(i),
public:
     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                           ExecutionContext *execution_context) override {
       Status error;
       const int short_option = m_getopt_table[option_idx].val;
       switch (short_option) {
       case 'i':
         do_install = true;
         if (!option_arg.empty())
-          install_path.SetFile(option_arg, false, FileSpec::Style::native);
+          install_path.SetFile(option_arg, FileSpec::Style::native);
         break;
       default:
         error.SetErrorStringWithFormat("invalid short option character '%c'",
                                        short_option);
         break;
       }
       return error;
     }
bool DoExecute(Args &command, CommandReturnObject &result) override {
 
     for (auto &entry : command.entries()) {
       Status error;
       PlatformSP platform = process->GetTarget().GetPlatform();
       llvm::StringRef image_path = entry.ref;
       uint32_t image_token = LLDB_INVALID_IMAGE_TOKEN;
 
       if (!m_options.do_install) {
-        FileSpec image_spec(image_path, false);
+        FileSpec image_spec(image_path);
         platform->ResolveRemotePath(image_spec, image_spec);
         image_token =
             platform->LoadImage(process, FileSpec(), image_spec, error);
       } else if (m_options.install_path) {
-        FileSpec image_spec(image_path, true);
+        FileSpec image_spec(image_path);
+        FileSystem::Instance().Resolve(image_spec);
         platform->ResolveRemotePath(m_options.install_path,
                                     m_options.install_path);
         image_token = platform->LoadImage(process, image_spec,
                                           m_options.install_path, error);
       } else {
-        FileSpec image_spec(image_path, true);
+        FileSpec image_spec(image_path);
+        FileSystem::Instance().Resolve(image_spec);
         image_token =
             platform->LoadImage(process, image_spec, FileSpec(), error);
       }
 
       if (image_token != LLDB_INVALID_IMAGE_TOKEN) {
         result.AppendMessageWithFormat(
             "Loading \"%s\"...ok\nImage %u loaded.\n", image_path.str().c_str(),
             image_token);
public:
 
   ~CommandObjectProcessSaveCore() override = default;
 
 protected:
   bool DoExecute(Args &command, CommandReturnObject &result) override {
     ProcessSP process_sp = m_exe_ctx.GetProcessSP();
     if (process_sp) {
       if (command.GetArgumentCount() == 1) {
-        FileSpec output_file(command.GetArgumentAtIndex(0), false);
+        FileSpec output_file(command.GetArgumentAtIndex(0));
         Status error = PluginManager::SaveCore(process_sp, output_file);
         if (error.Success()) {
           result.SetStatus(eReturnStatusSuccessFinishResult);
         } else {
           result.AppendErrorWithFormat(
               "Failed to save core file for process: %s\n", error.AsCString());
           result.SetStatus(eReturnStatusFailed);
         }

source/Commands/CommandObjectSettings.cpp

public:
 
     // Instance variables to hold the values for command options.
     std::string m_filename;
     bool m_append = false;
   };
 
 protected:
   bool DoExecute(Args &args, CommandReturnObject &result) override {
-    std::string path(FileSpec(m_options.m_filename, true).GetPath());
+    FileSpec file_spec(m_options.m_filename);
+    FileSystem::Instance().Resolve(file_spec);
+    std::string path(file_spec.GetPath());
     uint32_t options = File::OpenOptions::eOpenOptionWrite |
                        File::OpenOptions::eOpenOptionCanCreate;
     if (m_options.m_append)
       options |= File::OpenOptions::eOpenOptionAppend;
     else
       options |= File::OpenOptions::eOpenOptionTruncate;
 
     StreamFile out_file(path.c_str(), options,
public:
     }
 
     // Instance variables to hold the values for command options.
     std::string m_filename;
   };
 
 protected:
   bool DoExecute(Args &command, CommandReturnObject &result) override {
-    FileSpec file(m_options.m_filename, true);
+    FileSpec file(m_options.m_filename);
+    FileSystem::Instance().Resolve(file);
     ExecutionContext clean_ctx;
     CommandInterpreterRunOptions options;
     options.SetAddToHistory(false);
     options.SetEchoCommands(false);
     options.SetPrintResults(true);
     options.SetStopOnError(false);
     m_interpreter.HandleCommandsFromFile(file, &clean_ctx, options, result);
     return result.Succeeded();

source/Commands/CommandObjectSource.cpp

if (!DumpLinesInSymbolContexts(result.GetOutputStream(), sc_list,
                                    m_options.address);
       return false;
     }
     return true;
   }
 
   // Dump the line entries found in the file specified in the option.
   bool DumpLinesForFile(CommandReturnObject &result) {
-    FileSpec file_spec(m_options.file_name, false);
+    FileSpec file_spec(m_options.file_name);
     const char *filename = m_options.file_name.c_str();
     Target *target = m_exe_ctx.GetTargetPtr();
     const ModuleList &module_list =
         (m_module_list.GetSize() > 0) ? m_module_list : target->GetImages();
 
     bool displayed_something = false;
     const size_t num_modules = module_list.GetSize();
     for (uint32_t i = 0; i < num_modules; ++i) {
bool DoExecute(Args &command, CommandReturnObject &result) override {
     uint32_t addr_byte_size = target->GetArchitecture().GetAddressByteSize();
     result.GetOutputStream().SetAddressByteSize(addr_byte_size);
     result.GetErrorStream().SetAddressByteSize(addr_byte_size);
 
     // Collect the list of modules to search.
     m_module_list.Clear();
     if (!m_options.modules.empty()) {
       for (size_t i = 0, e = m_options.modules.size(); i < e; ++i) {
-        FileSpec module_file_spec(m_options.modules[i], false);
+        FileSpec module_file_spec(m_options.modules[i]);
         if (module_file_spec) {
           ModuleSpec module_spec(module_file_spec);
           if (target->GetImages().FindModules(module_spec, m_module_list) == 0)
             result.AppendWarningWithFormat("No module found for '%s'.\n",
                                            m_options.modules[i].c_str());
         }
       }
       if (!m_module_list.GetSize()) {
size_t FindMatchingFunctions(Target *target, const ConstString &name,
 
     if (m_options.num_lines == 0)
       m_options.num_lines = 10;
 
     const size_t num_modules = m_options.modules.size();
     if (num_modules > 0) {
       ModuleList matching_modules;
       for (size_t i = 0; i < num_modules; ++i) {
-        FileSpec module_file_spec(m_options.modules[i], false);
+        FileSpec module_file_spec(m_options.modules[i]);
         if (module_file_spec) {
           ModuleSpec module_spec(module_file_spec);
           matching_modules.Clear();
           target->GetImages().FindModules(module_spec, matching_modules);
           num_matches += matching_modules.FindFunctions(
               name, eFunctionNameTypeAuto, include_symbols, include_inlines,
               append, sc_list);
         }
       }
     } else {
       num_matches = target->GetImages().FindFunctions(
           name, eFunctionNameTypeAuto, include_symbols, include_inlines, append,
           sc_list);
     }
     return num_matches;
   }
 
   size_t FindMatchingFunctionSymbols(Target *target, const ConstString &name,
                                      SymbolContextList &sc_list) {
     size_t num_matches = 0;
     const size_t num_modules = m_options.modules.size();
     if (num_modules > 0) {
       ModuleList matching_modules;
       for (size_t i = 0; i < num_modules; ++i) {
-        FileSpec module_file_spec(m_options.modules[i], false);
+        FileSpec module_file_spec(m_options.modules[i]);
         if (module_file_spec) {
           ModuleSpec module_spec(module_file_spec);
           matching_modules.Clear();
           target->GetImages().FindModules(module_spec, matching_modules);
           num_matches += matching_modules.FindFunctionSymbols(
               name, eFunctionNameTypeAuto, sc_list);
         }
       }
if (!m_options.symbol_name.empty()) {
 
       bool check_inlines = false;
       SymbolContextList sc_list;
       size_t num_matches = 0;
 
       if (!m_options.modules.empty()) {
         ModuleList matching_modules;
         for (size_t i = 0, e = m_options.modules.size(); i < e; ++i) {
-          FileSpec module_file_spec(m_options.modules[i], false);
+          FileSpec module_file_spec(m_options.modules[i]);
           if (module_file_spec) {
             ModuleSpec module_spec(module_file_spec);
             matching_modules.Clear();
             target->GetImages().FindModules(module_spec, matching_modules);
             num_matches += matching_modules.ResolveSymbolContextForFilePath(
                 filename, 0, check_inlines,
                 SymbolContextItem(eSymbolContextModule |
                                   eSymbolContextCompUnit),

source/Commands/CommandObjectTarget.cpp

if (argc == 1 || core_file || remote_file) {
         }
       }
 
       const char *file_path = command.GetArgumentAtIndex(0);
       static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
       Timer scoped_timer(func_cat, "(lldb) target create '%s'", file_path);
       FileSpec file_spec;
 
-      if (file_path)
-        file_spec.SetFile(file_path, true, FileSpec::Style::native);
+      if (file_path) {
+        file_spec.SetFile(file_path, FileSpec::Style::native);
+        FileSystem::Instance().Resolve(file_spec);
+      }
 
       bool must_set_platform_path = false;
 
       Debugger &debugger = m_interpreter.GetDebugger();
 
       TargetSP target_sp;
       llvm::StringRef arch_cstr = m_arch_option.GetArchitectureName();
       Status error(debugger.GetTargetList().CreateTarget(
if (module && file_spec) {
     }
   }
   return 0;
 }
 
 static size_t FindModulesByName(Target *target, const char *module_name,
                                 ModuleList &module_list,
                                 bool check_global_list) {
-  FileSpec module_file_spec(module_name, false);
+  FileSpec module_file_spec(module_name);
   ModuleSpec module_spec(module_file_spec);
 
   const size_t initial_size = module_list.GetSize();
 
   if (check_global_list) {
     // Check the global list
     std::lock_guard<std::recursive_mutex> guard(
         Module::GetAllocationModuleCollectionMutex());
if (command.GetArgumentCount() == 0) {
       result.SetStatus(eReturnStatusFailed);
       return result.Succeeded();
     } else {
       // Dump specified images (by basename or fullpath)
       const char *arg_cstr;
       for (int arg_idx = 0;
            (arg_cstr = command.GetArgumentAtIndex(arg_idx)) != nullptr;
            ++arg_idx) {
-        FileSpec file_spec(arg_cstr, false);
+        FileSpec file_spec(arg_cstr);
 
         const ModuleList &target_modules = target->GetImages();
         std::lock_guard<std::recursive_mutex> guard(target_modules.GetMutex());
         const size_t num_modules = target_modules.GetSize();
         if (num_modules > 0) {
           uint32_t num_dumped = 0;
           for (uint32_t i = 0; i < num_modules; ++i) {
             if (m_interpreter.WasInterrupted())
if (target == nullptr) {
           result.SetStatus(eReturnStatusFailed);
           return false;
         }
       } else {
         for (auto &entry : args.entries()) {
           if (entry.ref.empty())
             continue;
 
-          FileSpec file_spec(entry.ref, true);
+          FileSpec file_spec(entry.ref);
           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();
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
         break;
 
       case 's':
         m_str = option_arg;
         m_type = eLookupTypeSymbol;
         break;
 
       case 'f':
-        m_file.SetFile(option_arg, false, FileSpec::Style::native);
+        m_file.SetFile(option_arg, FileSpec::Style::native);
         m_type = eLookupTypeFileLine;
         break;
 
       case 'i':
         m_include_inlines = false;
         break;
 
       case 'l':
if (argc == 0) {
       } else if (file_option_set && argc > 1) {
         result.AppendError("specify at most one symbol file path when "
                            "--shlib option is set");
       } else {
         PlatformSP platform_sp(target->GetPlatform());
 
         for (auto &entry : args.entries()) {
           if (!entry.ref.empty()) {
-            module_spec.GetSymbolFileSpec().SetFile(entry.ref, true,
-                                                    FileSpec::Style::native);
+            auto &symbol_file_spec = module_spec.GetSymbolFileSpec();
+            symbol_file_spec.SetFile(entry.ref, FileSpec::Style::native);
+            FileSystem::Instance().Resolve(symbol_file_spec);
             if (file_option_set) {
               module_spec.GetFileSpec() =
                   m_file_option.GetOptionValue().GetCurrentValue();
             }
             if (platform_sp) {
               FileSpec symfile_spec;
               if (platform_sp
                       ->ResolveSymbolFile(*target, module_spec, symfile_spec)

source/Commands/CommandObjectThread.cpp

public:
 
     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                           ExecutionContext *execution_context) override {
       const int short_option = m_getopt_table[option_idx].val;
       Status error;
 
       switch (short_option) {
       case 'f':
-        m_filenames.AppendIfUnique(FileSpec(option_arg, false));
+        m_filenames.AppendIfUnique(FileSpec(option_arg));
         if (m_filenames.GetSize() > 1)
           return Status("only one source file expected.");
         break;
       case 'l':
         if (option_arg.getAsInteger(0, m_line_num))
           return Status("invalid line number: '%s'.", option_arg.str().c_str());
         break;
       case 'b':

source/Core/Debugger.cpp

LoadPluginCallback(void *baton, llvm::sys::fs::file_type ft,
 
   namespace fs = llvm::sys::fs;
   // If we have a regular file, a symbolic link or unknown file type, try and
   // process the file. We must handle unknown as sometimes the directory
   // enumeration might be enumerating a file system that doesn't have correct
   // file type information.
   if (ft == fs::file_type::regular_file || ft == fs::file_type::symlink_file ||
       ft == fs::file_type::type_unknown) {
-    FileSpec plugin_file_spec(path, false);
-    plugin_file_spec.ResolvePath();
+    FileSpec plugin_file_spec(path);
+    FileSystem::Instance().Resolve(plugin_file_spec);
 
     if (plugin_file_spec.GetFileNameExtension() != g_dylibext &&
         plugin_file_spec.GetFileNameExtension() != g_solibext) {
       return FileSystem::eEnumerateDirectoryResultNext;
     }
 
     Status plugin_load_error;
     debugger->LoadPlugin(plugin_file_spec, plugin_load_error);

source/Core/DynamicLoader.cpp

ModuleSP DynamicLoader::LoadModuleAtAddress(const FileSpec &file,
   // We failed to find the module based on its name. Lets try to check if we
   // can find a different name based on the memory region info.
   if (check_alternative_file_name) {
     MemoryRegionInfo memory_info;
     Status error = m_process->GetMemoryRegionInfo(base_addr, memory_info);
     if (error.Success() && memory_info.GetMapped() &&
         memory_info.GetRange().GetRangeBase() == base_addr && 
         !(memory_info.GetName().IsEmpty())) {
-      ModuleSpec new_module_spec(
-          FileSpec(memory_info.GetName().AsCString(), false),
+      ModuleSpec new_module_spec(FileSpec(memory_info.GetName().AsCString()),
                                  target.GetArchitecture());
 
       if ((module_sp = modules.FindFirstModule(new_module_spec))) {
         UpdateLoadedSections(module_sp, link_map_addr, base_addr, false);
         return module_sp;
       }
 
       if ((module_sp = target.GetSharedModule(new_module_spec))) {
         UpdateLoadedSections(module_sp, link_map_addr, base_addr, false);

source/Core/Module.cpp

if (section_sp && section_sp->GetModule().get() == this) {
     }
   }
   return resolved_flags;
 }
 
 uint32_t Module::ResolveSymbolContextForFilePath(
     const char *file_path, uint32_t line, bool check_inlines,
     lldb::SymbolContextItem resolve_scope, SymbolContextList &sc_list) {
-  FileSpec file_spec(file_path, false);
+  FileSpec file_spec(file_path);
   return ResolveSymbolContextsForFileSpec(file_spec, line, check_inlines,
                                           resolve_scope, sc_list);
 }
 
 uint32_t Module::ResolveSymbolContextsForFileSpec(
     const FileSpec &file_spec, uint32_t line, bool check_inlines,
     lldb::SymbolContextItem resolve_scope, SymbolContextList &sc_list) {
   std::lock_guard<std::recursive_mutex> guard(m_mutex);

source/Core/ModuleList.cpp

ModuleList::ResolveSymbolContextForAddress(const Address &so_addr,
   }
 
   return resolved_flags;
 }
 
 uint32_t ModuleList::ResolveSymbolContextForFilePath(
     const char *file_path, uint32_t line, bool check_inlines,
     SymbolContextItem resolve_scope, SymbolContextList &sc_list) const {
-  FileSpec file_spec(file_path, false);
+  FileSpec file_spec(file_path);
   return ResolveSymbolContextsForFileSpec(file_spec, line, check_inlines,
                                           resolve_scope, sc_list);
 }
 
 uint32_t ModuleList::ResolveSymbolContextsForFileSpec(
     const FileSpec &file_spec, uint32_t line, bool check_inlines,
     SymbolContextItem resolve_scope, SymbolContextList &sc_list) const {
   std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
Status ModuleList::GetSharedModule(const ModuleSpec &module_spec,
   } else {
     module_sp.reset();
   }
 
   if (module_search_paths_ptr) {
     const auto num_directories = module_search_paths_ptr->GetSize();
     for (size_t idx = 0; idx < num_directories; ++idx) {
       auto search_path_spec = module_search_paths_ptr->GetFileSpecAtIndex(idx);
-      if (!search_path_spec.ResolvePath())
-        continue;
+      FileSystem::Instance().Resolve(search_path_spec);
       namespace fs = llvm::sys::fs;
       if (!fs::is_directory(search_path_spec.GetPath()))
         continue;
       search_path_spec.AppendPathComponent(
           module_spec.GetFileSpec().GetFilename().AsCString());
       if (!FileSystem::Instance().Exists(search_path_spec))
         continue;
 

source/Core/PluginManager.cpp

LoadPluginCallback(void *baton, llvm::sys::fs::file_type ft,
 
   namespace fs = llvm::sys::fs;
   // If we have a regular file, a symbolic link or unknown file type, try and
   // process the file. We must handle unknown as sometimes the directory
   // enumeration might be enumerating a file system that doesn't have correct
   // file type information.
   if (ft == fs::file_type::regular_file || ft == fs::file_type::symlink_file ||
       ft == fs::file_type::type_unknown) {
-    FileSpec plugin_file_spec(path, false);
-    plugin_file_spec.ResolvePath();
+    FileSpec plugin_file_spec(path);
+    FileSystem::Instance().Resolve(plugin_file_spec);
 
     if (PluginIsLoaded(plugin_file_spec))
       return FileSystem::eEnumerateDirectoryResultNext;
     else {
       PluginInfo plugin_info;
 
       std::string pluginLoadError;
       plugin_info.library = llvm::sys::DynamicLibrary::getPermanentLibrary(

source/Core/SearchFilter.cpp

SearchFilterSP SearchFilterByModule::CreateFromStructuredData(
   }
 
   llvm::StringRef module;
   success = modules_array->GetItemAtIndexAsString(0, module);
   if (!success) {
     error.SetErrorString("SFBM::CFSD: filter module item not a string.");
     return nullptr;
   }
-  FileSpec module_spec(module, false);
+  FileSpec module_spec(module);
 
   return std::make_shared<SearchFilterByModule>(target.shared_from_this(),
                                                 module_spec);
 }
 
 StructuredData::ObjectSP SearchFilterByModule::SerializeToStructuredData() {
   auto options_dict_sp = std::make_shared<StructuredData::Dictionary>();
   auto module_array_sp = std::make_shared<StructuredData::Array>();
if (success) {
     for (size_t i = 0; i < num_modules; i++) {
       llvm::StringRef module;
       success = modules_array->GetItemAtIndexAsString(i, module);
       if (!success) {
         error.SetErrorStringWithFormat(
             "SFBM::CFSD: filter module item %zu not a string.", i);
         return nullptr;
       }
-      modules.Append(FileSpec(module, false));
+      modules.Append(FileSpec(module));
     }
   }
 
   return std::make_shared<SearchFilterByModuleList>(target.shared_from_this(),
                                                     modules);
 }
 
 void SearchFilterByModuleList::SerializeUnwrapped(
if (success) {
     for (size_t i = 0; i < num_modules; i++) {
       llvm::StringRef module;
       success = modules_array->GetItemAtIndexAsString(i, module);
       if (!success) {
         error.SetErrorStringWithFormat(
             "SFBM::CFSD: filter module item %zu not a string.", i);
         return result_sp;
       }
-      modules.Append(FileSpec(module, false));
+      modules.Append(FileSpec(module));
     }
   }
 
   StructuredData::Array *cus_array = nullptr;
   success =
       data_dict.GetValueForKeyAsArray(GetKey(OptionNames::CUList), cus_array);
   if (!success) {
     error.SetErrorString("SFBM::CFSD: Could not find the CU list key.");
     return result_sp;
   }
 
   size_t num_cus = cus_array->GetSize();
   FileSpecList cus;
   for (size_t i = 0; i < num_cus; i++) {
     llvm::StringRef cu;
     success = cus_array->GetItemAtIndexAsString(i, cu);
     if (!success) {
       error.SetErrorStringWithFormat(
           "SFBM::CFSD: filter cu item %zu not a string.", i);
       return nullptr;
     }
-    cus.Append(FileSpec(cu, false));
+    cus.Append(FileSpec(cu));
   }
 
   return std::make_shared<SearchFilterByModuleListAndCU>(
       target.shared_from_this(), modules, cus);
 }
 
 StructuredData::ObjectSP
 SearchFilterByModuleListAndCU::SerializeToStructuredData() {

source/Expression/REPL.cpp

 
 std::string REPL::GetSourcePath() {
   ConstString file_basename = GetSourceFileBasename();
   FileSpec tmpdir_file_spec = HostInfo::GetProcessTempDir();
   if (tmpdir_file_spec) {
     tmpdir_file_spec.GetFilename().SetCString(file_basename.AsCString());
     m_repl_source_path = tmpdir_file_spec.GetPath();
   } else {
-    tmpdir_file_spec = FileSpec("/tmp", false);
+    tmpdir_file_spec = FileSpec("/tmp");
     tmpdir_file_spec.AppendPathComponent(file_basename.AsCString());
   }
 
   return tmpdir_file_spec.GetPath();
 }
 
 lldb::IOHandlerSP REPL::GetIOHandler() {
   if (!m_io_handler_sp) {
if (code[0] == ':') {
             std::string code(m_code.CopyList());
             code.append(1, '\n');
             size_t bytes_written = code.size();
             file.Write(code.c_str(), bytes_written);
             file.Close();
 
             // Now set the default file and line to the REPL source file
             m_target.GetSourceManager().SetDefaultFileAndLine(
-                FileSpec(m_repl_source_path, false), new_default_line);
+                FileSpec(m_repl_source_path), new_default_line);
           }
           static_cast<IOHandlerEditline &>(io_handler)
               .SetBaseLineNumber(m_code.GetSize() + 1);
         }
         if (extra_line) {
           fprintf(output_sp->GetFile().GetStream(), "\n");
         }
       }

source/Host/common/Editline.cpp

 //===-- Editline.cpp --------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include <iomanip>
 #include <iostream>
 #include <limits.h>
 
 #include "lldb/Host/ConnectionFileDescriptor.h"
 #include "lldb/Host/Editline.h"
+#include "lldb/Host/FileSystem.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/LLDBAssert.h"
 #include "lldb/Utility/SelectHelper.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/StreamString.h"
 #include "lldb/Utility/StringList.h"
 #include "lldb/Utility/Timeout.h"
EditlineHistory(const std::string &prefix, uint32_t size, bool unique_entries)
     m_history = history_winit();
     history_w(m_history, &m_event, H_SETSIZE, size);
     if (unique_entries)
       history_w(m_history, &m_event, H_SETUNIQUE, 1);
   }
 
   const char *GetHistoryFilePath() {
     if (m_path.empty() && m_history && !m_prefix.empty()) {
-      FileSpec parent_path{"~/.lldb", true};
+      FileSpec parent_path("~/.lldb");
+      FileSystem::Instance().Resolve(parent_path);
       char history_path[PATH_MAX];
       if (!llvm::sys::fs::create_directory(parent_path.GetPath())) {
         snprintf(history_path, sizeof(history_path), "~/.lldb/%s-history",
                  m_prefix.c_str());
       } else {
         snprintf(history_path, sizeof(history_path), "~/%s-widehistory",
                  m_prefix.c_str());
       }
-      m_path = FileSpec(history_path, true).GetPath();
+      auto file_spec = FileSpec(history_path);
+      FileSystem::Instance().Resolve(file_spec);
+      m_path = file_spec.GetPath();
     }
     if (m_path.empty())
       return NULL;
     return m_path.c_str();
   }
 
 public:
   ~EditlineHistory() {

source/Host/common/File.cpp

 Status File::GetFileSpec(FileSpec &file_spec) const {
   Status error;
 #ifdef F_GETPATH
   if (IsValid()) {
     char path[PATH_MAX];
     if (::fcntl(GetDescriptor(), F_GETPATH, path) == -1)
       error.SetErrorToErrno();
     else
-      file_spec.SetFile(path, false, FileSpec::Style::native);
+      file_spec.SetFile(path, FileSpec::Style::native);
   } else {
     error.SetErrorString("invalid file handle");
   }
 #elif defined(__linux__)
   char proc[64];
   char path[PATH_MAX];
   if (::snprintf(proc, sizeof(proc), "/proc/self/fd/%d", GetDescriptor()) < 0)
     error.SetErrorString("cannot resolve file descriptor");

source/Host/common/FileSystem.cpp

 std::error_code FileSystem::MakeAbsolute(FileSpec &file_spec) const {
   SmallString<128> path;
   file_spec.GetPath(path, false);
 
   auto EC = MakeAbsolute(path);
   if (EC)
     return EC;
 
-  FileSpec new_file_spec(path, false, file_spec.GetPathStyle());
+  FileSpec new_file_spec(path, file_spec.GetPathStyle());
   file_spec = new_file_spec;
   return {};
 }
 
 std::error_code FileSystem::GetRealPath(const Twine &path,
                                         SmallVectorImpl<char> &output) const {
   return m_fs->getRealPath(path, output);
 }
void FileSystem::Resolve(FileSpec &file_spec) {
   SmallString<128> path;
   file_spec.GetPath(path);
 
   // Resolve the path.
   Resolve(path);
 
   // Update the FileSpec with the resolved path.
   file_spec.SetPath(path);
+  file_spec.SetIsResolved(true);
 }
 
 bool FileSystem::ResolveFileLocation(FileSpec &file_spec) {
   // If the directory is set there's nothing to do.
   const ConstString &directory = file_spec.GetDirectory();
   if (directory)
     return false;
 
bool FileSystem::ResolveFileLocation(FileSpec &file_spec) {
 
   // findProgramByName returns "." if it can't find the file.
   llvm::StringRef path = *error_or_path;
   llvm::StringRef parent = llvm::sys::path::parent_path(path);
   if (parent.empty() || parent == ".")
     return false;
 
   // Make sure that the result exists.
-  FileSpec result(*error_or_path, false);
+  FileSpec result(*error_or_path);
   if (!Exists(result))
     return false;
 
   file_spec = result;
   return true;
 }

source/Host/common/Host.cpp

 
 #ifndef _WIN32
 
 FileSpec Host::GetModuleFileSpecForHostAddress(const void *host_addr) {
   FileSpec module_filespec;
 #if !defined(__ANDROID__)
   Dl_info info;
   if (::dladdr(host_addr, &info)) {
-    if (info.dli_fname)
-      module_filespec.SetFile(info.dli_fname, true, FileSpec::Style::native);
+    if (info.dli_fname) {
+      module_filespec.SetFile(info.dli_fname, FileSpec::Style::native);
+      FileSystem::Instance().Resolve(module_filespec);
+    }
   }
 #endif
   return module_filespec;
 }
 
 #endif
 
 #if !defined(__linux__)
if (FileSpec tmpdir_file_spec = HostInfo::GetProcessTempDir()) {
       llvm::sys::fs::createUniqueFile(tmpdir_file_spec.GetPath(),
                                       output_file_path);
     } else {
       llvm::sys::fs::createTemporaryFile("lldb-shell-output.%%%%%%", "",
                                          output_file_path);
     }
   }
 
-  FileSpec output_file_spec{output_file_path.c_str(), false};
+  FileSpec output_file_spec(output_file_path.c_str());
 
   launch_info.AppendSuppressFileAction(STDIN_FILENO, true, false);
   if (output_file_spec) {
     launch_info.AppendOpenFileAction(STDOUT_FILENO, output_file_spec, false,
                                      true);
     launch_info.AppendDuplicateFileAction(STDOUT_FILENO, STDERR_FILENO);
   } else {
     launch_info.AppendSuppressFileAction(STDOUT_FILENO, false, true);

source/Host/common/HostInfoBase.cpp

bool HostInfoBase::ComputeProcessTempFileDirectory(FileSpec &file_spec) {
 
   file_spec.GetDirectory().SetCString(temp_file_spec.GetCString());
   return true;
 }
 
 bool HostInfoBase::ComputeTempFileBaseDirectory(FileSpec &file_spec) {
   llvm::SmallVector<char, 16> tmpdir;
   llvm::sys::path::system_temp_directory(/*ErasedOnReboot*/ true, tmpdir);
-  file_spec = FileSpec(std::string(tmpdir.data(), tmpdir.size()), true);
+  file_spec = FileSpec(std::string(tmpdir.data(), tmpdir.size()));
+  FileSystem::Instance().Resolve(file_spec);
   return true;
 }
 
 bool HostInfoBase::ComputeGlobalTempFileDirectory(FileSpec &file_spec) {
   file_spec.Clear();
 
   FileSpec temp_file_spec;
   if (!HostInfo::ComputeTempFileBaseDirectory(temp_file_spec))

source/Host/common/MonitoringProcessLauncher.cpp

MonitoringProcessLauncher::LaunchProcess(const ProcessLaunchInfo &launch_info,
 
   error.Clear();
 
   FileSpec exe_spec(resolved_info.GetExecutableFile());
 
   llvm::sys::fs::file_status stats;
   status(exe_spec.GetPath(), stats);
   if (!exists(stats)) {
-    exe_spec.ResolvePath();
+    FileSystem::Instance().Resolve(exe_spec);
     status(exe_spec.GetPath(), stats);
   }
   if (!exists(stats)) {
     FileSystem::Instance().ResolveFileLocation(exe_spec);
     status(exe_spec.GetPath(), stats);
   }
 
   if (!exists(stats)) {

source/Host/common/Symbols.cpp

FileSpecList debug_file_search_paths(
         Target::GetDefaultDebugFileSearchPaths());
 
     // Add module directory.
     FileSpec module_file_spec = module_spec.GetFileSpec();
     // We keep the unresolved pathname if it fails.
     FileSystem::Instance().ResolveSymbolicLink(module_file_spec, module_file_spec);
 
     const ConstString &file_dir = module_file_spec.GetDirectory();
-    debug_file_search_paths.AppendIfUnique(
-        FileSpec(file_dir.AsCString("."), true));
+    {
+      FileSpec file_spec(file_dir.AsCString("."));
+      FileSystem::Instance().Resolve(file_spec);
+      debug_file_search_paths.AppendIfUnique(file_spec);
+    }
 
     // Add current working directory.
-    debug_file_search_paths.AppendIfUnique(FileSpec(".", true));
+    {
+      FileSpec file_spec(".");
+      FileSystem::Instance().Resolve(file_spec);
+      debug_file_search_paths.AppendIfUnique(file_spec);
+    }
 
 #ifndef _WIN32
 #if defined(__NetBSD__)
     // Add /usr/libdata/debug directory.
-    debug_file_search_paths.AppendIfUnique(
-        FileSpec("/usr/libdata/debug", true));
+    {
+      FileSpec file_spec("/usr/libdata/debug");
+      FileSystem::Instance().Resolve(file_spec);
+      debug_file_search_paths.AppendIfUnique(file_spec);
+    }
 #else
     // Add /usr/lib/debug directory.
-    debug_file_search_paths.AppendIfUnique(FileSpec("/usr/lib/debug", true));
+    {
+      FileSpec file_spec("/usr/lib/debug");
+      FileSystem::Instance().Resolve(file_spec);
+      debug_file_search_paths.AppendIfUnique(file_spec);
+    }
 #endif
 #endif // _WIN32
 
     std::string uuid_str;
     const UUID &module_uuid = module_spec.GetUUID();
     if (module_uuid.IsValid()) {
       // Some debug files are stored in the .build-id directory like this:
       //   /usr/lib/debug/.build-id/ff/e7fe727889ad82bb153de2ad065b2189693315.debug
       uuid_str = module_uuid.GetAsString("");
       std::transform(uuid_str.begin(), uuid_str.end(), uuid_str.begin(),
           ::tolower);
       uuid_str.insert(2, 1, '/');
       uuid_str = uuid_str + ".debug";
     }
 
     size_t num_directories = debug_file_search_paths.GetSize();
     for (size_t idx = 0; idx < num_directories; ++idx) {
       FileSpec dirspec = debug_file_search_paths.GetFileSpecAtIndex(idx);
-      dirspec.ResolvePath();
+      FileSystem::Instance().Resolve(dirspec);
       if (!llvm::sys::fs::is_directory(dirspec.GetPath()))
         continue;
 
       std::vector<std::string> files;
       std::string dirname = dirspec.GetPath();
 
       files.push_back(dirname + "/" + symbol_filename);
       files.push_back(dirname + "/.debug/" + symbol_filename);
       files.push_back(dirname + "/.build-id/" + uuid_str);
 
       // Some debug files may stored in the module directory like this:
       //   /usr/lib/debug/usr/lib/library.so.debug
       if (!file_dir.IsEmpty())
         files.push_back(dirname + file_dir.AsCString() + "/" + symbol_filename);
 
       const uint32_t num_files = files.size();
       for (size_t idx_file = 0; idx_file < num_files; ++idx_file) {
         const std::string &filename = files[idx_file];
-        FileSpec file_spec(filename, true);
+        FileSpec file_spec(filename);
+        FileSystem::Instance().Resolve(file_spec);
 
         if (llvm::sys::fs::equivalent(file_spec.GetPath(),
                                       module_file_spec.GetPath()))
           continue;
 
         if (FileSystem::Instance().Exists(file_spec)) {
           lldb_private::ModuleSpecList specs;
           const size_t num_specs =

source/Host/macosx/Symbols.cpp

if (module_uuid.size() == 16) {
         if (dsym_url.get()) {
           if (::CFURLGetFileSystemRepresentation(
                   dsym_url.get(), true, (UInt8 *)path, sizeof(path) - 1)) {
             if (log) {
               log->Printf("DebugSymbols framework returned dSYM path of %s for "
                           "UUID %s -- looking for the dSYM",
                           path, uuid->GetAsString().c_str());
             }
-            FileSpec dsym_filespec(path, path[0] == '~');
+            FileSpec dsym_filespec(path);
+            if (path[0] == '~')
+              FileSystem::Instance().Resolve(dsym_filespec);
 
             if (llvm::sys::fs::is_directory(dsym_filespec.GetPath())) {
               dsym_filespec =
                   Symbols::FindSymbolFileInBundle(dsym_filespec, uuid, arch);
               ++items_found;
             } else {
               ++items_found;
             }
if (module_uuid.size() == 16) {
                     uuid_dict, CFSTR("DBGSymbolRichExecutable")));
             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] == '~');
+              FileSpec exec_filespec(path);
+              if (path[0] == '~')
+                FileSystem::Instance().Resolve(exec_filespec);
               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
             // matches...
             if (::CFURLGetFileSystemRepresentation(
                     dsym_url.get(), true, (UInt8 *)path, sizeof(path) - 1)) {
               char *dsym_extension_pos = ::strstr(path, ".dSYM");
               if (dsym_extension_pos) {
                 *dsym_extension_pos = '\0';
                 if (log) {
                   log->Printf("Looking for executable binary next to dSYM "
                               "bundle with name with name %s",
                               path);
                 }
-                FileSpec file_spec(path, true);
+                FileSpec file_spec(path);
+                FileSystem::Instance().Resolve(file_spec);
                 ModuleSpecList module_specs;
                 ModuleSpec matched_module_spec;
                 using namespace llvm::sys::fs;
                 switch (get_file_type(file_spec.GetPath())) {
 
                 case file_type::directory_file: // Bundle directory?
                 {
                   CFCBundle bundle(path);
                   CFCReleaser<CFURLRef> bundle_exe_url(
                       bundle.CopyExecutableURL());
                   if (bundle_exe_url.get()) {
                     if (::CFURLGetFileSystemRepresentation(bundle_exe_url.get(),
                                                            true, (UInt8 *)path,
                                                            sizeof(path) - 1)) {
-                      FileSpec bundle_exe_file_spec(path, true);
+                      FileSpec bundle_exe_file_spec(path);
+                      FileSystem::Instance().Resolve(bundle_exe_file_spec);
                       if (ObjectFile::GetModuleSpecifications(
                               bundle_exe_file_spec, 0, 0, module_specs) &&
                           module_specs.FindMatchingModuleSpec(
                               module_spec, matched_module_spec))
 
                       {
                         ++items_found;
                         return_module_spec.GetFileSpec() = bundle_exe_file_spec;
if (uuid_dict != NULL && CFGetTypeID(uuid_dict) == CFDictionaryGetTypeID()) {
     std::string str;
     CFStringRef cf_str;
     CFDictionaryRef cf_dict;
 
     cf_str = (CFStringRef)CFDictionaryGetValue(
         (CFDictionaryRef)uuid_dict, CFSTR("DBGSymbolRichExecutable"));
     if (cf_str && CFGetTypeID(cf_str) == CFStringGetTypeID()) {
       if (CFCString::FileSystemRepresentation(cf_str, str)) {
-        module_spec.GetFileSpec().SetFile(str.c_str(), true,
-                                          FileSpec::Style::native);
+        module_spec.GetFileSpec().SetFile(str.c_str(), FileSpec::Style::native);
+        FileSystem::Instance().Resolve(module_spec.GetFileSpec());
         if (log) {
           log->Printf(
               "From dsymForUUID plist: Symbol rich executable is at '%s'",
               str.c_str());
         }
       }
     }
 
     cf_str = (CFStringRef)CFDictionaryGetValue((CFDictionaryRef)uuid_dict,
                                                CFSTR("DBGDSYMPath"));
     if (cf_str && CFGetTypeID(cf_str) == CFStringGetTypeID()) {
       if (CFCString::FileSystemRepresentation(cf_str, str)) {
-        module_spec.GetSymbolFileSpec().SetFile(str.c_str(), true,
+        module_spec.GetSymbolFileSpec().SetFile(str.c_str(),
                                                 FileSpec::Style::native);
+        FileSystem::Instance().Resolve(module_spec.GetFileSpec());
         success = true;
         if (log) {
           log->Printf("From dsymForUUID plist: dSYM is at '%s'", str.c_str());
         }
       }
     }
 
     cf_str = (CFStringRef)CFDictionaryGetValue((CFDictionaryRef)uuid_dict,
if (cf_dict && CFGetTypeID(cf_dict) == CFDictionaryGetTypeID()) {
             // DBGSourcePath values (the "values" half of key-value path pairs)
             // were wrong.  Ignore them and use the universal DBGSourcePath
             // string from earlier.
             if (new_style_source_remapping_dictionary == true &&
                 !original_DBGSourcePath_value.empty()) {
               DBGSourcePath = original_DBGSourcePath_value;
             }
             if (DBGSourcePath[0] == '~') {
-              FileSpec resolved_source_path(DBGSourcePath.c_str(), true);
+              FileSpec resolved_source_path(DBGSourcePath.c_str());
+              FileSystem::Instance().Resolve(resolved_source_path);
               DBGSourcePath = resolved_source_path.GetPath();
             }
             // With version 2 of DBGSourcePathRemapping, we can chop off the
             // last two filename parts from the source remapping and get a more
             // general source remapping that still works. Add this as another
             // option in addition to the full source path remap.
             module_spec.GetSourceMappingList().Append(
                 ConstString(DBGBuildSourcePath.c_str()),
                 ConstString(DBGSourcePath.c_str()), true);
             if (do_truncate_remapping_names) {
-              FileSpec build_path(DBGBuildSourcePath.c_str(), false);
-              FileSpec source_path(DBGSourcePath.c_str(), false);
+              FileSpec build_path(DBGBuildSourcePath.c_str());
+              FileSpec source_path(DBGSourcePath.c_str());
               build_path.RemoveLastPathComponent();
               build_path.RemoveLastPathComponent();
               source_path.RemoveLastPathComponent();
               source_path.RemoveLastPathComponent();
               module_spec.GetSourceMappingList().Append(
                 ConstString(build_path.GetPath().c_str()),
                 ConstString(source_path.GetPath().c_str()), true);
             }
if (uuid_dict != NULL && CFGetTypeID(uuid_dict) == CFDictionaryGetTypeID()) {
     cf_str = (CFStringRef)CFDictionaryGetValue((CFDictionaryRef)uuid_dict,
                                                CFSTR("DBGSourcePath"));
     if (cf_str && CFGetTypeID(cf_str) == CFStringGetTypeID()) {
       CFCString::FileSystemRepresentation(cf_str, DBGSourcePath);
     }
 
     if (!DBGBuildSourcePath.empty() && !DBGSourcePath.empty()) {
       if (DBGSourcePath[0] == '~') {
-        FileSpec resolved_source_path(DBGSourcePath.c_str(), true);
+        FileSpec resolved_source_path(DBGSourcePath.c_str());
+        FileSystem::Instance().Resolve(resolved_source_path);
         DBGSourcePath = resolved_source_path.GetPath();
       }
       module_spec.GetSourceMappingList().Append(
           ConstString(DBGBuildSourcePath.c_str()),
           ConstString(DBGSourcePath.c_str()), true);
     }
   }
   return success;
if (uuid_ptr ||
     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,
+        dsym_for_uuid_exe_spec.SetFile(dsym_for_uuid_exe_path_cstr,
                                        FileSpec::Style::native);
+        FileSystem::Instance().Resolve(dsym_for_uuid_exe_spec);
         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,
+        dsym_for_uuid_exe_spec.SetFile("/usr/local/bin/dsymForUUID",
                                        FileSpec::Style::native);
         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,
+              dsym_for_uuid_exe_spec.SetFile(dsymforuuid_path.c_str(),
                                              FileSpec::Style::native);
               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,
+        dsym_for_uuid_exe_spec.SetFile(g_dbgshell_command,
                                        FileSpec::Style::native);
+        FileSystem::Instance().Resolve(dsym_for_uuid_exe_spec);
         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));
     }

source/Host/macosx/objcxx/Host.mm

 bool Host::GetBundleDirectory(const FileSpec &file,
                               FileSpec &bundle_directory) {
 #if defined(__APPLE__)
   if (llvm::sys::fs::is_directory(file.GetPath())) {
     char path[PATH_MAX];
     if (file.GetPath(path, sizeof(path))) {
       CFCBundle bundle(path);
       if (bundle.GetPath(path, sizeof(path))) {
-        bundle_directory.SetFile(path, false, FileSpec::Style::native);
+        bundle_directory.SetFile(path, FileSpec::Style::native);
         return true;
       }
     }
   }
 #endif
   bundle_directory.Clear();
   return false;
 }
 
 bool Host::ResolveExecutableInBundle(FileSpec &file) {
 #if defined(__APPLE__)
   if (llvm::sys::fs::is_directory(file.GetPath())) {
     char path[PATH_MAX];
     if (file.GetPath(path, sizeof(path))) {
       CFCBundle bundle(path);
       CFCReleaser<CFURLRef> url(bundle.CopyExecutableURL());
       if (url.get()) {
         if (::CFURLGetFileSystemRepresentation(url.get(), YES, (UInt8 *)path,
                                                sizeof(path))) {
-          file.SetFile(path, false, FileSpec::Style::native);
+          file.SetFile(path, FileSpec::Style::native);
           return true;
         }
       }
     }
   }
 #endif
   return false;
 }
if (::sysctl(proc_args_mib, 3, arg_data.GetBytes(), &arg_data_size, NULL,
       uint32_t argc = data.GetU32(&offset);
       llvm::Triple &triple = process_info.GetArchitecture().GetTriple();
       const llvm::Triple::ArchType triple_arch = triple.getArch();
       const bool check_for_ios_simulator =
           (triple_arch == llvm::Triple::x86 ||
            triple_arch == llvm::Triple::x86_64);
       const char *cstr = data.GetCStr(&offset);
       if (cstr) {
-        process_info.GetExecutableFile().SetFile(cstr, false,
-                                                 FileSpec::Style::native);
+        process_info.GetExecutableFile().SetFile(cstr, FileSpec::Style::native);
 
         if (match_info_ptr == NULL ||
             NameMatches(
                 process_info.GetExecutableFile().GetFilename().GetCString(),
                 match_info_ptr->GetNameMatchType(),
                 match_info_ptr->GetProcessInfo().GetName())) {
           // Skip NULLs
           while (1) {

 
 Status Host::LaunchProcess(ProcessLaunchInfo &launch_info) {
   Status error;
   FileSpec exe_spec(launch_info.GetExecutableFile());
 
   llvm::sys::fs::file_status stats;
   status(exe_spec.GetPath(), stats);
   if (!exists(stats)) {
-    exe_spec.ResolvePath();
+    FileSystem::Instance().Resolve(exe_spec);
     status(exe_spec.GetPath(), stats);
   }
   if (!exists(stats)) {
     FileSystem::Instance().ResolveFileLocation(exe_spec);
     status(exe_spec.GetPath(), stats);
   }
   if (!exists(stats)) {
     error.SetErrorStringWithFormatv("executable doesn't exist: '{0}'",
if (launch_info.GetFlags().Test(eLaunchFlagShellExpandArguments)) {
     FileSpec cwd(launch_info.GetWorkingDirectory());
     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);
+        FileSpec working_dir(wd);
         free(wd);
         launch_info.SetWorkingDirectory(working_dir);
       }
     }
     RunShellCommand(expand_command, cwd, &status, nullptr, &output,
                     std::chrono::seconds(10));
 
     if (status != 0) {

source/Host/macosx/objcxx/HostInfoMacOSX.mm

 //===-- HostInfoMacOSX.mm ---------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
-#include "lldb/Host/HostInfo.h"
 #include "lldb/Host/macosx/HostInfoMacOSX.h"
+#include "lldb/Host/FileSystem.h"
+#include "lldb/Host/HostInfo.h"
 #include "lldb/Utility/Args.h"
 #include "lldb/Utility/Log.h"
 
 #include "llvm/ADT/SmallString.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/raw_ostream.h"
 

 FileSpec HostInfoMacOSX::GetProgramFileSpec() {
   static FileSpec g_program_filespec;
   if (!g_program_filespec) {
     char program_fullpath[PATH_MAX];
     // If DST is NULL, then return the number of bytes needed.
     uint32_t len = sizeof(program_fullpath);
     int err = _NSGetExecutablePath(program_fullpath, &len);
     if (err == 0)
-      g_program_filespec.SetFile(program_fullpath, false,
-                                 FileSpec::Style::native);
+      g_program_filespec.SetFile(program_fullpath, FileSpec::Style::native);
     else if (err == -1) {
       char *large_program_fullpath = (char *)::malloc(len + 1);
 
       err = _NSGetExecutablePath(large_program_fullpath, &len);
       if (err == 0)
-        g_program_filespec.SetFile(large_program_fullpath, false,
+        g_program_filespec.SetFile(large_program_fullpath,
                                    FileSpec::Style::native);
 
       ::free(large_program_fullpath);
     }
   }
   return g_program_filespec;
 }
 
#endif
     // Find the bin path relative to the lib path where the cmake-based
     // OS X .dylib lives.  This is not going to work if the bin and lib
     // dir are not both in the same dir.
     //
     // It is not going to work to do it by the executable path either,
     // as in the case of a python script, the executable is python, not
     // the lldb driver.
     raw_path.append("/../bin");
-    FileSpec support_dir_spec(raw_path, true);
+    FileSpec support_dir_spec(raw_path);
+    FileSystem::Instance().Resolve(support_dir_spec);
     if (!llvm::sys::fs::is_directory(support_dir_spec.GetPath())) {
       Log *log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_HOST);
       if (log)
         log->Printf("HostInfoMacOSX::%s(): failed to find support directory",
                     __FUNCTION__);
       return false;
     }
 
bool HostInfoMacOSX::ComputeSystemPluginsDirectory(FileSpec &file_spec) {
   raw_path.resize(framework_pos);
   raw_path.append("/Resources/PlugIns");
   file_spec.GetDirectory().SetString(
       llvm::StringRef(raw_path.c_str(), raw_path.size()));
   return true;
 }
 
 bool HostInfoMacOSX::ComputeUserPluginsDirectory(FileSpec &file_spec) {
-  FileSpec temp_file("~/Library/Application Support/LLDB/PlugIns", true);
+  FileSpec temp_file("~/Library/Application Support/LLDB/PlugIns");
+  FileSystem::Instance().Resolve(temp_file);
   file_spec.GetDirectory().SetCString(temp_file.GetPath().c_str());
   return true;
 }
 
 void HostInfoMacOSX::ComputeHostArchitectureSupport(ArchSpec &arch_32,
                                                     ArchSpec &arch_64) {
   // All apple systems support 32 bit execution.
   uint32_t cputype, cpusubtype;

source/Host/posix/FileSystem.cpp

 Status FileSystem::Readlink(const FileSpec &src, FileSpec &dst) {
   Status error;
   char buf[PATH_MAX];
   ssize_t count = ::readlink(src.GetCString(), buf, sizeof(buf) - 1);
   if (count < 0)
     error.SetErrorToErrno();
   else {
     buf[count] = '\0'; // Success
-    dst.SetFile(buf, false, FileSpec::Style::native);
+    dst.SetFile(buf, FileSpec::Style::native);
   }
   return error;
 }
 
 Status FileSystem::ResolveSymbolicLink(const FileSpec &src, FileSpec &dst) {
   char resolved_path[PATH_MAX];
   if (!src.GetPath(resolved_path, sizeof(resolved_path))) {
     return Status("Couldn't get the canonical path for %s", src.GetCString());
   }
 
   char real_path[PATH_MAX + 1];
   if (realpath(resolved_path, real_path) == nullptr) {
     Status err;
     err.SetErrorToErrno();
     return err;
   }
 
-  dst = FileSpec(real_path, false);
+  dst = FileSpec(real_path);
 
   return Status();
 }
 
 FILE *FileSystem::Fopen(const char *path, const char *mode) {
   return ::fopen(path, mode);
 }

source/Host/posix/HostInfoPosix.cpp

 uint32_t HostInfoPosix::GetUserID() { return getuid(); }
 
 uint32_t HostInfoPosix::GetGroupID() { return getgid(); }
 
 uint32_t HostInfoPosix::GetEffectiveUserID() { return geteuid(); }
 
 uint32_t HostInfoPosix::GetEffectiveGroupID() { return getegid(); }
 
-FileSpec HostInfoPosix::GetDefaultShell() { return FileSpec("/bin/sh", false); }
+FileSpec HostInfoPosix::GetDefaultShell() { return FileSpec("/bin/sh"); }
 
 bool HostInfoPosix::ComputePathRelativeToLibrary(FileSpec &file_spec,
                                                  llvm::StringRef dir) {
   Log *log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_HOST);
 
   FileSpec lldb_file_spec = GetShlibDir();
   if (!lldb_file_spec)
     return false;
bool HostInfoPosix::ComputePathRelativeToLibrary(FileSpec &file_spec,
   return (bool)file_spec.GetDirectory();
 }
 
 bool HostInfoPosix::ComputeSupportExeDirectory(FileSpec &file_spec) {
   return ComputePathRelativeToLibrary(file_spec, "/bin");
 }
 
 bool HostInfoPosix::ComputeHeaderDirectory(FileSpec &file_spec) {
-  FileSpec temp_file("/opt/local/include/lldb", false);
+  FileSpec temp_file("/opt/local/include/lldb");
   file_spec.GetDirectory().SetCString(temp_file.GetPath().c_str());
   return true;
 }
 
 bool HostInfoPosix::GetEnvironmentVar(const std::string &var_name,
                                       std::string &var) {
   if (const char *pvar = ::getenv(var_name.c_str())) {
     var = std::string(pvar);
     return true;
   }
   return false;
 }

source/Host/posix/HostProcessPosix.cpp

Status HostProcessPosix::GetMainModule(FileSpec &file_spec) const {
 
   // Use special code here because proc/[pid]/exe is a symbolic link.
   char link_path[PATH_MAX];
   if (snprintf(link_path, PATH_MAX, "/proc/%" PRIu64 "/exe", m_process) != 1) {
     error.SetErrorString("Unable to build /proc/<pid>/exe string");
     return error;
   }
 
-  error = FileSystem::Instance().Readlink(FileSpec{link_path, false}, file_spec);
+  error = FileSystem::Instance().Readlink(FileSpec(link_path), file_spec);
   if (!error.Success())
     return error;
 
   // If the binary has been deleted, the link name has " (deleted)" appended.
   // Remove if there.
   if (file_spec.GetFilename().GetStringRef().endswith(" (deleted)")) {
     const char *filename = file_spec.GetFilename().GetCString();
     static const size_t deleted_len = strlen(" (deleted)");

source/Interpreter/CommandInterpreter.cpp

if (target) {
       // In the current working directory we don't load any program specific
       // .lldbinit files, we only look for a ".lldbinit" file.
       if (m_skip_lldbinit_files)
         return;
 
       LoadCWDlldbinitFile should_load =
           target->TargetProperties::GetLoadCWDlldbinitFile();
       if (should_load == eLoadCWDlldbinitWarn) {
-        FileSpec dot_lldb(".lldbinit", true);
+        FileSpec dot_lldb(".lldbinit");
+        FileSystem::Instance().Resolve(dot_lldb);
         llvm::SmallString<64> home_dir_path;
         llvm::sys::path::home_directory(home_dir_path);
-        FileSpec homedir_dot_lldb(home_dir_path.c_str(), false);
+        FileSpec homedir_dot_lldb(home_dir_path.c_str());
         homedir_dot_lldb.AppendPathComponent(".lldbinit");
-        homedir_dot_lldb.ResolvePath();
+        FileSystem::Instance().Resolve(homedir_dot_lldb);
         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"
               "To allow lldb to source .lldbinit files in the current working "
               "directory,\n"
               "set the value of this variable to true.  Only do so if you "
               "understand and\n"
               "accept the security risk.");
           result.SetStatus(eReturnStatusFailed);
           return;
         }
       } else if (should_load == eLoadCWDlldbinitTrue) {
-        init_file.SetFile("./.lldbinit", true, FileSpec::Style::native);
+        init_file.SetFile("./.lldbinit", FileSpec::Style::native);
+        FileSystem::Instance().Resolve(init_file);
       }
     }
   } else {
     // If we aren't looking in the current working directory we are looking in
     // the home directory. We will first see if there is an application
     // specific ".lldbinit" file whose name is "~/.lldbinit" followed by a "-"
     // and the name of the program. If this file doesn't exist, we fall back to
     // just the "~/.lldbinit" file. We also obey any requests to not load the
     // init files.
     llvm::SmallString<64> home_dir_path;
     llvm::sys::path::home_directory(home_dir_path);
-    FileSpec profilePath(home_dir_path.c_str(), false);
+    FileSpec profilePath(home_dir_path.c_str());
     profilePath.AppendPathComponent(".lldbinit");
     std::string init_file_path = profilePath.GetPath();
 
     if (m_skip_app_init_files == false) {
       FileSpec program_file_spec(HostInfo::GetProgramFileSpec());
       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);
+        init_file.SetFile(program_init_file_name, FileSpec::Style::native);
+        FileSystem::Instance().Resolve(init_file);
         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);
+      init_file.SetFile(init_file_path, 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 (FileSystem::Instance().Exists(init_file)) {
     const bool saved_batch = SetBatchCommandMode(true);

source/Interpreter/OptionValueFileSpec.cpp

if (value.size() > 0) {
       // around the file path to indicate that internal spaces are not word
       // breaks.  Strip off any ws & quotes from the start and end of the file
       // path - we aren't doing any word // breaking here so the quoting is
       // unnecessary.  NB this will cause a problem if someone tries to specify
       // a file path that legitimately begins or ends with a " or ' character,
       // or whitespace.
       value = value.trim("\"' \t");
       m_value_was_set = true;
-      m_current_value.SetFile(value.str(), m_resolve, FileSpec::Style::native);
+      m_current_value.SetFile(value.str(), FileSpec::Style::native);
+      if (m_resolve)
+        FileSystem::Instance().Resolve(m_current_value);
       m_data_sp.reset();
       m_data_mod_time = llvm::sys::TimePoint<>();
       NotifyValueChanged();
     } else {
       error.SetErrorString("invalid value string");
     }
     break;
 

source/Interpreter/OptionValueFileSpecLIst.cpp

if (argc > 1) {
           StringConvert::ToUInt32(args.GetArgumentAtIndex(0), UINT32_MAX);
       const uint32_t count = m_current_value.GetSize();
       if (idx > count) {
         error.SetErrorStringWithFormat(
             "invalid file list index %u, index must be 0 through %u", idx,
             count);
       } else {
         for (size_t i = 1; i < argc; ++i, ++idx) {
-          FileSpec file(args.GetArgumentAtIndex(i), false);
+          FileSpec file(args.GetArgumentAtIndex(i));
           if (idx < count)
             m_current_value.Replace(idx, file);
           else
             m_current_value.Append(file);
         }
         NotifyValueChanged();
       }
     } else {
       error.SetErrorString("replace operation takes an array index followed by "
                            "one or more values");
     }
     break;
 
   case eVarSetOperationAssign:
     m_current_value.Clear();
     // Fall through to append case
     LLVM_FALLTHROUGH;
   case eVarSetOperationAppend:
     if (argc > 0) {
       m_value_was_set = true;
       for (size_t i = 0; i < argc; ++i) {
-        FileSpec file(args.GetArgumentAtIndex(i), false);
+        FileSpec file(args.GetArgumentAtIndex(i));
         m_current_value.Append(file);
       }
       NotifyValueChanged();
     } else {
       error.SetErrorString(
           "assign operation takes at least one file path argument");
     }
     break;
 
   case eVarSetOperationInsertBefore:
   case eVarSetOperationInsertAfter:
     if (argc > 1) {
       uint32_t idx =
           StringConvert::ToUInt32(args.GetArgumentAtIndex(0), UINT32_MAX);
       const uint32_t count = m_current_value.GetSize();
       if (idx > count) {
         error.SetErrorStringWithFormat(
             "invalid insert file list index %u, index must be 0 through %u",
             idx, count);
       } else {
         if (op == eVarSetOperationInsertAfter)
           ++idx;
         for (size_t i = 1; i < argc; ++i, ++idx) {
-          FileSpec file(args.GetArgumentAtIndex(i), false);
+          FileSpec file(args.GetArgumentAtIndex(i));
           m_current_value.Insert(idx, file);
         }
         NotifyValueChanged();
       }
     } else {
       error.SetErrorString("insert operation takes an array index followed by "
                            "one or more values");
     }

source/Interpreter/Options.cpp

for (size_t i = 0; i < opt_element_vector.size(); i++) {
 
       // If this is the "shlib" option and there was an argument provided,
       // restrict it to that shared library.
       if (cur_opt_name && strcmp(cur_opt_name, "shlib") == 0 &&
           cur_arg_pos != -1) {
         const char *module_name =
             request.GetParsedLine().GetArgumentAtIndex(cur_arg_pos);
         if (module_name) {
-          FileSpec module_spec(module_name, false);
+          FileSpec module_spec(module_name);
           lldb::TargetSP target_sp =
               interpreter.GetDebugger().GetSelectedTarget();
           // Search filters require a target...
           if (target_sp)
             filter_ap.reset(new SearchFilterByModule(target_sp, module_spec));
         }
         break;
       }

source/Interpreter/Property.cpp

// default value.
       }
     }
     break;
 
   case OptionValue::eTypeFileSpec: {
     // "definition.default_uint_value" represents if the
     // "definition.default_cstr_value" should be resolved or not
     const bool resolve = definition.default_uint_value != 0;
-    m_value_sp.reset(new OptionValueFileSpec(
-        FileSpec(definition.default_cstr_value, resolve), resolve));
+    FileSpec file_spec = FileSpec(definition.default_cstr_value);
+    if (resolve)
+      FileSystem::Instance().Resolve(file_spec);
+    m_value_sp.reset(new OptionValueFileSpec(file_spec, resolve));
     break;
   }
 
   case OptionValue::eTypeFileSpecList:
     // "definition.default_uint_value" is not used for a
     // OptionValue::eTypeFileSpecList
     m_value_sp.reset(new OptionValueFileSpecList());
     break;

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

DynamicLoaderDarwinKernel::CheckForKernelImageAtAddress(lldb::addr_t addr,
   // First try a quick test -- read the first 4 bytes and see if there is a
   // valid Mach-O magic field there
   // (the first field of the mach_header/mach_header_64 struct).
   // A kernel is an executable which does not have the dynamic link object flag
   // set.
   if (header.filetype == llvm::MachO::MH_EXECUTE &&
       (header.flags & llvm::MachO::MH_DYLDLINK) == 0) {
     // Create a full module to get the UUID
-    ModuleSP memory_module_sp = process->ReadModuleFromMemory(
-        FileSpec("temp_mach_kernel", false), addr);
+    ModuleSP memory_module_sp =
+        process->ReadModuleFromMemory(FileSpec("temp_mach_kernel"), addr);
     if (!memory_module_sp.get())
       return UUID();
 
     ObjectFile *exe_objfile = memory_module_sp->GetObjectFile();
     if (exe_objfile == NULL) {
       if (log)
         log->Printf("DynamicLoaderDarwinKernel::CheckForKernelImageAtAddress "
                     "found a binary at 0x%" PRIx64

 bool DynamicLoaderDarwinKernel::KextImageInfo::ReadMemoryModule(
     Process *process) {
   Log *log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_HOST);
   if (m_memory_module_sp.get() != NULL)
     return true;
   if (m_load_address == LLDB_INVALID_ADDRESS)
     return false;
 
-  FileSpec file_spec;
-  file_spec.SetFile(m_name.c_str(), false, FileSpec::Style::native);
+  FileSpec file_spec(m_name.c_str());
 
   llvm::MachO::mach_header mh;
   size_t size_to_read = 512;
   if (ReadMachHeader(m_load_address, process, mh)) {
     if (mh.magic == llvm::MachO::MH_CIGAM || mh.magic == llvm::MachO::MH_MAGIC)
       size_to_read = sizeof(llvm::MachO::mach_header) + mh.sizeofcmds;
     if (mh.magic == llvm::MachO::MH_CIGAM_64 ||
         mh.magic == llvm::MachO::MH_MAGIC_64)
if (!m_module_sp && uuid_is_valid) {
       // "com.apple.filesystems.msdosfs", and ask the platform to find it.
       PlatformSP platform_sp(target.GetPlatform());
       if (!m_module_sp && platform_sp) {
         ConstString platform_name(platform_sp->GetPluginName());
         static ConstString g_platform_name(
             PlatformDarwinKernel::GetPluginNameStatic());
         if (platform_name == g_platform_name) {
           ModuleSpec kext_bundle_module_spec(module_spec);
-          FileSpec kext_filespec(m_name.c_str(), false);
+          FileSpec kext_filespec(m_name.c_str());
           kext_bundle_module_spec.GetFileSpec() = kext_filespec;
           platform_sp->GetSharedModule(
               kext_bundle_module_spec, process, m_module_sp,
               &target.GetExecutableSearchPaths(), NULL, NULL);
         }
       }
 
       // Ask the Target to find this file on the local system, if possible.

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

void DynamicLoaderHexagonDYLD::RefreshModules() {
 
   ModuleList &loaded_modules = m_process->GetTarget().GetImages();
 
   if (m_rendezvous.ModulesDidLoad()) {
     ModuleList new_modules;
 
     E = m_rendezvous.loaded_end();
     for (I = m_rendezvous.loaded_begin(); I != E; ++I) {
-      FileSpec file(I->path, true);
+      FileSpec file(I->path);
+      FileSystem::Instance().Resolve(file);
       ModuleSP module_sp =
           LoadModuleAtAddress(file, I->link_addr, I->base_addr, true);
       if (module_sp.get()) {
         loaded_modules.AppendIfNeeded(module_sp);
         new_modules.Append(module_sp);
       }
 
       if (log) {
         log->Printf("Target is loading '%s'", I->path.c_str());
         if (!module_sp.get())
           log->Printf("LLDB failed to load '%s'", I->path.c_str());
         else
           log->Printf("LLDB successfully loaded '%s'", I->path.c_str());
       }
     }
     m_process->GetTarget().ModulesDidLoad(new_modules);
   }
 
   if (m_rendezvous.ModulesDidUnload()) {
     ModuleList old_modules;
 
     E = m_rendezvous.unloaded_end();
     for (I = m_rendezvous.unloaded_begin(); I != E; ++I) {
-      FileSpec file(I->path, true);
+      FileSpec file(I->path);
+      FileSystem::Instance().Resolve(file);
       ModuleSpec module_spec(file);
       ModuleSP module_sp = loaded_modules.FindFirstModule(module_spec);
 
       if (module_sp.get()) {
         old_modules.Append(module_sp);
         UnloadSections(module_sp);
       }
 
void DynamicLoaderHexagonDYLD::LoadAllCurrentModules() {
 
   // The rendezvous class doesn't enumerate the main module, so track that
   // ourselves here.
   ModuleSP executable = GetTargetExecutable();
   m_loaded_modules[executable] = m_rendezvous.GetLinkMapAddress();
 
   for (I = m_rendezvous.begin(), E = m_rendezvous.end(); I != E; ++I) {
     const char *module_path = I->path.c_str();
-    FileSpec file(module_path, false);
+    FileSpec file(module_path);
     ModuleSP module_sp =
         LoadModuleAtAddress(file, I->link_addr, I->base_addr, true);
     if (module_sp.get()) {
       module_list.Append(module_sp);
     } else {
       Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_DYNAMIC_LOADER));
       if (log)
         log->Printf("DynamicLoaderHexagonDYLD::%s failed loading module %s at "

source/Plugins/DynamicLoader/MacOSX-DYLD/DynamicLoaderDarwin.cpp

if (image->HasKey("load_address") == false ||
         image->HasKey("uuid") == false) {
       return false;
     }
     image_infos[i].address =
         image->GetValueForKey("load_address")->GetAsInteger()->GetValue();
     image_infos[i].mod_date =
         image->GetValueForKey("mod_date")->GetAsInteger()->GetValue();
     image_infos[i].file_spec.SetFile(
-        image->GetValueForKey("pathname")->GetAsString()->GetValue(), false,
+        image->GetValueForKey("pathname")->GetAsString()->GetValue(),
         FileSpec::Style::native);
 
     StructuredData::Dictionary *mh =
         image->GetValueForKey("mach_header")->GetAsDictionary();
     image_infos[i].header.magic =
         mh->GetValueForKey("magic")->GetAsInteger()->GetValue();
     image_infos[i].header.cputype =
         mh->GetValueForKey("cputype")->GetAsInteger()->GetValue();

source/Plugins/DynamicLoader/MacOSX-DYLD/DynamicLoaderMacOSXDYLD.cpp

for (size_t i = 0;
       lldb::addr_t path_addr = info_data_ref.GetPointer(&info_data_offset);
       image_infos[i].mod_date = info_data_ref.GetPointer(&info_data_offset);
 
       char raw_path[PATH_MAX];
       m_process->ReadCStringFromMemory(path_addr, raw_path, sizeof(raw_path),
                                        error);
       // don't resolve the path
       if (error.Success()) {
-        const bool resolve_path = false;
-        image_infos[i].file_spec.SetFile(raw_path, resolve_path,
-                                         FileSpec::Style::native);
+        image_infos[i].file_spec.SetFile(raw_path, FileSpec::Style::native);
       }
     }
     return true;
   } else {
     return false;
   }
 }
 
if (data.ValidOffsetForDataOfSize(offset,
         dylib_info.segments.push_back(segment);
       } break;
 
       case llvm::MachO::LC_ID_DYLINKER:
         if (lc_id_dylinker) {
           const lldb::offset_t name_offset =
               load_cmd_offset + data.GetU32(&offset);
           const char *path = data.PeekCStr(name_offset);
-          lc_id_dylinker->SetFile(path, true, FileSpec::Style::native);
+          lc_id_dylinker->SetFile(path, FileSpec::Style::native);
+          FileSystem::Instance().Resolve(*lc_id_dylinker);
         }
         break;
 
       case llvm::MachO::LC_UUID:
         dylib_info.uuid = UUID::fromOptionalData(data.GetData(&offset, 16), 16);
         break;
 
       default:

source/Plugins/DynamicLoader/POSIX-DYLD/DYLDRendezvous.cpp

bool DYLDRendezvous::FillSOEntryFromModuleInfo(
   if (!modInfo.get_link_map(link_map_addr) || !modInfo.get_base(base_addr) ||
       !modInfo.get_dynamic(dyn_addr) || !modInfo.get_name(name))
     return false;
 
   entry.link_addr = link_map_addr;
   entry.base_addr = base_addr;
   entry.dyn_addr = dyn_addr;
 
-  entry.file_spec.SetFile(name, false, FileSpec::Style::native);
+  entry.file_spec.SetFile(name, FileSpec::Style::native);
 
   UpdateBaseAddrIfNecessary(entry, name);
 
   // not needed if we're using ModuleInfos
   entry.next = 0;
   entry.prev = 0;
   entry.path_addr = 0;
 
bool DYLDRendezvous::ReadSOEntryFromMemory(lldb::addr_t addr, SOEntry &entry) {
 
   if (!(addr = ReadPointer(addr, &entry.next)))
     return false;
 
   if (!(addr = ReadPointer(addr, &entry.prev)))
     return false;
 
   std::string file_path = ReadStringFromMemory(entry.path_addr);
-  entry.file_spec.SetFile(file_path, false, FileSpec::Style::native);
+  entry.file_spec.SetFile(file_path, FileSpec::Style::native);
 
   UpdateBaseAddrIfNecessary(entry, file_path);
 
   return true;
 }
 
 bool DYLDRendezvous::FindMetadata(const char *name, PThreadField field,
                                   uint32_t &value) {

source/Plugins/DynamicLoader/POSIX-DYLD/DynamicLoaderPOSIXDYLD.cpp

DynamicLoaderPOSIXDYLD::GetStepThroughTrampolinePlan(Thread &thread,
 
   return thread_plan_sp;
 }
 
 void DynamicLoaderPOSIXDYLD::LoadVDSO() {
   if (m_vdso_base == LLDB_INVALID_ADDRESS)
     return;
 
-  FileSpec file("[vdso]", false);
+  FileSpec file("[vdso]");
 
   MemoryRegionInfo info;
   Status status = m_process->GetMemoryRegionInfo(m_vdso_base, info);
   if (status.Fail()) {
     Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_DYNAMIC_LOADER));
     LLDB_LOG(log, "Failed to get vdso region info: {0}", status);
     return;
   }
ModuleSP DynamicLoaderPOSIXDYLD::LoadInterpreterModule() {
   Status status = m_process->GetMemoryRegionInfo(m_interpreter_base, info);
   if (status.Fail() || info.GetMapped() != MemoryRegionInfo::eYes ||
       info.GetName().IsEmpty()) {
     Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_DYNAMIC_LOADER));
     LLDB_LOG(log, "Failed to get interpreter region info: {0}", status);
     return nullptr;
   }
 
-  FileSpec file(info.GetName().GetCString(), false);
+  FileSpec file(info.GetName().GetCString());
   ModuleSpec module_spec(file, target.GetArchitecture());
 
   if (ModuleSP module_sp = target.GetSharedModule(module_spec)) {
     UpdateLoadedSections(module_sp, LLDB_INVALID_ADDRESS, m_interpreter_base,
                          false);
     return module_sp;
   }
   return nullptr;

source/Plugins/ExpressionParser/Clang/ClangHost.cpp

 #include "clang/Config/config.h"
 
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Threading.h"
 
 // Project includes
+#include "lldb/Host/FileSystem.h"
 #include "lldb/Host/HostInfo.h"
 #if !defined(_WIN32)
 #include "lldb/Host/posix/HostInfoPosix.h"
 #endif
 #include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/Log.h"
 
 #include <string>
bool lldb_private::ComputeClangDirectory(FileSpec &lldb_shlib_spec,
   if (parent != r_end && *parent == "SharedFrameworks") {
     // This is the top-level LLDB in the Xcode.app bundle.
     // E.g., "Xcode.app/Contents/SharedFrameworks/LLDB.framework/Versions/A"
     raw_path.resize(parent - r_end);
     llvm::sys::path::append(clang_path, raw_path,
                             "Developer/Toolchains/XcodeDefault.xctoolchain",
                             swift_clang_resource_dir);
     if (!verify || VerifyClangPath(clang_path)) {
-      file_spec.SetFile(clang_path.c_str(), true, FileSpec::Style::native);
+      file_spec.SetFile(clang_path.c_str(), FileSpec::Style::native);
+      FileSystem::Instance().Resolve(file_spec);
       return true;
     }
   } else if (parent != r_end && *parent == "PrivateFrameworks" &&
              std::distance(parent, r_end) > 2) {
     ++parent;
     ++parent;
     if (*parent == "System") {
       // This is LLDB inside an Xcode toolchain.
       // E.g., "Xcode.app/Contents/Developer/Toolchains/"               \
       //       "My.xctoolchain/System/Library/PrivateFrameworks/LLDB.framework"
       raw_path.resize(parent - r_end);
       llvm::sys::path::append(clang_path, raw_path, swift_clang_resource_dir);
       if (!verify || VerifyClangPath(clang_path)) {
-        file_spec.SetFile(clang_path.c_str(), true, FileSpec::Style::native);
+        file_spec.SetFile(clang_path.c_str(), FileSpec::Style::native);
+        FileSystem::Instance().Resolve(file_spec);
         return true;
       }
       raw_path = lldb_shlib_spec.GetPath();
     }
     raw_path.resize(rev_it - r_end);
   } else {
     raw_path.resize(rev_it - r_end);
   }
 
   // Fall back to the Clang resource directory inside the framework.
   raw_path.append("LLDB.framework/Resources/Clang");
-  file_spec.SetFile(raw_path.c_str(), true, FileSpec::Style::native);
+  file_spec.SetFile(raw_path.c_str(), FileSpec::Style::native);
+  FileSystem::Instance().Resolve(file_spec);
   return true;
 }
 
 static bool ComputeClangDirectory(FileSpec &file_spec) {
   if (FileSpec lldb_file_spec = HostInfo::GetShlibDir())
     return ComputeClangDirectory(lldb_file_spec, file_spec, true);
   return false;
 }

source/Plugins/JITLoader/GDB/JITLoaderGDB.cpp

if (jit_action == JIT_REGISTER_FN) {
       if (log)
         log->Printf("JITLoaderGDB::%s registering JIT entry at 0x%" PRIx64
                     " (%" PRIu64 " bytes)",
                     __FUNCTION__, symbolfile_addr, (uint64_t)symbolfile_size);
 
       char jit_name[64];
       snprintf(jit_name, 64, "JIT(0x%" PRIx64 ")", symbolfile_addr);
       module_sp = m_process->ReadModuleFromMemory(
-          FileSpec(jit_name, false), symbolfile_addr, symbolfile_size);
+          FileSpec(jit_name), symbolfile_addr, symbolfile_size);
 
       if (module_sp && module_sp->GetObjectFile()) {
         // load the symbol table right away
         module_sp->GetObjectFile()->GetSymtab();
 
         m_jit_objects.insert(std::make_pair(symbolfile_addr, module_sp));
         if (module_sp->GetObjectFile()->GetPluginName() ==
             ConstString("mach-o")) {

source/Plugins/LanguageRuntime/CPlusPlus/ItaniumABI/ItaniumABILanguageRuntime.cpp

 
 lldb::SearchFilterSP ItaniumABILanguageRuntime::CreateExceptionSearchFilter() {
   Target &target = m_process->GetTarget();
 
   if (target.GetArchitecture().GetTriple().getVendor() == llvm::Triple::Apple) {
     // Limit the number of modules that are searched for these breakpoints for
     // Apple binaries.
     FileSpecList filter_modules;
-    filter_modules.Append(FileSpec("libc++abi.dylib", false));
-    filter_modules.Append(FileSpec("libSystem.B.dylib", false));
+    filter_modules.Append(FileSpec("libc++abi.dylib"));
+    filter_modules.Append(FileSpec("libSystem.B.dylib"));
     return target.GetSearchFilterForModuleList(&filter_modules);
   } else {
     return LanguageRuntime::CreateExceptionSearchFilter();
   }
 }
 
 lldb::BreakpointSP ItaniumABILanguageRuntime::CreateExceptionBreakpoint(
     bool catch_bp, bool throw_bp, bool for_expressions, bool is_internal) {

source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntime.cpp

else
     return false;
 }
 
 lldb::SearchFilterSP AppleObjCRuntime::CreateExceptionSearchFilter() {
   Target &target = m_process->GetTarget();
 
   if (target.GetArchitecture().GetTriple().getVendor() == llvm::Triple::Apple) {
     FileSpecList filter_modules;
-    filter_modules.Append(FileSpec("libobjc.A.dylib", false));
+    filter_modules.Append(FileSpec("libobjc.A.dylib"));
     return target.GetSearchFilterForModuleList(&filter_modules);
   } else {
     return LanguageRuntime::CreateExceptionSearchFilter();
   }
 }
 
 void AppleObjCRuntime::ReadObjCLibraryIfNeeded(const ModuleList &module_list) {
   if (!HasReadObjCLibrary()) {

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);
+  FileSpec file(path);
+  FileSystem::Instance().Resolve(file);
   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);
bool RenderScriptRuntime::SaveAllocation(Stream &strm, const uint32_t alloc_id,
 
   assert(alloc->data_ptr.isValid() && alloc->element.type.isValid() &&
          alloc->element.type_vec_size.isValid() &&
          alloc->element.datum_size.get() &&
          alloc->element.type_kind.isValid() && alloc->dimension.isValid() &&
          "Allocation information not available");
 
   // Check we can create writable file
-  FileSpec file_spec(path, true);
+  FileSpec file_spec(path);
+  FileSystem::Instance().Resolve(file_spec);
   File file(file_spec, File::eOpenOptionWrite | File::eOpenOptionCanCreate |
                            File::eOpenOptionTruncate);
   if (!file) {
     strm.Printf("Error: Failed to open '%s' for writing", path);
     strm.EOL();
     return false;
   }
 
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);
+        m_outfile.SetFile(option_arg, FileSpec::Style::native);
+        FileSystem::Instance().Resolve(m_outfile);
         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);

source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp

bool ObjectFileELF::GetUUID(lldb_private::UUID *uuid) {
 
   return false;
 }
 
 lldb_private::FileSpecList ObjectFileELF::GetDebugSymbolFilePaths() {
   FileSpecList file_spec_list;
 
   if (!m_gnu_debuglink_file.empty()) {
-    FileSpec file_spec(m_gnu_debuglink_file, false);
+    FileSpec file_spec(m_gnu_debuglink_file);
     file_spec_list.Append(file_spec);
   }
   return file_spec_list;
 }
 
 uint32_t ObjectFileELF::GetDependentModules(FileSpecList &files) {
   size_t num_modules = ParseDependentModules();
   uint32_t num_specs = 0;
while (offset < section_size) {
       if (!symbol.Parse(dynsym_data, &offset))
         break;
 
       if (symbol.d_tag != DT_NEEDED)
         continue;
 
       uint32_t str_index = static_cast<uint32_t>(symbol.d_val);
       const char *lib_name = dynstr_data.PeekCStr(str_index);
-      m_filespec_ap->Append(FileSpec(lib_name, true));
+      FileSpec file_spec(lib_name);
+      FileSystem::Instance().Resolve(file_spec);
+      m_filespec_ap->Append(file_spec);
     }
   }
 
   return m_filespec_ap->GetSize();
 }
 
 //----------------------------------------------------------------------
 // GetProgramHeaderInfo

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

for (i = 0; i < m_header.ncmds; ++i) {
     case LC_LOAD_DYLIB:
     case LC_LOAD_WEAK_DYLIB:
     case LC_REEXPORT_DYLIB:
     case LC_LOADFVMLIB:
     case LC_LOAD_UPWARD_DYLIB: {
       uint32_t name_offset = cmd_offset + m_data.GetU32(&offset);
       const char *path = m_data.PeekCStr(name_offset);
       if (path) {
-        FileSpec file_spec(path, false);
+        FileSpec file_spec(path);
         // Strip the path if there is @rpath, @executable, etc so we just use
         // the basename
         if (path[0] == '@')
           file_spec.GetDirectory().Clear();
 
         if (lc.cmd == LC_REEXPORT_DYLIB) {
           m_reexported_dylibs.AppendIfUnique(file_spec);
         }
if (nlist_data.GetByteSize() > 0) {
                   std::string full_so_path(so_path);
                   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);
+                    FileSpec so_dir(so_path);
                     if (!FileSystem::Instance().Exists(so_dir)) {
-                      so_dir.SetFile(&full_so_path[double_slash_pos + 1], false,
+                      so_dir.SetFile(&full_so_path[double_slash_pos + 1],
                                      FileSpec::Style::native);
                       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() != '/')
uint32_t ObjectFileMachO::GetDependentModules(FileSpecList &files) {
   ModuleSP module_sp(GetModule());
   if (module_sp) {
     std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
     struct load_command load_cmd;
     lldb::offset_t offset = MachHeaderSizeFromMagic(m_header.magic);
     std::vector<std::string> rpath_paths;
     std::vector<std::string> rpath_relative_paths;
     std::vector<std::string> at_exec_relative_paths;
-    const bool resolve_path = false; // Don't resolve the dependent file paths
-                                     // since they may not reside on this
-                                     // system
     uint32_t i;
     for (i = 0; i < m_header.ncmds; ++i) {
       const uint32_t cmd_offset = offset;
       if (m_data.GetU32(&offset, &load_cmd, 2) == NULL)
         break;
 
       switch (load_cmd.cmd) {
       case LC_RPATH:
for (i = 0; i < m_header.ncmds; ++i) {
             if (path[0] == '@') {
               if (strncmp(path, "@rpath", strlen("@rpath")) == 0)
                 rpath_relative_paths.push_back(path + strlen("@rpath"));
               else if (strncmp(path, "@executable_path", 
                        strlen("@executable_path")) == 0)
                 at_exec_relative_paths.push_back(path 
                                                  + strlen("@executable_path"));
             } else {
-              FileSpec file_spec(path, resolve_path);
+              FileSpec file_spec(path);
               if (files.AppendIfUnique(file_spec))
                 count++;
             }
           }
         }
       } break;
 
       default:
         break;
       }
       offset = cmd_offset + load_cmd.cmdsize;
     }
 
     FileSpec this_file_spec(m_file);
-    this_file_spec.ResolvePath();
-    
+    FileSystem::Instance().Resolve(this_file_spec);
     if (!rpath_paths.empty()) {
       // Fixup all LC_RPATH values to be absolute paths
       std::string loader_path("@loader_path");
       std::string executable_path("@executable_path");
       for (auto &rpath : rpath_paths) {
         if (rpath.find(loader_path) == 0) {
           rpath.erase(0, loader_path.size());
           rpath.insert(0, this_file_spec.GetDirectory().GetCString());
         } else if (rpath.find(executable_path) == 0) {
           rpath.erase(0, executable_path.size());
           rpath.insert(0, this_file_spec.GetDirectory().GetCString());
         }
       }
 
       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);
+          FileSpec file_spec(path);
+          FileSystem::Instance().Resolve(file_spec);
           if (FileSystem::Instance().Exists(file_spec) &&
               files.AppendIfUnique(file_spec)) {
             count++;
             break;
           }
         }
       }
     }

source/Plugins/Platform/Android/PlatformAndroid.cpp

Status PlatformAndroid::ConnectRemote(Args &args) {
   return error;
 }
 
 Status PlatformAndroid::GetFile(const FileSpec &source,
                                 const FileSpec &destination) {
   if (IsHost() || !m_remote_platform_sp)
     return PlatformLinux::GetFile(source, destination);
 
-  FileSpec source_spec(source.GetPath(false), false, FileSpec::Style::posix);
+  FileSpec source_spec(source.GetPath(false), FileSpec::Style::posix);
   if (source_spec.IsRelative())
     source_spec = GetRemoteWorkingDirectory().CopyByAppendingPathComponent(
         source_spec.GetCString(false));
 
   Status error;
   auto sync_service = GetSyncService(error);
   if (error.Fail())
     return error;

 }
 
 Status PlatformAndroid::PutFile(const FileSpec &source,
                                 const FileSpec &destination, uint32_t uid,
                                 uint32_t gid) {
   if (IsHost() || !m_remote_platform_sp)
     return PlatformLinux::PutFile(source, destination, uid, gid);
 
-  FileSpec destination_spec(destination.GetPath(false), false,
-                            FileSpec::Style::posix);
+  FileSpec destination_spec(destination.GetPath(false), FileSpec::Style::posix);
   if (destination_spec.IsRelative())
     destination_spec = GetRemoteWorkingDirectory().CopyByAppendingPathComponent(
         destination_spec.GetCString(false));
 
   // TODO: Set correct uid and gid on remote file.
   Status error;
   auto sync_service = GetSyncService(error);
   if (error.Fail())
tmpdir_remover(&tmpdir, [&adb](std::string *s) {
     command.Printf("rm -rf %s", s->c_str());
     Status error = adb.Shell(command.GetData(), seconds(5), nullptr);
 
     Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_PLATFORM));
     if (log && error.Fail())
       log->Printf("Failed to remove temp directory: %s", error.AsCString());
   });
 
-  FileSpec symfile_platform_filespec(tmpdir, false);
+  FileSpec symfile_platform_filespec(tmpdir);
   symfile_platform_filespec.AppendPathComponent("symbolized.oat");
 
   // Execute oatdump on the remote device to generate a file with symtab
   StreamString command;
   command.Printf("oatdump --symbolize=%s --output=%s",
                  module_sp->GetPlatformFileSpec().GetCString(false),
                  symfile_platform_filespec.GetCString(false));
   error = adb.Shell(command.GetData(), minutes(1), nullptr);

source/Plugins/Platform/MacOSX/PlatformAppleSimulator.cpp

#if defined(__APPLE__)
   std::lock_guard<std::mutex> guard(m_core_sim_path_mutex);
   if (!m_core_simulator_framework_path.hasValue()) {
     const char *developer_dir = GetDeveloperDirectory();
     if (developer_dir) {
       StreamString cs_path;
       cs_path.Printf(
           "%s/Library/PrivateFrameworks/CoreSimulator.framework/CoreSimulator",
           developer_dir);
-      const bool resolve_path = true;
-      m_core_simulator_framework_path =
-          FileSpec(cs_path.GetData(), resolve_path);
+      m_core_simulator_framework_path = FileSpec(cs_path.GetData());
+      FileSystem::Instance().Resolve(*m_core_simulator_framework_path);
     }
   }
 
   return m_core_simulator_framework_path.getValue();
 #else
   return FileSpec();
 #endif
 }

source/Plugins/Platform/MacOSX/PlatformAppleTVSimulator.cpp

Status PlatformAppleTVSimulator::ResolveExecutable(
 
   return error;
 }
 
 static FileSystem::EnumerateDirectoryResult
 EnumerateDirectoryCallback(void *baton, llvm::sys::fs::file_type ft,
                            llvm::StringRef path) {
   if (ft == llvm::sys::fs::file_type::directory_file) {
-    FileSpec file_spec(path, false);
+    FileSpec file_spec(path);
     const char *filename = file_spec.GetFilename().GetCString();
     if (filename &&
         strncmp(filename, "AppleTVSimulator", strlen("AppleTVSimulator")) ==
             0) {
       ::snprintf((char *)baton, PATH_MAX, "%s", filename);
       return FileSystem::eEnumerateDirectoryResultQuit;
     }
   }
if (platform_file.GetPath(platform_file_path, sizeof(platform_file_path))) {
     char resolved_path[PATH_MAX];
 
     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);
+      local_file.SetFile(resolved_path, FileSpec::Style::native);
+      FileSystem::Instance().Resolve(local_file);
       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);
+      local_file.SetFile(platform_file_path, FileSpec::Style::native);
+      FileSystem::Instance().Resolve(local_file);
       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(
 
   return error;
 }
 
 static FileSystem::EnumerateDirectoryResult
 EnumerateDirectoryCallback(void *baton, llvm::sys::fs::file_type ft,
                            llvm::StringRef path) {
   if (ft == llvm::sys::fs::file_type::directory_file) {
-    FileSpec file_spec(path, false);
+    FileSpec file_spec(path);
     const char *filename = file_spec.GetFilename().GetCString();
     if (filename &&
         strncmp(filename, "AppleWatchSimulator",
                 strlen("AppleWatchSimulator")) == 0) {
       ::snprintf((char *)baton, PATH_MAX, "%s", filename);
       return FileSystem::eEnumerateDirectoryResultQuit;
     }
   }
if (platform_file.GetPath(platform_file_path, sizeof(platform_file_path))) {
     char resolved_path[PATH_MAX];
 
     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);
+      local_file.SetFile(resolved_path, FileSpec::Style::native);
+      FileSystem::Instance().Resolve(local_file);
       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);
+      local_file.SetFile(platform_file_path, FileSpec::Style::native);
+      FileSystem::Instance().Resolve(local_file);
       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 (module_spec) {
                 // file exists
                 path_string.Printf("%s/../Python/%s.py",
                                    symfile_spec.GetDirectory().GetCString(),
                                    module_basename.c_str());
                 original_path_string.Printf(
                     "%s/../Python/%s.py",
                     symfile_spec.GetDirectory().GetCString(),
                     original_module_basename.c_str());
-                FileSpec script_fspec(path_string.GetString(), true);
-                FileSpec orig_script_fspec(original_path_string.GetString(),
-                                           true);
+                FileSpec script_fspec(path_string.GetString());
+                FileSystem::Instance().Resolve(script_fspec);
+                FileSpec orig_script_fspec(original_path_string.GetString());
+                FileSystem::Instance().Resolve(orig_script_fspec);
 
                 // 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 &&
                       FileSystem::Instance().Exists(orig_script_fspec)) {
                     const char *reason_for_complaint =
if (module_sp)
     return err;
 
   if (!IsHost()) {
     std::string cache_path(GetLocalCacheDirectory());
     // Only search for a locally cached file if we have a valid cache path
     if (!cache_path.empty()) {
       std::string module_path(module_spec.GetFileSpec().GetPath());
       cache_path.append(module_path);
-      FileSpec module_cache_spec(cache_path, false);
+      FileSpec module_cache_spec(cache_path);
 
       // 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_sp && module_search_paths_ptr && platform_file) {
           for (size_t i = 0; i < num_module_search_paths; ++i) {
             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);
+              FileSpec new_file_spec(new_path);
               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) {
if (m_developer_directory.empty()) {
     }
 
     if (!developer_dir_path_valid) {
       std::string xcode_dir_path;
       const char *xcode_select_prefix_dir = getenv("XCODE_SELECT_PREFIX_DIR");
       if (xcode_select_prefix_dir)
         xcode_dir_path.append(xcode_select_prefix_dir);
       xcode_dir_path.append("/usr/share/xcode-select/xcode_dir_path");
-      temp_file_spec.SetFile(xcode_dir_path, false, FileSpec::Style::native);
+      temp_file_spec.SetFile(xcode_dir_path, FileSpec::Style::native);
       auto dir_buffer =
           DataBufferLLVM::CreateFromPath(temp_file_spec.GetPath());
       if (dir_buffer && dir_buffer->GetByteSize() > 0) {
         llvm::StringRef path_ref(dir_buffer->GetChars());
         // Trim tailing newlines and make sure there is enough room for a null
         // terminator.
         path_ref =
             path_ref.rtrim("\r\n").take_front(sizeof(developer_dir_path) - 1);
         ::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);
+      FileSpec xcode_select_cmd("/usr/bin/xcode-select");
       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
                                   false); // don't run in a shell
         if (error.Success() && exit_status == 0 && !command_output.empty()) {
           const char *cmd_output_ptr = command_output.c_str();
           developer_dir_path[sizeof(developer_dir_path) - 1] = '\0';
           size_t i;
           for (i = 0; i < sizeof(developer_dir_path) - 1; i++) {
             if (cmd_output_ptr[i] == '\r' || cmd_output_ptr[i] == '\n' ||
                 cmd_output_ptr[i] == '\0')
               break;
             developer_dir_path[i] = cmd_output_ptr[i];
           }
           developer_dir_path[i] = '\0';
 
-          FileSpec devel_dir(developer_dir_path, false);
+          FileSpec devel_dir(developer_dir_path);
           if (llvm::sys::fs::is_directory(devel_dir.GetPath())) {
             developer_dir_path_valid = true;
           }
         }
       }
     }
 
     if (developer_dir_path_valid) {
-      temp_file_spec.SetFile(developer_dir_path, false,
-                             FileSpec::Style::native);
+      temp_file_spec.SetFile(developer_dir_path, FileSpec::Style::native);
       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');
BreakpointSP PlatformDarwin::SetThreadCreationBreakpoint(Target &target) {
   };
 
   static const char *g_bp_modules[] = {"libsystem_c.dylib",
                                        "libSystem.B.dylib"};
 
   FileSpecList bp_modules;
   for (size_t i = 0; i < llvm::array_lengthof(g_bp_modules); i++) {
     const char *bp_module = g_bp_modules[i];
-    bp_modules.Append(FileSpec(bp_module, false));
+    bp_modules.Append(FileSpec(bp_module));
   }
 
   bool internal = true;
   bool hardware = false;
   LazyBool skip_prologue = eLazyBoolNo;
   bp_sp = target.CreateBreakpoint(&bp_modules, NULL, g_bp_names,
                                   llvm::array_lengthof(g_bp_names),
                                   eFunctionNameTypeFull, eLanguageTypeUnknown,

 static FileSpec CheckPathForXcode(const FileSpec &fspec) {
   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 ret(path_to_shlib);
 
       FileSpec xcode_binary_path = ret;
       xcode_binary_path.AppendPathComponent("MacOS");
       xcode_binary_path.AppendPathComponent("Xcode");
 
       if (FileSystem::Instance().Exists(xcode_binary_path)) {
         return ret;
       }
if (fspec) {
         g_xcode_filespec = CheckPathForXcode(fspec);
       }
     }
 
     // Next check DEVELOPER_DIR environment variable
     if (!g_xcode_filespec) {
       const char *developer_dir_env_var = getenv("DEVELOPER_DIR");
       if (developer_dir_env_var && developer_dir_env_var[0]) {
-        g_xcode_filespec =
-            CheckPathForXcode(FileSpec(developer_dir_env_var, true));
+        FileSpec developer_dir_spec = FileSpec(developer_dir_env_var);
+        FileSystem::Instance().Resolve(developer_dir_spec);
+        g_xcode_filespec = CheckPathForXcode(developer_dir_spec);
       }
 
       // Fall back to using "xcrun" to find the selected Xcode
       if (!g_xcode_filespec) {
         int status = 0;
         int signo = 0;
         std::string output;
         const char *command = "/usr/bin/xcode-select -p";
         lldb_private::Status error = Host::RunShellCommand(
             command, // shell command to run
             NULL,    // current working directory
             &status, // Put the exit status of the process in here
             &signo,  // Put the signal that caused the process to exit in here
             &output, // Get the output from the command and place it in this
                      // string
             std::chrono::seconds(3));
         if (status == 0 && !output.empty()) {
           size_t first_non_newline = output.find_last_not_of("\r\n");
           if (first_non_newline != std::string::npos) {
             output.erase(first_non_newline + 1);
           }
           output.append("/..");
 
-          g_xcode_filespec = CheckPathForXcode(FileSpec(output, false));
+          g_xcode_filespec = CheckPathForXcode(FileSpec(output));
         }
       }
     }
   });
 
   return g_xcode_filespec;
 }
 
bool PlatformDarwin::SDKSupportsModules(SDKType desired_type,
 
   return false;
 }
 
 FileSystem::EnumerateDirectoryResult PlatformDarwin::DirectoryEnumerator(
     void *baton, llvm::sys::fs::file_type file_type, llvm::StringRef path) {
   SDKEnumeratorInfo *enumerator_info = static_cast<SDKEnumeratorInfo *>(baton);
 
-  FileSpec spec(path, false);
+  FileSpec spec(path);
   if (SDKSupportsModules(enumerator_info->sdk_type, spec)) {
     enumerator_info->found_path = spec;
     return FileSystem::EnumerateDirectoryResult::eEnumerateDirectoryResultNext;
   }
 
   return FileSystem::EnumerateDirectoryResult::eEnumerateDirectoryResultNext;
 }
 

source/Plugins/Platform/MacOSX/PlatformDarwinKernel.cpp

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

 FileSystem::EnumerateDirectoryResult
 PlatformDarwinKernel::GetKernelsAndKextsInDirectoryHelper(
     void *baton, llvm::sys::fs::file_type ft, llvm::StringRef path,
     bool recurse) {
   static ConstString g_kext_suffix = ConstString(".kext");
   static ConstString g_dsym_suffix = ConstString(".dSYM");
   static ConstString g_bundle_suffix = ConstString("Bundle");
 
-  FileSpec file_spec(path, false);
+  FileSpec file_spec(path);
   ConstString file_spec_extension = file_spec.GetFileNameExtension();
 
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_PLATFORM));
   Log *log_verbose(GetLogIfAllCategoriesSet(LIBLLDB_LOG_PLATFORM | LLDB_LOG_OPTION_VERBOSE));
 
   if (log_verbose)
       log_verbose->Printf ("PlatformDarwinKernel examining '%s'", file_spec.GetPath().c_str());
 
if ((strncmp(filename.GetCString(), "kernel", 6) == 0 ||
         thisp->m_kernel_binaries_without_dsyms.push_back(file_spec);
       }
       return FileSystem::eEnumerateDirectoryResultNext;
     }
   } else if (ft == llvm::sys::fs::file_type::directory_file &&
              file_spec_extension == g_kext_suffix) {
     AddKextToMap(thisp, file_spec);
     // Look to see if there is a PlugIns subdir with more kexts
-    FileSpec contents_plugins(file_spec.GetPath() + "/Contents/PlugIns", false);
+    FileSpec contents_plugins(file_spec.GetPath() + "/Contents/PlugIns");
     std::string search_here_too;
     if (llvm::sys::fs::is_directory(contents_plugins.GetPath())) {
       search_here_too = contents_plugins.GetPath();
     } else {
-      FileSpec plugins(file_spec.GetPath() + "/PlugIns", false);
+      FileSpec plugins(file_spec.GetPath() + "/PlugIns");
       if (llvm::sys::fs::is_directory(plugins.GetPath())) {
         search_here_too = plugins.GetPath();
       }
     }
 
     if (!search_here_too.empty()) {
       const bool find_directories = true;
       const bool find_files = false;
bool PlatformDarwinKernel::KextHasdSYMSibling(
 
   // Look for a deep bundle foramt
   ConstString executable_name =
       kext_bundle_filepath.GetFileNameStrippingExtension();
   std::string deep_bundle_str =
       kext_bundle_filepath.GetPath() + "/Contents/MacOS/";
   deep_bundle_str += executable_name.AsCString();
   deep_bundle_str += ".dSYM";
-  dsym_fspec.SetFile(deep_bundle_str, true, FileSpec::Style::native);
+  dsym_fspec.SetFile(deep_bundle_str, FileSpec::Style::native);
+  FileSystem::Instance().Resolve(dsym_fspec);
   if (llvm::sys::fs::is_directory(dsym_fspec.GetPath())) {
     return true;
   }
 
   // look for a shallow bundle format
   //
   std::string shallow_bundle_str = kext_bundle_filepath.GetPath() + "/";
   shallow_bundle_str += executable_name.AsCString();
   shallow_bundle_str += ".dSYM";
-  dsym_fspec.SetFile(shallow_bundle_str, true, FileSpec::Style::native);
+  dsym_fspec.SetFile(shallow_bundle_str, FileSpec::Style::native);
+  FileSystem::Instance().Resolve(dsym_fspec);
   if (llvm::sys::fs::is_directory(dsym_fspec.GetPath())) {
     return true;
   }
   return false;
 }
 
 // Given a FileSpec of /dir/dir/mach.development.t7004 Return true if a dSYM
 // exists next to it:
PlatformDarwinKernel::SearchForExecutablesRecursively(const std::string &dir) {
   for (llvm::sys::fs::recursive_directory_iterator it(dir.c_str(), EC),
        end;
        it != end && !EC; it.increment(EC)) {
     auto status = it->status();
     if (!status)
       break;
     if (llvm::sys::fs::is_regular_file(*status) &&
         llvm::sys::fs::can_execute(it->path()))
-      executables.emplace_back(it->path(), false);
+      executables.emplace_back(it->path());
   }
   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 :

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);
+          fspec.SetFile(sdk_path.GetString(), FileSpec::Style::native);
           if (FileSystem::Instance().Exists(fspec))
             return ConstString(sdk_path.GetString());
         }
 
         if (!default_xcode_sdk.empty()) {
-          fspec.SetFile(default_xcode_sdk, false, FileSpec::Style::native);
+          fspec.SetFile(default_xcode_sdk, FileSpec::Style::native);
           if (FileSystem::Instance().Exists(fspec))
             return ConstString(default_xcode_sdk);
         }
       }
     }
   }
   return ConstString();
 }
if (local_os_build.compare(remote_os_build) == 0) {
       // same OS version: the local file is good enough
       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);
+      FileSpec module_cache_spec(cache_path);
       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

source/Plugins/Platform/MacOSX/PlatformRemoteDarwinDevice.cpp

Status PlatformRemoteDarwinDevice::ResolveExecutable(
 
   return error;
 }
 
 FileSystem::EnumerateDirectoryResult
 PlatformRemoteDarwinDevice::GetContainedFilesIntoVectorOfStringsCallback(
     void *baton, llvm::sys::fs::file_type ft, llvm::StringRef path) {
   ((PlatformRemoteDarwinDevice::SDKDirectoryInfoCollection *)baton)
-      ->push_back(
-          PlatformRemoteDarwinDevice::SDKDirectoryInfo(FileSpec(path, false)));
+      ->push_back(PlatformRemoteDarwinDevice::SDKDirectoryInfo(FileSpec(path)));
   return FileSystem::eEnumerateDirectoryResultNext;
 }
 
 bool PlatformRemoteDarwinDevice::UpdateSDKDirectoryInfosIfNeeded() {
   Log *log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_HOST);
   std::lock_guard<std::mutex> guard(m_sdk_dir_mutex);
   if (m_sdk_directory_infos.empty()) {
     // A --sysroot option was supplied - add it to our list of SDKs to check
     if (m_sdk_sysroot) {
-      FileSpec sdk_sysroot_fspec(m_sdk_sysroot.GetCString(), true);
+      FileSpec sdk_sysroot_fspec(m_sdk_sysroot.GetCString());
+      FileSystem::Instance().Resolve(sdk_sysroot_fspec);
       const SDKDirectoryInfo sdk_sysroot_directory_info(sdk_sysroot_fspec);
       m_sdk_directory_infos.push_back(sdk_sysroot_directory_info);
       if (log) {
         log->Printf("PlatformRemoteDarwinDevice::UpdateSDKDirectoryInfosIfNeeded added "
                     "--sysroot SDK directory %s",
                     m_sdk_sysroot.GetCString());
       }
       return true;
if (device_support_dir) {
       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);
+        FileSpec local_sdk_cache(local_sdk_cache_str.c_str());
+        FileSystem::Instance().Resolve(local_sdk_cache);
         if (FileSystem::Instance().Exists(local_sdk_cache)) {
           if (log) {
             log->Printf("PlatformRemoteDarwinDevice::UpdateSDKDirectoryInfosIfNeeded "
                         "searching %s for additional SDKs",
                         local_sdk_cache.GetPath().c_str());
           }
             char path[PATH_MAX];
             if (local_sdk_cache.GetPath(path, sizeof(path))) {
if (sdk_idx < m_sdk_directory_infos.size()) {
 
     if (!sdkroot_path.empty() && platform_file_path && platform_file_path[0]) {
       // We may need to interpose "/Symbols/" or "/Symbols.Internal/" between
       // the
       // SDK root directory and the file path.
 
       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);
+        local_file.SetFile(sdkroot_path, 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();
+        FileSystem::Instance().Resolve(local_file);
         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();
Status PlatformRemoteDarwinDevice::GetSymbolFile(const FileSpec &platform_file,
   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);
+      local_file.SetFile(resolved_path, FileSpec::Style::native);
+      FileSystem::Instance().Resolve(local_file);
       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);
+      local_file.SetFile(resolved_path, FileSpec::Style::native);
+      FileSystem::Instance().Resolve(local_file);
       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);
+      local_file.SetFile(resolved_path, FileSpec::Style::native);
+      FileSystem::Instance().Resolve(local_file);
       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;
       }
     }

source/Plugins/Platform/MacOSX/PlatformiOSSimulator.cpp

Status PlatformiOSSimulator::ResolveExecutable(
 
   return error;
 }
 
 static FileSystem::EnumerateDirectoryResult
 EnumerateDirectoryCallback(void *baton, llvm::sys::fs::file_type ft,
                            llvm::StringRef path) {
   if (ft == llvm::sys::fs::file_type::directory_file) {
-    FileSpec file_spec(path, false);
+    FileSpec file_spec(path);
     const char *filename = file_spec.GetFilename().GetCString();
     if (filename &&
         strncmp(filename, "iPhoneSimulator", strlen("iPhoneSimulator")) == 0) {
       ::snprintf((char *)baton, PATH_MAX, "%s", filename);
       return FileSystem::eEnumerateDirectoryResultQuit;
     }
   }
   return FileSystem::eEnumerateDirectoryResultNext;
if (platform_file.GetPath(platform_file_path, sizeof(platform_file_path))) {
     char resolved_path[PATH_MAX];
 
     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);
+      local_file.SetFile(resolved_path, FileSpec::Style::native);
+      FileSystem::Instance().Resolve(local_file);
       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);
+      local_file.SetFile(platform_file_path, FileSpec::Style::native);
+      FileSystem::Instance().Resolve(local_file);
       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/objcxx/PlatformiOSSimulatorCoreSimulatorSupport.mm

if (file_action) {
     case FileAction::eFileActionOpen: {
       FileSpec file_spec = file_action->GetFileSpec();
       if (file_spec) {
         const int master_fd = launch_info.GetPTY().GetMasterFileDescriptor();
         if (master_fd != PseudoTerminal::invalid_fd) {
           // Check in case our file action open wants to open the slave
           const char *slave_path = launch_info.GetPTY().GetSlaveName(NULL, 0);
           if (slave_path) {
-            FileSpec slave_spec(slave_path, false);
+            FileSpec slave_spec(slave_path);
             if (file_spec == slave_spec) {
               int slave_fd = launch_info.GetPTY().GetSlaveFileDescriptor();
               if (slave_fd == PseudoTerminal::invalid_fd)
                 slave_fd = launch_info.GetPTY().OpenSlave(O_RDWR, nullptr, 0);
               if (slave_fd == PseudoTerminal::invalid_fd) {
                 error.SetErrorStringWithFormat("unable to open slave pty '%s'",
                                                slave_path);
                 return error; // Failure

source/Plugins/Platform/POSIX/PlatformPOSIX.cpp

PlatformPOSIX::ResolveExecutable(const ModuleSpec &module_spec,
   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 (!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,
+      resolved_module_spec.GetFileSpec().SetFile(exe_path,
                                                  FileSpec::Style::native);
+      FileSystem::Instance().Resolve(resolved_module_spec.GetFileSpec());
     }
 
     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());
uint32_t PlatformPOSIX::DoLoadImage(lldb_private::Process *process,
   if (token != 0x0) {
     if (loaded_image && buffer_addr != 0x0)
     {
       // Capture the image which was loaded.  We leave it in the buffer on
       // exit from the dlopen function, so we can just read it from there:
       std::string name_string;
       process->ReadCStringFromMemory(buffer_addr, name_string, utility_error);
       if (utility_error.Success())
-        loaded_image->SetFile(name_string, false, 
-                              llvm::sys::path::Style::posix);
+        loaded_image->SetFile(name_string, llvm::sys::path::Style::posix);
     }
     return process->AddImageToken(token);
   }
     
   // We got an error, lets read in the error string:
   std::string dlopen_error_str;
   lldb::addr_t error_addr 
     = process->ReadPointerFromMemory(return_addr + addr_size, utility_error);

source/Plugins/Platform/Windows/PlatformWindows.cpp

Status PlatformWindows::ResolveExecutable(
   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 (!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,
+      resolved_module_spec.GetFileSpec().SetFile(exe_path,
                                                  FileSpec::Style::native);
+      FileSystem::Instance().Resolve(resolved_module_spec.GetFileSpec());
     }
 
     if (!FileSystem::Instance().Exists(resolved_module_spec.GetFileSpec()))
       FileSystem::Instance().ResolveFileLocation(
           resolved_module_spec.GetFileSpec());
 
     if (FileSystem::Instance().Exists(resolved_module_spec.GetFileSpec()))
       error.Clear();

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

Status ProcessElfCore::DoLoadCore() {
   // the main executable using data we found in the core file notes.
   lldb::ModuleSP exe_module_sp = GetTarget().GetExecutableModule();
   if (!exe_module_sp) {
     // The first entry in the NT_FILE might be our executable
     if (!m_nt_file_entries.empty()) {
       ModuleSpec exe_module_spec;
       exe_module_spec.GetArchitecture() = arch;
       exe_module_spec.GetFileSpec().SetFile(
-          m_nt_file_entries[0].path.GetCString(), false,
-          FileSpec::Style::native);
+          m_nt_file_entries[0].path.GetCString(), FileSpec::Style::native);
       if (exe_module_spec.GetFileSpec()) {
         exe_module_sp = GetTarget().GetSharedModule(exe_module_spec);
         if (exe_module_sp)
           GetTarget().SetExecutableModule(exe_module_sp, eLoadDependentsNo);
       }
     }
   }
   return error;

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

Status GDBRemoteCommunication::StartDebugserverProcess(
 
   char debugserver_path[PATH_MAX];
   FileSpec &debugserver_file_spec = launch_info.GetExecutableFile();
 
   // Always check to see if we have an environment override for the path to the
   // debugserver to use and use it if we do.
   const char *env_debugserver_path = getenv("LLDB_DEBUGSERVER_PATH");
   if (env_debugserver_path) {
-    debugserver_file_spec.SetFile(env_debugserver_path, false,
+    debugserver_file_spec.SetFile(env_debugserver_path,
                                   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 =

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

bool GDBRemoteCommunicationClient::GetWorkingDir(FileSpec &working_dir) {
   if (SendPacketAndWaitForResponse("qGetWorkingDir", response, false) ==
       PacketResult::Success) {
     if (response.IsUnsupportedResponse())
       return false;
     if (response.IsErrorResponse())
       return false;
     std::string cwd;
     response.GetHexByteString(cwd);
-    working_dir.SetFile(cwd, false, GetHostArchitecture().GetTriple());
+    working_dir.SetFile(cwd, GetHostArchitecture().GetTriple());
     return !cwd.empty();
   }
   return false;
 }
 
 int GDBRemoteCommunicationClient::SetWorkingDir(const FileSpec &working_dir) {
   if (working_dir) {
     std::string path{working_dir.GetPath(false)};
while (response.GetNameColonValue(name, value)) {
         extractor.GetHexByteString(triple);
         process_info.GetArchitecture().SetTriple(triple.c_str());
       } else if (name.equals("name")) {
         StringExtractor extractor(value);
         // The process name from ASCII hex bytes since we can't control the
         // characters in a process name
         std::string name;
         extractor.GetHexByteString(name);
-        process_info.GetExecutableFile().SetFile(name, false,
-                                                 FileSpec::Style::native);
+        process_info.GetExecutableFile().SetFile(name, FileSpec::Style::native);
       } else if (name.equals("cputype")) {
         value.getAsInteger(0, cpu);
       } else if (name.equals("cpusubtype")) {
         value.getAsInteger(0, sub);
       } else if (name.equals("vendor")) {
         vendor = value;
       } else if (name.equals("ostype")) {
         os_type = value;
while (response.GetNameColonValue(name, value)) {
     } else if (name == "file_size") {
       uint64_t ival = 0;
       if (!value.getAsInteger(16, ival))
         module_spec.SetObjectSize(ival);
     } else if (name == "file_path") {
       StringExtractor extractor(value);
       std::string path;
       extractor.GetHexByteString(path);
-      module_spec.GetFileSpec() = FileSpec(path, false, arch_spec.GetTriple());
+      module_spec.GetFileSpec() = FileSpec(path, arch_spec.GetTriple());
     }
   }
 
   return true;
 }
 
 static llvm::Optional<ModuleSpec>
 ParseModuleSpec(StructuredData::Dictionary *dict) {
ParseModuleSpec(StructuredData::Dictionary *dict) {
   result.SetObjectSize(integer);
 
   if (!dict->GetValueForKeyAsString("triple", string))
     return llvm::None;
   result.GetArchitecture().SetTriple(string);
 
   if (!dict->GetValueForKeyAsString("file_path", string))
     return llvm::None;
-  result.GetFileSpec() =
-      FileSpec(string, false, result.GetArchitecture().GetTriple());
+  result.GetFileSpec() = FileSpec(string, result.GetArchitecture().GetTriple());
 
   return result;
 }
 
 llvm::Optional<std::vector<ModuleSpec>>
 GDBRemoteCommunicationClient::GetModulesInfo(
     llvm::ArrayRef<FileSpec> module_file_specs, const llvm::Triple &triple) {
   if (!m_supports_jModulesInfo)

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

if (packet.GetChar() == ':') {
     llvm::StringRef value;
     while (packet.GetNameColonValue(key, value)) {
       bool success = true;
       if (key.equals("name")) {
         StringExtractor extractor(value);
         std::string file;
         extractor.GetHexByteString(file);
         match_info.GetProcessInfo().GetExecutableFile().SetFile(
-            file, false, FileSpec::Style::native);
+            file, FileSpec::Style::native);
       } else if (key.equals("name_match")) {
         NameMatch name_match = llvm::StringSwitch<NameMatch>(value)
                                    .Case("equals", NameMatch::Equals)
                                    .Case("starts_with", NameMatch::StartsWith)
                                    .Case("ends_with", NameMatch::EndsWith)
                                    .Case("contains", NameMatch::Contains)
                                    .Case("regex", NameMatch::RegularExpression)
                                    .Default(NameMatch::Ignore);
GDBRemoteCommunicationServerCommon::Handle_vFile_Open(
   packet.GetHexByteStringTerminatedBy(path, ',');
   if (!path.empty()) {
     if (packet.GetChar() == ',') {
       uint32_t flags =
           File::ConvertOpenOptionsForPOSIXOpen(packet.GetHexMaxU32(false, 0));
       if (packet.GetChar() == ',') {
         mode_t mode = packet.GetHexMaxU32(false, 0600);
         Status error;
-        const FileSpec path_spec{path, true};
+        FileSpec path_spec(path);
+        FileSystem::Instance().Resolve(path_spec);
         int fd = ::open(path_spec.GetCString(), flags, mode);
         const int save_errno = fd == -1 ? errno : 0;
         StreamString response;
         response.PutChar('F');
         response.Printf("%i", fd);
         if (save_errno)
           response.Printf(",%i", save_errno);
         return SendPacketNoLock(response.GetString());

 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServerCommon::Handle_vFile_Mode(
     StringExtractorGDBRemote &packet) {
   packet.SetFilePos(::strlen("vFile:mode:"));
   std::string path;
   packet.GetHexByteString(path);
   if (!path.empty()) {
     Status error;
-    const uint32_t mode = File::GetPermissions(FileSpec{path, true}, error);
+    FileSpec file_spec(path);
+    FileSystem::Instance().Resolve(file_spec);
+    const uint32_t mode = File::GetPermissions(file_spec, error);
     StreamString response;
     response.Printf("F%u", mode);
     if (mode == 0 || error.Fail())
       response.Printf(",%i", (int)error.GetError());
     return SendPacketNoLock(response.GetString());
   }
   return SendErrorResponse(23);
 }

 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServerCommon::Handle_vFile_symlink(
     StringExtractorGDBRemote &packet) {
   packet.SetFilePos(::strlen("vFile:symlink:"));
   std::string dst, src;
   packet.GetHexByteStringTerminatedBy(dst, ',');
   packet.GetChar(); // Skip ',' char
   packet.GetHexByteString(src);
-  Status error = FileSystem::Instance().Symlink(FileSpec{src, true}, FileSpec{dst, false});
+
+  FileSpec src_spec(src);
+  FileSystem::Instance().Resolve(src_spec);
+  Status error = FileSystem::Instance().Symlink(src_spec, FileSpec(dst));
+
   StreamString response;
   response.Printf("F%u,%u", error.GetError(), error.GetError());
   return SendPacketNoLock(response.GetString());
 }
 
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServerCommon::Handle_vFile_unlink(
     StringExtractorGDBRemote &packet) {
GDBRemoteCommunicationServerCommon::Handle_qPlatform_shell(
   if (!path.empty()) {
     if (packet.GetChar() == ',') {
       // FIXME: add timeout to qPlatform_shell packet
       // uint32_t timeout = packet.GetHexMaxU32(false, 32);
       if (packet.GetChar() == ',')
         packet.GetHexByteString(working_dir);
       int status, signo;
       std::string output;
-      Status err = Host::RunShellCommand(
-          path.c_str(), FileSpec{working_dir, true}, &status, &signo, &output,
-          std::chrono::seconds(10));
+      FileSpec working_spec(working_dir);
+      FileSystem::Instance().Resolve(working_spec);
+      Status err =
+          Host::RunShellCommand(path.c_str(), working_spec, &status, &signo,
+                                &output, std::chrono::seconds(10));
       StreamGDBRemote response;
       if (err.Fail()) {
         response.PutCString("F,");
         response.PutHex32(UINT32_MAX);
       } else {
         response.PutCString("F,");
         response.PutHex32(status);
         response.PutChar(',');

 GDBRemoteCommunicationServerCommon::Handle_QSetSTDIN(
     StringExtractorGDBRemote &packet) {
   packet.SetFilePos(::strlen("QSetSTDIN:"));
   FileAction file_action;
   std::string path;
   packet.GetHexByteString(path);
   const bool read = true;
   const bool write = false;
-  if (file_action.Open(STDIN_FILENO, FileSpec{path, false}, read, write)) {
+  if (file_action.Open(STDIN_FILENO, FileSpec(path), read, write)) {
     m_process_launch_info.AppendFileAction(file_action);
     return SendOKResponse();
   }
   return SendErrorResponse(15);
 }
 
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServerCommon::Handle_QSetSTDOUT(
     StringExtractorGDBRemote &packet) {
   packet.SetFilePos(::strlen("QSetSTDOUT:"));
   FileAction file_action;
   std::string path;
   packet.GetHexByteString(path);
   const bool read = false;
   const bool write = true;
-  if (file_action.Open(STDOUT_FILENO, FileSpec{path, false}, read, write)) {
+  if (file_action.Open(STDOUT_FILENO, FileSpec(path), read, write)) {
     m_process_launch_info.AppendFileAction(file_action);
     return SendOKResponse();
   }
   return SendErrorResponse(16);
 }
 
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServerCommon::Handle_QSetSTDERR(
     StringExtractorGDBRemote &packet) {
   packet.SetFilePos(::strlen("QSetSTDERR:"));
   FileAction file_action;
   std::string path;
   packet.GetHexByteString(path);
   const bool read = false;
   const bool write = true;
-  if (file_action.Open(STDERR_FILENO, FileSpec{path, false}, read, write)) {
+  if (file_action.Open(STDERR_FILENO, FileSpec(path), read, write)) {
     m_process_launch_info.AppendFileAction(file_action);
     return SendOKResponse();
   }
   return SendErrorResponse(17);
 }
 
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServerCommon::Handle_qLaunchSuccess(
else {
               if (packet.GetBytesLeft()) {
                 if (packet.GetChar() != ',')
                   success = false;
               }
 
               if (success) {
                 if (arg_idx == 0)
                   m_process_launch_info.GetExecutableFile().SetFile(
-                      arg, false, FileSpec::Style::native);
+                      arg, FileSpec::Style::native);
                 m_process_launch_info.GetArguments().AppendArgument(arg);
                 if (log)
                   log->Printf("LLGSPacketHandler::%s added arg %d: \"%s\"",
                               __FUNCTION__, actual_arg_index, arg.c_str());
                 ++actual_arg_index;
               }
             }
           }
#endif
   }
 }
 
 FileSpec GDBRemoteCommunicationServerCommon::FindModuleFile(
     const std::string &module_path, const ArchSpec &arch) {
 #ifdef __ANDROID__
   return HostInfoAndroid::ResolveLibraryPath(module_path, arch);
 #else
-  return FileSpec(module_path, true);
+  FileSpec file_spec(module_path);
+  FileSystem::Instance().Resolve(file_spec);
+  return file_spec;
 #endif
 }
 
 ModuleSpec
 GDBRemoteCommunicationServerCommon::GetModuleInfo(llvm::StringRef module_path,
                                                   llvm::StringRef triple) {
   ArchSpec arch(triple);
 
-  const FileSpec req_module_path_spec(module_path, true);
+  FileSpec req_module_path_spec(module_path);
+  FileSystem::Instance().Resolve(req_module_path_spec);
+
   const FileSpec module_path_spec =
       FindModuleFile(req_module_path_spec.GetPath(), arch);
   const ModuleSpec module_spec(module_path_spec, arch);
 
   ModuleSpecList module_specs;
   if (!ObjectFile::GetModuleSpecifications(module_path_spec, 0, 0,
                                            module_specs))
     return ModuleSpec();
 
   ModuleSpec matched_module_spec;
   if (!module_specs.FindMatchingModuleSpec(module_spec, matched_module_spec))
     return ModuleSpec();
 
   return matched_module_spec;
 }

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

 }
 
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServerLLGS::Handle_QSetWorkingDir(
     StringExtractorGDBRemote &packet) {
   packet.SetFilePos(::strlen("QSetWorkingDir:"));
   std::string path;
   packet.GetHexByteString(path);
-  m_process_launch_info.SetWorkingDirectory(FileSpec{path, true});
+  m_process_launch_info.SetWorkingDirectory(FileSpec(path));
   return SendOKResponse();
 }
 
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServerLLGS::Handle_qGetWorkingDir(
     StringExtractorGDBRemote &packet) {
   FileSpec working_dir{m_process_launch_info.GetWorkingDirectory()};
   if (working_dir) {

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

 const FileSpec &GDBRemoteCommunicationServerPlatform::GetDomainSocketDir() {
   static FileSpec g_domainsocket_dir;
   static llvm::once_flag g_once_flag;
 
   llvm::call_once(g_once_flag, []() {
     const char *domainsocket_dir_env =
         ::getenv("LLDB_DEBUGSERVER_DOMAINSOCKET_DIR");
     if (domainsocket_dir_env != nullptr)
-      g_domainsocket_dir = FileSpec(domainsocket_dir_env, false);
+      g_domainsocket_dir = FileSpec(domainsocket_dir_env);
     else
       g_domainsocket_dir = HostInfo::GetProcessTempDir();
   });
 
   return g_domainsocket_dir;
 }
 
 FileSpec
 GDBRemoteCommunicationServerPlatform::GetDomainSocketPath(const char *prefix) {
   llvm::SmallString<PATH_MAX> socket_path;
   llvm::SmallString<PATH_MAX> socket_name(
       (llvm::StringRef(prefix) + ".%%%%%%").str());
 
   FileSpec socket_path_spec(GetDomainSocketDir());
   socket_path_spec.AppendPathComponent(socket_name.c_str());
 
   llvm::sys::fs::createUniqueFile(socket_path_spec.GetCString(), socket_path);
-  return FileSpec(socket_path.c_str(), false);
+  return FileSpec(socket_path.c_str());
 }
 
 void GDBRemoteCommunicationServerPlatform::SetPortOffset(uint16_t port_offset) {
   m_port_offset = port_offset;
 }
 
 void GDBRemoteCommunicationServerPlatform::SetPendingGdbServer(
     lldb::pid_t pid, uint16_t port, const std::string &socket_name) {
   m_pending_gdb_server.pid = pid;
   m_pending_gdb_server.port = port;
   m_pending_gdb_server.socket_name = socket_name;
 }

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

void ProcessGDBRemote::BuildDynamicRegisterInfo(bool force) {
   //     target.xml (registers) then proceed to read the target.xml.
   //     3 - Fall back on the qRegisterInfo packets.
 
   FileSpec target_definition_fspec =
       GetGlobalPluginProperties()->GetTargetDefinitionFile();
   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();
+    FileSystem::Instance().Resolve(target_definition_fspec);
   }
   if (target_definition_fspec) {
     // See if we can get register definitions from a python file
     if (ParsePythonTargetDefinition(target_definition_fspec)) {
       return;
     } else {
       StreamSP stream_sp = GetTarget().GetDebugger().GetAsyncOutputStream();
       stream_sp->Printf("ERROR: target description file %s failed to parse.\n",
if (object_file) {
     if (error.Success()) {
       PseudoTerminal pty;
       const bool disable_stdio = (launch_flags & eLaunchFlagDisableSTDIO) != 0;
 
       PlatformSP platform_sp(GetTarget().GetPlatform());
       if (disable_stdio) {
         // set to /dev/null unless redirected to a file above
         if (!stdin_file_spec)
-          stdin_file_spec.SetFile(FileSystem::DEV_NULL, false,
+          stdin_file_spec.SetFile(FileSystem::DEV_NULL,
                                   FileSpec::Style::native);
         if (!stdout_file_spec)
-          stdout_file_spec.SetFile(FileSystem::DEV_NULL, false,
+          stdout_file_spec.SetFile(FileSystem::DEV_NULL,
                                    FileSpec::Style::native);
         if (!stderr_file_spec)
-          stderr_file_spec.SetFile(FileSystem::DEV_NULL, false,
+          stderr_file_spec.SetFile(FileSystem::DEV_NULL,
                                    FileSpec::Style::native);
       } else if (platform_sp && platform_sp->IsHost()) {
         // If the debugserver is local and we aren't disabling STDIO, lets use
         // a pseudo terminal to instead of relying on the 'O' packets for stdio
         // since 'O' packets can really slow down debugging if the inferior
         // does a lot of output.
         if ((!stdin_file_spec || !stdout_file_spec || !stderr_file_spec) &&
             pty.OpenFirstAvailableMaster(O_RDWR | O_NOCTTY, NULL, 0)) {
-          FileSpec slave_name{pty.GetSlaveName(NULL, 0), false};
+          FileSpec slave_name{pty.GetSlaveName(NULL, 0)};
 
           if (!stdin_file_spec)
             stdin_file_spec = slave_name;
 
           if (!stdout_file_spec)
             stdout_file_spec = slave_name;
 
           if (!stderr_file_spec)
for (LoadedModuleInfoList::LoadedModuleInfo &modInfo : module_list.m_list) {
     valid &= modInfo.get_base(mod_base);
     valid &= modInfo.get_base_is_offset(mod_base_is_offset);
     if (!valid)
       continue;
 
     if (!modInfo.get_link_map(link_map))
       link_map = LLDB_INVALID_ADDRESS;
 
-    FileSpec file(mod_name, true);
+    FileSpec file(mod_name);
+    FileSystem::Instance().Resolve(file);
     lldb::ModuleSP module_sp =
         LoadModuleAtAddress(file, link_map, mod_base, mod_base_is_offset);
 
     if (module_sp.get())
       new_modules.Append(module_sp);
   }
 
   if (new_modules.GetSize() > 0) {

source/Plugins/Process/minidump/ProcessMinidump.cpp

for (auto module : filtered_modules) {
 
     // check if the process is wow64 - a 32 bit windows process running on a
     // 64 bit windows
     if (llvm::StringRef(name.getValue()).endswith_lower("wow64.dll")) {
       m_is_wow64 = true;
     }
 
     const auto uuid = m_minidump_parser.GetModuleUUID(module);
-    const auto file_spec =
-        FileSpec(name.getValue(), true, GetArchitecture().GetTriple());
+    auto file_spec = FileSpec(name.getValue(), GetArchitecture().GetTriple());
+    FileSystem::Instance().Resolve(file_spec);
     ModuleSpec module_spec(file_spec, uuid);
     Status error;
     lldb::ModuleSP module_sp = GetTarget().GetSharedModule(module_spec, &error);
     if (!module_sp || error.Fail()) {
       // We failed to locate a matching local object file. Fortunately, the
       // minidump format encodes enough information about each module's memory
       // range to allow us to create placeholder modules.
       //

source/Plugins/ScriptInterpreter/Python/ScriptInterpreterPython.cpp

bool ScriptInterpreterPython::LoadScriptingModule(
   if (!g_swig_call_module_init) {
     error.SetErrorString("internal helper function missing");
     return false;
   }
 
   lldb::DebuggerSP debugger_sp = m_interpreter.GetDebugger().shared_from_this();
 
   {
-    FileSpec target_file(pathname, true);
+    FileSpec target_file(pathname);
+    FileSystem::Instance().Resolve(target_file);
     std::string basename(target_file.GetFilename().GetCString());
 
     StreamString command_stream;
 
     // Before executing Python code, lock the GIL.
     Locker py_lock(this, Locker::AcquireLock |
                              (init_session ? Locker::InitSession : 0) |
                              Locker::NoSTDIN,

source/Plugins/StructuredData/DarwinLog/StructuredDataDarwinLog.cpp

void StructuredDataDarwinLog::AddInitCompletionHook(Process &process) {
 
   // Set a breakpoint for the process that will kick in when libtrace has
   // finished its initialization.
   Target &target = process.GetTarget();
 
   // Build up the module list.
   FileSpecList module_spec_list;
   auto module_file_spec =
-      FileSpec(GetGlobalProperties()->GetLoggingModuleName(), false);
+      FileSpec(GetGlobalProperties()->GetLoggingModuleName());
   module_spec_list.Append(module_file_spec);
 
   // We aren't specifying a source file set.
   FileSpecList *source_spec_list = nullptr;
 
   const char *func_name = "_libtrace_init";
   const lldb::addr_t offset = 0;
   const LazyBool skip_prologue = eLazyBoolCalculate;

source/Plugins/SymbolFile/DWARF/DWARFDebugLine.cpp

bool DWARFDebugLine::ParseSupportFiles(
   }
 
   FileSpec file_spec;
   std::string remapped_file;
 
   for (uint32_t file_idx = 1;
        prologue.GetFile(file_idx, cu_comp_dir, file_spec); ++file_idx) {
     if (module_sp->RemapSourceFile(file_spec.GetPath(), remapped_file))
-      file_spec.SetFile(remapped_file, false, FileSpec::Style::native);
+      file_spec.SetFile(remapped_file, FileSpec::Style::native);
     support_files.Append(file_spec);
   }
   return true;
 }
 
 //----------------------------------------------------------------------
 // ParseStatementTable
 //

 //  }
 //  buff.Append8(0);    // Terminate the file names section with empty string
 //}
 
 bool DWARFDebugLine::Prologue::GetFile(uint32_t file_idx,
     const lldb_private::FileSpec &comp_dir, FileSpec &file) const {
   uint32_t idx = file_idx - 1; // File indexes are 1 based...
   if (idx < file_names.size()) {
-    file.SetFile(file_names[idx].name, false, FileSpec::Style::native);
+    file.SetFile(file_names[idx].name, FileSpec::Style::native);
     if (file.IsRelative()) {
       if (file_names[idx].dir_idx > 0) {
         const uint32_t dir_idx = file_names[idx].dir_idx - 1;
         if (dir_idx < include_directories.size()) {
           file.PrependPathComponent(include_directories[dir_idx]);
           if (!file.IsRelative())
             return true;
         }

source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

static FileSpec resolveCompDir(const char *path_from_dwarf) {
   // Remove the host part if present.
   const char *local_path = removeHostnameFromPathname(path_from_dwarf);
   if (!local_path)
     return FileSpec();
 
   bool is_symlink = false;
   // Always normalize our compile unit directory to get rid of redundant
   // slashes and other path anomalies before we use it for path prepending
-  FileSpec local_spec(local_path, false);
+  FileSpec local_spec(local_path);
   const auto &file_specs = GetGlobalPluginProperties()->GetSymLinkPaths();
   for (size_t i = 0; i < file_specs.GetSize() && !is_symlink; ++i)
     is_symlink = FileSpec::Equal(file_specs.GetFileSpecAtIndex(i),
                                  local_spec, true);
 
   if (!is_symlink)
     return local_spec;
 
if (comp_unit) {
         // Let the debug map create the compile unit
         cu_sp = m_debug_map_symfile->GetCompileUnit(this);
         dwarf_cu->SetUserData(cu_sp.get());
       } else {
         ModuleSP module_sp(m_obj_file->GetModule());
         if (module_sp) {
           const DWARFDIE cu_die = dwarf_cu->DIE();
           if (cu_die) {
-            FileSpec cu_file_spec{cu_die.GetName(), false};
+            FileSpec cu_file_spec(cu_die.GetName());
             if (cu_file_spec) {
               // If we have a full path to the compile unit, we don't need to
               // resolve the file.  This can be expensive e.g. when the source
               // files are
               // NFS mounted.
               if (cu_file_spec.IsRelative()) {
                 const char *cu_comp_dir{
                     cu_die.GetAttributeValueAsString(DW_AT_comp_dir, nullptr)};
                 cu_file_spec.PrependPathComponent(resolveCompDir(cu_comp_dir));
               }
 
               std::string remapped_file;
               if (module_sp->RemapSourceFile(cu_file_spec.GetPath(),
                                              remapped_file))
-                cu_file_spec.SetFile(remapped_file, false,
-                                     FileSpec::Style::native);
+                cu_file_spec.SetFile(remapped_file, FileSpec::Style::native);
             }
 
             LanguageType cu_language = DWARFUnit::LanguageTypeFromDWARF(
                 cu_die.GetAttributeValueAsUnsigned(DW_AT_language, 0));
 
             bool is_optimized = dwarf_cu->GetIsOptimized();
             cu_sp.reset(new CompileUnit(
                 module_sp, dwarf_cu, cu_file_spec, dwarf_cu->GetID(),
if (dwp_symfile) {
     uint64_t dwo_id = cu_die.GetAttributeValueAsUnsigned(this, &dwarf_cu,
                                                          DW_AT_GNU_dwo_id, 0);
     std::unique_ptr<SymbolFileDWARFDwo> dwo_symfile =
         dwp_symfile->GetSymbolFileForDwoId(&dwarf_cu, dwo_id);
     if (dwo_symfile)
       return dwo_symfile;
   }
 
-  FileSpec dwo_file(dwo_name, true);
+  FileSpec dwo_file(dwo_name);
+  FileSystem::Instance().Resolve(dwo_file);
   if (dwo_file.IsRelative()) {
     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.SetFile(comp_dir, FileSpec::Style::native);
+    FileSystem::Instance().Resolve(dwo_file);
     dwo_file.AppendPathComponent(dwo_name);
   }
 
   if (!FileSystem::Instance().Exists(dwo_file))
     return nullptr;
 
   const lldb::offset_t file_offset = 0;
   DataBufferSP dwo_file_data_sp;
if (die && die.HasChildren() == false) {
         ConstString const_name(name);
         if (m_external_type_modules.find(const_name) ==
             m_external_type_modules.end()) {
           ModuleSP module_sp;
           const char *dwo_path =
               die.GetAttributeValueAsString(DW_AT_GNU_dwo_name, nullptr);
           if (dwo_path) {
             ModuleSpec dwo_module_spec;
-            dwo_module_spec.GetFileSpec().SetFile(dwo_path, false,
+            dwo_module_spec.GetFileSpec().SetFile(dwo_path,
                                                   FileSpec::Style::native);
             if (dwo_module_spec.GetFileSpec().IsRelative()) {
               const char *comp_dir =
                   die.GetAttributeValueAsString(DW_AT_comp_dir, nullptr);
               if (comp_dir) {
-                dwo_module_spec.GetFileSpec().SetFile(comp_dir, true,
+                dwo_module_spec.GetFileSpec().SetFile(comp_dir,
                                                       FileSpec::Style::native);
+                FileSystem::Instance().Resolve(dwo_module_spec.GetFileSpec());
                 dwo_module_spec.GetFileSpec().AppendPathComponent(dwo_path);
               }
             }
             dwo_module_spec.GetArchitecture() =
                 m_obj_file->GetModule()->GetArchitecture();
 
             // When LLDB loads "external" modules it looks at the presence of
             // DW_AT_GNU_dwo_name. However, when the already created module
SymbolFileDWARF::GetLocationListFormat() const {
   return DWARFExpression::RegularLocationList;
 }
 
 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(m_obj_file->GetFileSpec().GetPath() + ".dwp");
     FileSpec dwp_filespec = Symbols::LocateExecutableSymbolFile(module_spec);
     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 (oso_index_count > 0) {
         const uint32_t so_idx = oso_indexes[i] - 1;
         const uint32_t oso_idx = oso_indexes[i];
         const Symbol *so_symbol = symtab->SymbolAtIndex(so_idx);
         const Symbol *oso_symbol = symtab->SymbolAtIndex(oso_idx);
         if (so_symbol && oso_symbol &&
             so_symbol->GetType() == eSymbolTypeSourceFile &&
             oso_symbol->GetType() == eSymbolTypeObjectFile) {
           m_compile_unit_infos[i].so_file.SetFile(
-              so_symbol->GetName().AsCString(), false, FileSpec::Style::native);
+              so_symbol->GetName().AsCString(), FileSpec::Style::native);
           m_compile_unit_infos[i].oso_path = oso_symbol->GetName();
           m_compile_unit_infos[i].oso_mod_time =
               llvm::sys::toTimePoint(oso_symbol->GetIntegerValue(0));
           uint32_t sibling_idx = so_symbol->GetSiblingIndex();
           // The sibling index can't be less that or equal to the current index
           // "i"
           if (sibling_idx == UINT32_MAX) {
             m_obj_file->GetModule()->ReportError(
if (!comp_unit_info->oso_sp) {
     if (pos != m_oso_map.end()) {
       comp_unit_info->oso_sp = pos->second;
     } 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);
+      FileSpec oso_file(oso_path);
       ConstString oso_object;
       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",

source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.cpp

lldb::LanguageType lang =
                          : lldb::eLanguageTypeUnknown;
 
   LazyBool optimized = eLazyBoolNo;
   if (cci.m_compile_opts && cci.m_compile_opts->hasOptimizations())
     optimized = eLazyBoolYes;
 
   llvm::StringRef source_file_name =
       m_index->compilands().GetMainSourceFile(cci);
-  FileSpec fs(source_file_name, false);
+  FileSpec fs(source_file_name);
 
   CompUnitSP cu_sp =
       std::make_shared<CompileUnit>(m_obj_file->GetModule(), nullptr, fs,
                                     cci.m_uid.toOpaqueId(), lang, optimized);
 
   const PdbCompilandId &cuid = cci.m_uid.asCompiland();
   m_obj_file->GetModule()->GetSymbolVendor()->SetCompileUnitAtIndex(cuid.modi,
                                                                     cu_sp);
bool SymbolFileNativePDB::ParseCompileUnitSupportFiles(
   lldbassert(comp_uid.tag() == PDB_SymType::Compiland);
 
   const CompilandIndexItem *cci = m_index->compilands().GetCompiland(comp_uid);
   lldbassert(cci);
 
   for (llvm::StringRef f : cci->m_file_list) {
     FileSpec::Style style =
         f.startswith("/") ? FileSpec::Style::posix : FileSpec::Style::windows;
-    FileSpec spec(f, false, style);
+    FileSpec spec(f, style);
     support_files.Append(spec);
   }
 
   return true;
 }
 
 bool SymbolFileNativePDB::ParseImportedModules(
     const SymbolContext &sc, std::vector<ConstString> &imported_modules) {

source/Plugins/SymbolFile/PDB/PDBASTParser.cpp

if (!first_line_up) {
     if (!first_line_up)
       return false;
   }
   uint32_t src_file_id = first_line_up->getSourceFileId();
   auto src_file_up = symbol.getSession().getSourceFileById(src_file_id);
   if (!src_file_up)
     return false;
 
-  FileSpec spec(src_file_up->getFileName(), /*resolve_path*/ false);
+  FileSpec spec(src_file_up->getFileName());
   decl.SetFile(spec);
   decl.SetColumn(first_line_up->getColumnNumber());
   decl.SetLine(first_line_up->getLineNumber());
   return true;
 }
 
 static AccessType TranslateMemberAccess(PDB_MemberAccess access) {
   switch (access) {

source/Plugins/SymbolFile/PDB/SymbolFilePDB.cpp

bool SymbolFilePDB::ParseCompileUnitSupportFiles(
   auto compiland_up = GetPDBCompilandByUID(sc.comp_unit->GetID());
   if (!compiland_up)
     return false;
   auto files = m_session_up->getSourceFilesForCompiland(*compiland_up);
   if (!files || files->getChildCount() == 0)
     return false;
 
   while (auto file = files->getNext()) {
-    FileSpec spec(file->getFileName(), false, FileSpec::Style::windows);
+    FileSpec spec(file->getFileName(), FileSpec::Style::windows);
     support_files.AppendIfUnique(spec);
   }
 
   // LLDB uses the DWARF-like file numeration (one based),
   // the zeroth file is the compile unit itself
   support_files.Insert(0, *sc.comp_unit);
 
   return true;
while (auto compiland = compilands->getNext()) {
       // If we're not checking inlines, then don't add line information for
       // this file unless the FileSpec matches. For inline functions, we don't
       // have to match the FileSpec since they could be defined in headers
       // other than file specified in FileSpec.
       if (!check_inlines) {
         std::string source_file = compiland->getSourceFileFullPath();
         if (source_file.empty())
           continue;
-        FileSpec this_spec(source_file, false, FileSpec::Style::windows);
+        FileSpec this_spec(source_file, FileSpec::Style::windows);
         bool need_full_match = !file_spec.GetDirectory().IsEmpty();
         if (FileSpec::Compare(file_spec, this_spec, need_full_match) != 0)
           continue;
       }
 
       SymbolContext sc;
       auto cu = ParseCompileUnitForUID(compiland->getSymIndexId());
       if (!cu)
VariableSP SymbolFilePDB::ParseVariableForPDBData(
 
   Declaration decl;
   if (!is_artificial && !pdb_data.isCompilerGenerated()) {
     if (auto lines = pdb_data.getLineNumbers()) {
       if (auto first_line = lines->getNext()) {
         uint32_t src_file_id = first_line->getSourceFileId();
         auto src_file = m_session_up->getSourceFileById(src_file_id);
         if (src_file) {
-          FileSpec spec(src_file->getFileName(), /*resolve_path*/ false);
+          FileSpec spec(src_file->getFileName());
           decl.SetFile(spec);
           decl.SetColumn(first_line->getColumnNumber());
           decl.SetLine(first_line->getLineNumber());
         }
       }
     }
   }
 

source/Plugins/SymbolVendor/ELF/SymbolVendorELF.cpp

SymbolVendorELF::CreateInstance(const lldb::ModuleSP &module_sp,
   Timer scoped_timer(func_cat, "SymbolVendorELF::CreateInstance (module = %s)",
                      module_sp->GetFileSpec().GetPath().c_str());
 
   for (size_t idx = 0; idx < file_spec_list.GetSize(); ++idx) {
     ModuleSpec module_spec;
     const FileSpec fspec = file_spec_list.GetFileSpecAtIndex(idx);
 
     module_spec.GetFileSpec() = obj_file->GetFileSpec();
-    module_spec.GetFileSpec().ResolvePath();
+    FileSystem::Instance().Resolve(module_spec.GetFileSpec());
     module_spec.GetSymbolFileSpec() = fspec;
     module_spec.GetUUID() = uuid;
     FileSpec dsym_fspec = Symbols::LocateExecutableSymbolFile(module_spec);
     if (dsym_fspec) {
       DataBufferSP dsym_file_data_sp;
       lldb::offset_t dsym_file_data_offset = 0;
       ObjectFileSP dsym_objfile_sp =
           ObjectFile::FindPlugin(module_sp, &dsym_fspec, 0,

source/Plugins/SymbolVendor/MacOSX/SymbolVendorMacOSX.cpp

if (dsym_fspec) {
               std::string uuid_str = dsym_uuid.GetAsString();
               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);
+                  FileSpec dsym_uuid_plist_spec(dsym_uuid_plist_path);
                   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
if (dsym_fspec) {
                                     object->GetStringValue();
                                 if (new_style_source_remapping_dictionary ==
                                         false &&
                                     !original_DBGSourcePath_value.empty()) {
                                   DBGSourcePath = original_DBGSourcePath_value;
                                 }
                                 if (DBGSourcePath[0] == '~') {
                                   FileSpec resolved_source_path(
-                                      DBGSourcePath.c_str(), true);
+                                      DBGSourcePath.c_str());
+                                  FileSystem::Instance().Resolve(
+                                      resolved_source_path);
                                   DBGSourcePath =
                                       resolved_source_path.GetPath();
                                 }
                                 module_sp->GetSourceMappingList().Append(
                                     key, ConstString(DBGSourcePath), true);
                                 // With version 2 of DBGSourcePathRemapping, we
                                 // can chop off the last two filename parts
                                 // from the source remapping and get a more
                                 // general source remapping that still works.
                                 // Add this as another option in addition to
                                 // the full source path remap.
                                 if (do_truncate_remapping_names) {
-                                  FileSpec build_path(key.AsCString(), false);
-                                  FileSpec source_path(DBGSourcePath.c_str(), false);
+                                  FileSpec build_path(key.AsCString());
+                                  FileSpec source_path(DBGSourcePath.c_str());
                                   build_path.RemoveLastPathComponent();
                                   build_path.RemoveLastPathComponent();
                                   source_path.RemoveLastPathComponent();
                                   source_path.RemoveLastPathComponent();
                                   module_sp->GetSourceMappingList().Append(
                                       ConstString(build_path.GetPath().c_str()),
                                       ConstString(source_path.GetPath().c_str()), true);
                                 }
                               }
                               return true;
                             });
                       }
 
                       // If we have a DBGBuildSourcePath + DBGSourcePath pair,
                       // append those to the source path remappings.
 
                       plist.GetValueAsString("DBGBuildSourcePath",
                                              DBGBuildSourcePath);
                       plist.GetValueAsString("DBGSourcePath", DBGSourcePath);
                       if (!DBGBuildSourcePath.empty() &&
                           !DBGSourcePath.empty()) {
                         if (DBGSourcePath[0] == '~') {
-                          FileSpec resolved_source_path(DBGSourcePath.c_str(),
-                                                        true);
+                          FileSpec resolved_source_path(DBGSourcePath.c_str());
+                          FileSystem::Instance().Resolve(resolved_source_path);
                           DBGSourcePath = resolved_source_path.GetPath();
                         }
                         module_sp->GetSourceMappingList().Append(
                             ConstString(DBGBuildSourcePath),
                             ConstString(DBGSourcePath), true);
                       }
                     }
                   }

source/Plugins/SystemRuntime/MacOSX/SystemRuntimeMacOSX.cpp

if (m_dispatch_queue_offsets_addr != LLDB_INVALID_ADDRESS)
     return;
 
   static ConstString g_dispatch_queue_offsets_symbol_name(
       "dispatch_queue_offsets");
   const Symbol *dispatch_queue_offsets_symbol = NULL;
 
   // libdispatch symbols were in libSystem.B.dylib up through Mac OS X 10.6
   // ("Snow Leopard")
-  ModuleSpec libSystem_module_spec(FileSpec("libSystem.B.dylib", false));
+  ModuleSpec libSystem_module_spec(FileSpec("libSystem.B.dylib"));
   ModuleSP module_sp(m_process->GetTarget().GetImages().FindFirstModule(
       libSystem_module_spec));
   if (module_sp)
     dispatch_queue_offsets_symbol = module_sp->FindFirstSymbolWithNameAndType(
         g_dispatch_queue_offsets_symbol_name, eSymbolTypeData);
 
   // libdispatch symbols are in their own dylib as of Mac OS X 10.7 ("Lion")
   // and later
   if (dispatch_queue_offsets_symbol == NULL) {
-    ModuleSpec libdispatch_module_spec(FileSpec("libdispatch.dylib", false));
+    ModuleSpec libdispatch_module_spec(FileSpec("libdispatch.dylib"));
     module_sp = m_process->GetTarget().GetImages().FindFirstModule(
         libdispatch_module_spec);
     if (module_sp)
       dispatch_queue_offsets_symbol = module_sp->FindFirstSymbolWithNameAndType(
           g_dispatch_queue_offsets_symbol_name, eSymbolTypeData);
   }
   if (dispatch_queue_offsets_symbol)
     m_dispatch_queue_offsets_addr =

 void SystemRuntimeMacOSX::ReadLibpthreadOffsetsAddress() {
   if (m_libpthread_layout_offsets_addr != LLDB_INVALID_ADDRESS)
     return;
 
   static ConstString g_libpthread_layout_offsets_symbol_name(
       "pthread_layout_offsets");
   const Symbol *libpthread_layout_offsets_symbol = NULL;
 
-  ModuleSpec libpthread_module_spec(FileSpec("libsystem_pthread.dylib", false));
+  ModuleSpec libpthread_module_spec(FileSpec("libsystem_pthread.dylib"));
   ModuleSP module_sp(m_process->GetTarget().GetImages().FindFirstModule(
       libpthread_module_spec));
   if (module_sp) {
     libpthread_layout_offsets_symbol =
         module_sp->FindFirstSymbolWithNameAndType(
             g_libpthread_layout_offsets_symbol_name, eSymbolTypeData);
     if (libpthread_layout_offsets_symbol) {
       m_libpthread_layout_offsets_addr =

 void SystemRuntimeMacOSX::ReadLibdispatchTSDIndexesAddress() {
   if (m_dispatch_tsd_indexes_addr != LLDB_INVALID_ADDRESS)
     return;
 
   static ConstString g_libdispatch_tsd_indexes_symbol_name(
       "dispatch_tsd_indexes");
   const Symbol *libdispatch_tsd_indexes_symbol = NULL;
 
-  ModuleSpec libpthread_module_spec(FileSpec("libdispatch.dylib", false));
+  ModuleSpec libpthread_module_spec(FileSpec("libdispatch.dylib"));
   ModuleSP module_sp(m_process->GetTarget().GetImages().FindFirstModule(
       libpthread_module_spec));
   if (module_sp) {
     libdispatch_tsd_indexes_symbol = module_sp->FindFirstSymbolWithNameAndType(
         g_libdispatch_tsd_indexes_symbol_name, eSymbolTypeData);
     if (libdispatch_tsd_indexes_symbol) {
       m_dispatch_tsd_indexes_addr =
           libdispatch_tsd_indexes_symbol->GetLoadAddress(

source/Symbol/CompileUnit.cpp

 
 using namespace lldb;
 using namespace lldb_private;
 
 CompileUnit::CompileUnit(const lldb::ModuleSP &module_sp, void *user_data,
                          const char *pathname, const lldb::user_id_t cu_sym_id,
                          lldb::LanguageType language,
                          lldb_private::LazyBool is_optimized)
-    : ModuleChild(module_sp), FileSpec(pathname, false), UserID(cu_sym_id),
+    : ModuleChild(module_sp), FileSpec(pathname), UserID(cu_sym_id),
       m_user_data(user_data), m_language(language), m_flags(0),
       m_support_files(), m_line_table_ap(), m_variables(),
       m_is_optimized(is_optimized) {
   if (language != eLanguageTypeUnknown)
     m_flags.Set(flagsParsedLanguage);
   assert(module_sp);
 }
 

source/Symbol/ObjectFile.cpp

bool ObjectFile::SplitArchivePathWithObject(const char *path_with_object,
   RegularExpression g_object_regex(llvm::StringRef("(.*)\\(([^\\)]+)\\)$"));
   RegularExpression::Match regex_match(2);
   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_file.SetFile(path, FileSpec::Style::native);
       archive_object.SetCString(obj.c_str());
       if (must_exist && !FileSystem::Instance().Exists(archive_file))
         return false;
       return true;
     }
   }
   return false;
 }

source/Symbol/Symbol.cpp

 
 FileSpec Symbol::GetReExportedSymbolSharedLibrary() const {
   if (m_type == eSymbolTypeReExported) {
     // For eSymbolTypeReExported, the "const char *" from a ConstString is used
     // as the offset in the address range base address. We can then make this
     // back into a string that is the re-exported name.
     intptr_t str_ptr = m_addr_range.GetByteSize();
     if (str_ptr != 0)
-      return FileSpec((const char *)str_ptr, false);
+      return FileSpec((const char *)str_ptr);
   }
   return FileSpec();
 }
 
 void Symbol::SetReExportedSymbolName(const ConstString &name) {
   SetType(eSymbolTypeReExported);
   // For eSymbolTypeReExported, the "const char *" from a ConstString is used
   // as the offset in the address range base address.

source/Symbol/SymbolContext.cpp

bool SymbolContextSpecifier::AddSpecification(const char *spec_string,
                                               SpecificationType type) {
   bool return_value = true;
   switch (type) {
   case eNothingSpecified:
     Clear();
     break;
   case eModuleSpecified: {
     // See if we can find the Module, if so stick it in the SymbolContext.
-    FileSpec module_file_spec(spec_string, false);
+    FileSpec module_file_spec(spec_string);
     ModuleSpec module_spec(module_file_spec);
     lldb::ModuleSP module_sp(
         m_target_sp->GetImages().FindFirstModule(module_spec));
     m_type |= eModuleSpecified;
     if (module_sp)
       m_module_sp = module_sp;
     else
       m_module_spec.assign(spec_string);
   } break;
   case eFileSpecified:
     // CompUnits can't necessarily be resolved here, since an inlined function
     // might show up in a number of CompUnits.  Instead we just convert to a
     // FileSpec and store it away.
-    m_file_spec_ap.reset(new FileSpec(spec_string, false));
+    m_file_spec_ap.reset(new FileSpec(spec_string));
     m_type |= eFileSpecified;
     break;
   case eLineStartSpecified:
     m_start_line = StringConvert::ToSInt32(spec_string, 0, 0, &return_value);
     if (return_value)
       m_type |= eLineStartSpecified;
     break;
   case eLineEndSpecified:
if (m_target_sp.get() != sc.target_sp.get())
     return false;
 
   if (m_type & eModuleSpecified) {
     if (sc.module_sp) {
       if (m_module_sp.get() != nullptr) {
         if (m_module_sp.get() != sc.module_sp.get())
           return false;
       } else {
-        FileSpec module_file_spec(m_module_spec, false);
+        FileSpec module_file_spec(m_module_spec);
         if (!FileSpec::Equal(module_file_spec, sc.module_sp->GetFileSpec(),
                              false))
           return false;
       }
     }
   }
   if (m_type & eFileSpecified) {
     if (m_file_spec_ap.get()) {

source/Target/ModuleCache.cpp

 }
 
 FileSpec GetModuleDirectory(const FileSpec &root_dir_spec, const UUID &uuid) {
   const auto modules_dir_spec = JoinPath(root_dir_spec, kModulesSubdir);
   return JoinPath(modules_dir_spec, uuid.GetAsString().c_str());
 }
 
 FileSpec GetSymbolFileSpec(const FileSpec &module_file_spec) {
-  return FileSpec(module_file_spec.GetPath() + kSymFileExtension, false);
+  return FileSpec(module_file_spec.GetPath() + kSymFileExtension);
 }
 
 void DeleteExistingModule(const FileSpec &root_dir_spec,
                           const FileSpec &sysroot_module_path_spec) {
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_MODULES));
   UUID module_uuid;
   {
     auto module_sp =
Status CreateHostSysRootModuleLink(const FileSpec &root_dir_spec,
   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));
+      FileSpec(sysroot_module_path_spec.GetDirectory().AsCString()));
   if (error.Fail())
     return error;
 
   return llvm::sys::fs::create_hard_link(local_module_spec.GetPath(),
                                          sysroot_module_path_spec.GetPath());
 }
 
 } // namespace

source/Target/PathMappingList.cpp

namespace {
   // info contains "./foo/bar.c", the path will get normalized to "foo/bar.c".
   // When PathMappingList::RemapPath() is called, it expects the path to start
   // with the raw path pair, which doesn't work anymore because the paths have
   // been normalized when the debug info was loaded. So we need to store
   // nomalized path pairs to ensure things match up.
   ConstString NormalizePath(const ConstString &path) {
     // If we use "path" to construct a FileSpec, it will normalize the path for
     // us. We then grab the string and turn it back into a ConstString.
-    return ConstString(FileSpec(path.GetStringRef(), false).GetPath());
+    return ConstString(FileSpec(path.GetStringRef()).GetPath());
   }
 }
 //----------------------------------------------------------------------
 // PathMappingList constructor
 //----------------------------------------------------------------------
 PathMappingList::PathMappingList()
     : m_pairs(), m_callback(nullptr), m_callback_baton(nullptr), m_mod_id(0) {}
 
if (!path.consume_front(prefix)) {
       // Relative paths won't have a leading "./" in them unless "." is the
       // only thing in the relative path so we need to work around "."
       // carefully.
       if (prefix != ".")
         continue;
       // We need to figure out if the "path" argument is relative. If it is,
       // then we should remap, else skip this entry.
       if (path_is_relative == eLazyBoolCalculate) {
-        path_is_relative = FileSpec(path, false).IsRelative() ? eLazyBoolYes :
-        eLazyBoolNo;
+        path_is_relative =
+            FileSpec(path).IsRelative() ? eLazyBoolYes : eLazyBoolNo;
       }
       if (!path_is_relative)
         continue;
     }
-    FileSpec remapped(it.second.GetStringRef(), false);
+    FileSpec remapped(it.second.GetStringRef());
     remapped.AppendPathComponent(path);
     new_path = remapped.GetPath();
     return true;
   }
   return false;
 }
 
 bool PathMappingList::ReverseRemapPath(const FileSpec &file, FileSpec &fixed) const {
   std::string path = file.GetPath();
   llvm::StringRef path_ref(path);
   for (const auto &it : m_pairs) {
     if (!path_ref.consume_front(it.second.GetStringRef()))
       continue;
-    fixed.SetFile(it.first.GetStringRef(), false, FileSpec::Style::native);
+    fixed.SetFile(it.first.GetStringRef(), FileSpec::Style::native);
     fixed.AppendPathComponent(path_ref);
     return true;
   }
   return false;
 }
 
 bool PathMappingList::FindFile(const FileSpec &orig_spec,
                                FileSpec &new_spec) const {
   if (!m_pairs.empty()) {
     char orig_path[PATH_MAX];
     const size_t orig_path_len =
         orig_spec.GetPath(orig_path, sizeof(orig_path));
     if (orig_path_len > 0) {
       const_iterator pos, end = m_pairs.end();
       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.SetFile(pos->second.GetCString(), FileSpec::Style::native);
             new_spec.AppendPathComponent(orig_path + prefix_len);
             if (FileSystem::Instance().Exists(new_spec))
               return true;
           }
         }
       }
     }
   }

source/Target/Platform.cpp

PlatformProperties::PlatformProperties() {
   auto module_cache_dir = GetModuleCacheDirectory();
   if (module_cache_dir)
     return;
 
   llvm::SmallString<64> user_home_dir;
   if (!llvm::sys::path::home_directory(user_home_dir))
     return;
 
-  module_cache_dir = FileSpec(user_home_dir.c_str(), false);
+  module_cache_dir = FileSpec(user_home_dir.c_str());
   module_cache_dir.AppendPathComponent(".lldb");
   module_cache_dir.AppendPathComponent("module_cache");
   SetModuleCacheDirectory(module_cache_dir);
 }
 
 bool PlatformProperties::GetUseModuleCache() const {
   const auto idx = ePropertyUseModuleCache;
   return m_collection_sp->GetPropertyAtIndexAsBoolean(
void Platform::AddClangModuleCompilationOptions(
   options.insert(options.end(), default_compilation_options.begin(),
                  default_compilation_options.end());
 }
 
 FileSpec Platform::GetWorkingDirectory() {
   if (IsHost()) {
     llvm::SmallString<64> cwd;
     if (llvm::sys::fs::current_path(cwd))
-      return FileSpec{};
-    else
-      return FileSpec(cwd, true);
+      return {};
+    else {
+      FileSpec file_spec(cwd);
+      FileSystem::Instance().Resolve(file_spec);
+      return file_spec;
+    }
   } else {
     if (!m_working_dir)
       m_working_dir = GetRemoteWorkingDirectory();
     return m_working_dir;
   }
 }
 
 struct RecurseCopyBaton {
   const FileSpec &dst;
   Platform *platform_ptr;
   Status error;
 };
 
 static FileSystem::EnumerateDirectoryResult
 RecurseCopy_Callback(void *baton, llvm::sys::fs::file_type ft,
                      llvm::StringRef path) {
   RecurseCopyBaton *rc_baton = (RecurseCopyBaton *)baton;
-  FileSpec src(path, false);
+  FileSpec src(path);
   namespace fs = llvm::sys::fs;
   switch (ft) {
   case fs::file_type::fifo_file:
   case fs::file_type::socket_file:
     // we have no way to copy pipes and sockets - ignore them and continue
     return FileSystem::eEnumerateDirectoryResultNext;
     break;
 
Status Platform::ResolveSymbolFile(Target &target, const ModuleSpec &sym_spec,
   else
     error.SetErrorString("unable to resolve symbol file");
   return error;
 }
 
 bool Platform::ResolveRemotePath(const FileSpec &platform_path,
                                  FileSpec &resolved_platform_path) {
   resolved_platform_path = platform_path;
-  return resolved_platform_path.ResolvePath();
+  FileSystem::Instance().Resolve(resolved_platform_path);
+  return true;
 }
 
 const ArchSpec &Platform::GetSystemArchitecture() {
   if (IsHost()) {
     if (!m_system_arch.IsValid()) {
       // We have a local host platform
       m_system_arch = HostInfo::GetArchitecture();
       m_system_arch_set_while_connected = m_system_arch.IsValid();

 uint32_t Platform::LoadImageUsingPaths(lldb_private::Process *process,
                                const lldb_private::FileSpec &remote_filename,
                                const std::vector<std::string> &paths,
                                lldb_private::Status &error,
                                lldb_private::FileSpec *loaded_path)
 {
   FileSpec file_to_use;
   if (remote_filename.IsAbsolute())
-    file_to_use = FileSpec(remote_filename.GetFilename().GetStringRef(), 
-                               false, 
-                               remote_filename.GetPathStyle());
+    file_to_use = FileSpec(remote_filename.GetFilename().GetStringRef(),
+
   else
     file_to_use = remote_filename;
     
   return DoLoadImage(process, file_to_use, &paths, error, loaded_path);
 }
 
 Status Platform::UnloadImage(lldb_private::Process *process,
                              uint32_t image_token) {

source/Target/Process.cpp

Status ProcessLaunchCommandOptions::SetOptionValue(
   switch (short_option) {
   case 's': // Stop at program entry point
     launch_info.GetFlags().Set(eLaunchFlagStopAtEntry);
     break;
 
   case 'i': // STDIN for read only
   {
     FileAction action;
-    if (action.Open(STDIN_FILENO, FileSpec{option_arg, false}, true, false))
+    if (action.Open(STDIN_FILENO, FileSpec(option_arg), true, false))
       launch_info.AppendFileAction(action);
     break;
   }
 
   case 'o': // Open STDOUT for write only
   {
     FileAction action;
-    if (action.Open(STDOUT_FILENO, FileSpec{option_arg, false}, false, true))
+    if (action.Open(STDOUT_FILENO, FileSpec(option_arg), false, true))
       launch_info.AppendFileAction(action);
     break;
   }
 
   case 'e': // STDERR for write only
   {
     FileAction action;
-    if (action.Open(STDERR_FILENO, FileSpec{option_arg, false}, false, true))
+    if (action.Open(STDERR_FILENO, FileSpec(option_arg), false, true))
       launch_info.AppendFileAction(action);
     break;
   }
 
   case 'p': // Process plug-in name
     launch_info.SetProcessPluginName(option_arg);
     break;
 
   case 'n': // Disable STDIO
   {
     FileAction action;
-    const FileSpec dev_null{FileSystem::DEV_NULL, false};
+    const FileSpec dev_null(FileSystem::DEV_NULL);
     if (action.Open(STDIN_FILENO, dev_null, true, false))
       launch_info.AppendFileAction(action);
     if (action.Open(STDOUT_FILENO, dev_null, false, true))
       launch_info.AppendFileAction(action);
     if (action.Open(STDERR_FILENO, dev_null, false, true))
       launch_info.AppendFileAction(action);
     break;
   }
 
   case 'w':
-    launch_info.SetWorkingDirectory(FileSpec{option_arg, false});
+    launch_info.SetWorkingDirectory(FileSpec(option_arg));
     break;
 
   case 't': // Open process in new terminal window
     launch_info.GetFlags().Set(eLaunchFlagLaunchInTTY);
     break;
 
   case 'a': {
     TargetSP target_sp =
else
       error.SetErrorStringWithFormat(
           "Invalid boolean value for shell-expand-args option: '%s'",
           option_arg.empty() ? "<null>" : option_arg.str().c_str());
     break;
   }
 
   case 'c':
     if (!option_arg.empty())
-      launch_info.SetShell(FileSpec(option_arg, false));
+      launch_info.SetShell(FileSpec(option_arg));
     else
       launch_info.SetShell(HostInfo::GetDefaultShell());
     break;
 
   case 'v':
     launch_info.GetEnvironment().insert(option_arg);
     break;
 

source/Target/ProcessInfo.cpp

 using namespace lldb_private;
 
 ProcessInfo::ProcessInfo()
     : m_executable(), m_arguments(), m_environment(), m_uid(UINT32_MAX),
       m_gid(UINT32_MAX), m_arch(), m_pid(LLDB_INVALID_PROCESS_ID) {}
 
 ProcessInfo::ProcessInfo(const char *name, const ArchSpec &arch,
                          lldb::pid_t pid)
-    : m_executable(name, false), m_arguments(), m_environment(),
-      m_uid(UINT32_MAX), m_gid(UINT32_MAX), m_arch(arch), m_pid(pid) {}
+    : m_executable(name), m_arguments(), m_environment(), m_uid(UINT32_MAX),
+      m_gid(UINT32_MAX), m_arch(arch), m_pid(pid) {}
 
 void ProcessInfo::Clear() {
   m_executable.Clear();
   m_arguments.Clear();
   m_environment.clear();
   m_uid = UINT32_MAX;
   m_gid = UINT32_MAX;
   m_arch.Clear();
void ProcessInfo::SetArguments(char const **argv,
 
   // Is the first argument the executable?
   if (first_arg_is_executable) {
     const char *first_arg = m_arguments.GetArgumentAtIndex(0);
     if (first_arg) {
       // Yes the first argument is an executable, set it as the executable in
       // the launch options. Don't resolve the file path as the path could be a
       // remote platform path
-      const bool resolve = false;
-      m_executable.SetFile(first_arg, resolve, FileSpec::Style::native);
+      m_executable.SetFile(first_arg, FileSpec::Style::native);
     }
   }
 }
 
 void ProcessInfo::SetArguments(const Args &args, bool first_arg_is_executable) {
   // Copy all arguments
   m_arguments = args;
 
   // Is the first argument the executable?
   if (first_arg_is_executable) {
     const char *first_arg = m_arguments.GetArgumentAtIndex(0);
     if (first_arg) {
       // Yes the first argument is an executable, set it as the executable in
       // the launch options. Don't resolve the file path as the path could be a
       // remote platform path
-      const bool resolve = false;
-      m_executable.SetFile(first_arg, resolve, FileSpec::Style::native);
+      m_executable.SetFile(first_arg, FileSpec::Style::native);
     }
   }
 }

source/Target/ProcessLaunchInfo.cpp

if (file_action.Open(fd, file_spec, read, write)) {
     return true;
   }
   return false;
 }
 
 bool ProcessLaunchInfo::AppendSuppressFileAction(int fd, bool read,
                                                  bool write) {
   FileAction file_action;
-  if (file_action.Open(fd, FileSpec{FileSystem::DEV_NULL, false}, read,
-                       write)) {
+  if (file_action.Open(fd, FileSpec(FileSystem::DEV_NULL), read, write)) {
     AppendFileAction(file_action);
     return true;
   }
   return false;
 }
 
 const FileAction *ProcessLaunchInfo::GetFileActionAtIndex(size_t idx) const {
   if (idx < m_file_actions.size())
if (m_flags.Test(eLaunchFlagDisableSTDIO)) {
         int open_flags = O_RDWR | O_NOCTTY;
 #if !defined(_WIN32)
         // We really shouldn't be specifying platform specific flags that are
         // intended for a system call in generic code.  But this will have to
         // do for now.
         open_flags |= O_CLOEXEC;
 #endif
         if (m_pty->OpenFirstAvailableMaster(open_flags, nullptr, 0)) {
-          const FileSpec slave_file_spec{m_pty->GetSlaveName(nullptr, 0),
-                                         false};
+          const FileSpec slave_file_spec(m_pty->GetSlaveName(nullptr, 0));
 
           // Only use the slave tty if we don't have anything specified for
           // input and don't have an action for stdin
           if (!in_file_spec && GetFileActionForFD(STDIN_FILENO) == nullptr) {
             AppendOpenFileAction(STDIN_FILENO, slave_file_spec, true, false);
           }
 
           // Only use the slave tty if we don't have anything specified for
if (m_shell) {
       else
         shell_arguments.AppendArgument(llvm::StringRef("-c"));
 
       StreamString shell_command;
       if (will_debug) {
         // Add a modified PATH environment variable in case argv[0] is a
         // relative path.
         const char *argv0 = argv[0];
-        FileSpec arg_spec(argv0, false);
+        FileSpec arg_spec(argv0);
         if (arg_spec.IsRelative()) {
           // We have a relative path to our executable which may not work if we
           // just try to run "a.out" (without it being converted to "./a.out")
           FileSpec working_dir = GetWorkingDirectory();
           // Be sure to put quotes around PATH's value in case any paths have
           // spaces...
           std::string new_path("PATH=\"");
           const size_t empty_path_len = new_path.size();

source/Target/TargetList.cpp

if (!platform_options->PlatformMatches(platform_sp)) {
       if (!platform_sp)
         return error;
     }
   }
 
   if (!user_exe_path.empty()) {
     ModuleSpecList module_specs;
     ModuleSpec module_spec;
-    module_spec.GetFileSpec().SetFile(user_exe_path, true,
-                                      FileSpec::Style::native);
+    module_spec.GetFileSpec().SetFile(user_exe_path, FileSpec::Style::native);
+    FileSystem::Instance().Resolve(module_spec.GetFileSpec());
 
     // Resolve the executable in case we are given a path to a application
     // bundle like a .app bundle on MacOSX
     Host::ResolveExecutableInBundle(module_spec.GetFileSpec());
 
     lldb::offset_t file_offset = 0;
     lldb::offset_t file_size = 0;
     const size_t num_specs = ObjectFile::GetModuleSpecifications(
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);
+  FileSpec file(user_exe_path);
   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);
+      file = FileSpec(user_exe_path);
     else
-      file = FileSpec(unglobbed_path.c_str(), false);
+      file = FileSpec(unglobbed_path.c_str());
   }
 
   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);
+        FileSpec cwd_file(cwd.c_str());
         cwd_file.AppendPathComponent(file);
         if (FileSystem::Instance().Exists(cwd_file))
           file = cwd_file;
       }
     }
 
     ModuleSP exe_module_sp;
     if (platform_sp) {

source/Utility/FileSpec.cpp

 //===-- FileSpec.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/Utility/FileSpec.h"
 #include "lldb/Utility/RegularExpression.h"
 #include "lldb/Utility/Stream.h"
-#include "lldb/Utility/TildeExpressionResolver.h"
 
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/Triple.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/Support/ErrorOr.h"
 #include "llvm/Support/FileSystem.h"
void Denormalize(llvm::SmallVectorImpl<char> &path, FileSpec::Style style) {
   if (PathStyleIsPosix(style))
     return;
 
   std::replace(path.begin(), path.end(), '/', '\\');
 }
 
 } // end anonymous namespace
 
-void FileSpec::Resolve(llvm::SmallVectorImpl<char> &path) {
-  if (path.empty())
-    return;
-
-  llvm::SmallString<32> Source(path.begin(), path.end());
-  StandardTildeExpressionResolver Resolver;
-  Resolver.ResolveFullPath(Source, path);
-
-  // Save a copy of the original path that's passed in
-  llvm::SmallString<128> original_path(path.begin(), path.end());
-
-  llvm::sys::fs::make_absolute(path);
-  if (!llvm::sys::fs::exists(path)) {
-    path.clear();
-    path.append(original_path.begin(), original_path.end());
-  }
-}
-
 FileSpec::FileSpec() : m_style(GetNativeStyle()) {}
 
 //------------------------------------------------------------------
 // Default constructor that can take an optional full path to a file on disk.
 //------------------------------------------------------------------
-FileSpec::FileSpec(llvm::StringRef path, bool resolve_path, Style style)
-    : m_style(style) {
-  SetFile(path, resolve_path, style);
+FileSpec::FileSpec(llvm::StringRef path, Style style) : m_style(style) {
+  SetFile(path, style);
 }
 
-FileSpec::FileSpec(llvm::StringRef path, bool resolve_path,
-                   const llvm::Triple &Triple)
-    : FileSpec{path, resolve_path,
-               Triple.isOSWindows() ? Style::windows : Style::posix} {}
+FileSpec::FileSpec(llvm::StringRef path, const llvm::Triple &Triple)
+    : FileSpec{path, Triple.isOSWindows() ? Style::windows : Style::posix} {}
 
 //------------------------------------------------------------------
 // Copy constructor
 //------------------------------------------------------------------
 FileSpec::FileSpec(const FileSpec &rhs)
     : m_directory(rhs.m_directory), m_filename(rhs.m_filename),
       m_is_resolved(rhs.m_is_resolved), m_style(rhs.m_style) {}
 
if (this != &rhs) {
     m_directory = rhs.m_directory;
     m_filename = rhs.m_filename;
     m_is_resolved = rhs.m_is_resolved;
     m_style = rhs.m_style;
   }
   return *this;
 }
 
-void FileSpec::SetFile(llvm::StringRef pathname, bool resolve) {
-  SetFile(pathname, resolve, m_style);
-}
+void FileSpec::SetFile(llvm::StringRef pathname) { SetFile(pathname, m_style); }
 
 //------------------------------------------------------------------
 // Update the contents of this object with a new path. The path will be split
 // up into a directory and filename and stored as uniqued string values for
 // quick comparison and efficient memory usage.
 //------------------------------------------------------------------
-void FileSpec::SetFile(llvm::StringRef pathname, bool resolve, Style style) {
+void FileSpec::SetFile(llvm::StringRef pathname, Style style) {
   m_filename.Clear();
   m_directory.Clear();
   m_is_resolved = false;
   m_style = (style == Style::native) ? GetNativeStyle() : style;
 
   if (pathname.empty())
     return;
 
-  llvm::SmallString<64> resolved(pathname);
-
-  if (resolve) {
-    FileSpec::Resolve(resolved);
-    m_is_resolved = true;
-  }
+  llvm::SmallString<128> resolved(pathname);
 
   // Normalize the path by removing ".", ".." and other redundant components.
   if (needsNormalization(resolved))
     llvm::sys::path::remove_dots(resolved, true, m_style);
 
   // Normalize back slashes to forward slashes
   if (m_style == Style::windows)
     std::replace(resolved.begin(), resolved.end(), '\\', '/');
 
   if (resolved.empty()) {
     // If we have no path after normalization set the path to the current
     // directory. This matches what python does and also a few other path
     // utilities.
     m_filename.SetString(".");
     return;
   }
 
   // Split path into filename and directory. We rely on the underlying char
   // pointer to be nullptr when the components are empty.
   llvm::StringRef filename = llvm::sys::path::filename(resolved, m_style);
   if(!filename.empty())
     m_filename.SetString(filename);
+
   llvm::StringRef directory = llvm::sys::path::parent_path(resolved, m_style);
   if(!directory.empty())
     m_directory.SetString(directory);
 }
 
-void FileSpec::SetFile(llvm::StringRef path, bool resolve,
-                       const llvm::Triple &Triple) {
-  return SetFile(path, resolve,
-                 Triple.isOSWindows() ? Style::windows : Style::posix);
+void FileSpec::SetFile(llvm::StringRef path, const llvm::Triple &Triple) {
+  return SetFile(path, Triple.isOSWindows() ? Style::windows : Style::posix);
 }
 
 //----------------------------------------------------------------------
 // Convert to pointer operator. This allows code to check any FileSpec objects
 // to see if they contain anything valid using code such as:
 //
 //  if (file_spec)
 //  {}
bool FileSpec::FileEquals(const FileSpec &rhs) const {
   const bool case_sensitive = IsCaseSensitive() || rhs.IsCaseSensitive();
   return ConstString::Equals(m_filename, rhs.m_filename, case_sensitive);
 }
 
 //------------------------------------------------------------------
 // Equal to operator
 //------------------------------------------------------------------
 bool FileSpec::operator==(const FileSpec &rhs) const {
-  if (!FileEquals(rhs))
-    return false;
-  if (DirectoryEquals(rhs))
-    return true;
-
-  // TODO: determine if we want to keep this code in here.
-  // The code below was added to handle a case where we were trying to set a
-  // file and line breakpoint and one path was resolved, and the other not and
-  // the directory was in a mount point that resolved to a more complete path:
-  // "/tmp/a.c" == "/private/tmp/a.c". I might end up pulling this out...
-  if (IsResolved() && rhs.IsResolved()) {
-    // Both paths are resolved, no need to look further...
-    return false;
-  }
-
-  FileSpec resolved_lhs(*this);
-
-  // If "this" isn't resolved, resolve it
-  if (!IsResolved()) {
-    if (resolved_lhs.ResolvePath()) {
-      // This path wasn't resolved but now it is. Check if the resolved
-      // directory is the same as our unresolved directory, and if so, we can
-      // mark this object as resolved to avoid more future resolves
-      m_is_resolved = (m_directory == resolved_lhs.m_directory);
-    } else
-      return false;
-  }
-
-  FileSpec resolved_rhs(rhs);
-  if (!rhs.IsResolved()) {
-    if (resolved_rhs.ResolvePath()) {
-      // rhs's path wasn't resolved but now it is. Check if the resolved
-      // directory is the same as rhs's unresolved directory, and if so, we can
-      // mark this object as resolved to avoid more future resolves
-      rhs.m_is_resolved = (rhs.m_directory == resolved_rhs.m_directory);
-    } else
-      return false;
-  }
-
-  // If we reach this point in the code we were able to resolve both paths and
-  // since we only resolve the paths if the basenames are equal, then we can
-  // just check if both directories are equal...
-  return DirectoryEquals(rhs);
+  return FileEquals(rhs) && DirectoryEquals(rhs);
 }
 
 //------------------------------------------------------------------
 // Not equal to operator
 //------------------------------------------------------------------
 bool FileSpec::operator!=(const FileSpec &rhs) const { return !(*this == rhs); }
 
 //------------------------------------------------------------------
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);
   }
 }
 
-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;
-}
-
 FileSpec::Style FileSpec::GetPathStyle() const { return m_style; }
 
 //------------------------------------------------------------------
 // Directory string get accessor.
 //------------------------------------------------------------------
 ConstString &FileSpec::GetDirectory() { return m_directory; }
 
 //------------------------------------------------------------------
FileSpec::CopyByAppendingPathComponent(llvm::StringRef component) const {
   ret.AppendPathComponent(component);
   return ret;
 }
 
 FileSpec FileSpec::CopyByRemovingLastPathComponent() const {
   llvm::SmallString<64> current_path;
   GetPath(current_path, false);
   if (llvm::sys::path::has_parent_path(current_path, m_style))
-    return FileSpec(llvm::sys::path::parent_path(current_path, m_style), false,
+    return FileSpec(llvm::sys::path::parent_path(current_path, m_style),
                     m_style);
   return *this;
 }
 
 ConstString FileSpec::GetLastPathComponent() const {
   llvm::SmallString<64> current_path;
   GetPath(current_path, false);
   return ConstString(llvm::sys::path::filename(current_path, m_style));
 }
 
 void FileSpec::PrependPathComponent(llvm::StringRef component) {
   llvm::SmallString<64> new_path(component);
   llvm::SmallString<64> current_path;
   GetPath(current_path, false);
   llvm::sys::path::append(new_path,
                           llvm::sys::path::begin(current_path, m_style),
                           llvm::sys::path::end(current_path), m_style);
-  SetFile(new_path, false, m_style);
+  SetFile(new_path, m_style);
 }
 
 void FileSpec::PrependPathComponent(const FileSpec &new_path) {
   return PrependPathComponent(new_path.GetPath(false));
 }
 
 void FileSpec::AppendPathComponent(llvm::StringRef component) {
   llvm::SmallString<64> current_path;
   GetPath(current_path, false);
   llvm::sys::path::append(current_path, m_style, component);
-  SetFile(current_path, false, m_style);
+  SetFile(current_path, m_style);
 }
 
 void FileSpec::AppendPathComponent(const FileSpec &new_path) {
   return AppendPathComponent(new_path.GetPath(false));
 }
 
 bool FileSpec::RemoveLastPathComponent() {
   llvm::SmallString<64> current_path;
   GetPath(current_path, false);
   if (llvm::sys::path::has_parent_path(current_path, m_style)) {
-    SetFile(llvm::sys::path::parent_path(current_path, m_style), false);
+    SetFile(llvm::sys::path::parent_path(current_path, m_style));
     return true;
   }
   return false;
 }
 //------------------------------------------------------------------
 /// Returns true if the filespec represents an implementation source
 /// file (files with a ".c", ".cpp", ".m", ".mm" (many more)
 /// extension).

tools/lldb-server/lldb-gdbserver.cpp

 
 #ifndef _WIN32
 #include <signal.h>
 #include <unistd.h>
 #endif
 
 // C++ Includes
 
-
 #include "Acceptor.h"
 #include "LLDBServerUtilities.h"
 #include "Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.h"
 #include "Plugins/Process/gdb-remote/ProcessGDBRemoteLog.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Host/ConnectionFileDescriptor.h"
+#include "lldb/Host/FileSystem.h"
 #include "lldb/Host/HostGetOpt.h"
 #include "lldb/Host/OptionParser.h"
 #include "lldb/Host/Pipe.h"
 #include "lldb/Host/Socket.h"
 #include "lldb/Host/StringConvert.h"
 #include "lldb/Host/common/NativeProcessProtocol.h"
 #include "lldb/Utility/Status.h"
 #include "llvm/ADT/StringRef.h"
info.GetFlags().Set(eLaunchFlagStopAtEntry | eLaunchFlagDebug |
                       eLaunchFlagDisableASLR);
   info.SetArguments(const_cast<const char **>(argv), true);
 
   llvm::SmallString<64> cwd;
   if (std::error_code ec = llvm::sys::fs::current_path(cwd)) {
     llvm::errs() << "Error getting current directory: " << ec.message() << "\n";
     exit(1);
   }
-  info.SetWorkingDirectory(FileSpec(cwd, true));
+  FileSpec cwd_spec(cwd);
+  FileSystem::Instance().Resolve(cwd_spec);
+  info.SetWorkingDirectory(cwd_spec);
   info.GetEnvironment() = Host::GetEnvironment();
 
   gdb_server.SetLaunchInfo(info);
 
   Status error = gdb_server.LaunchProcess();
   if (error.Fail()) {
     llvm::errs() << llvm::formatv("error: failed to launch '{0}': {1}\n",
                                   argv[0], error);

tools/lldb-server/lldb-platform.cpp

fprintf(stderr, "Usage:\n  %s %s [--log-file log-file-name] [--log-channels "
                   "log-channel-list] [--port-file port-file-path] --server "
                   "--listen port\n",
           progname, subcommand);
   exit(0);
 }
 
 static Status save_socket_id_to_file(const std::string &socket_id,
                                      const FileSpec &file_spec) {
-  FileSpec temp_file_spec(file_spec.GetDirectory().AsCString(), false);
+  FileSpec temp_file_spec(file_spec.GetDirectory().AsCString());
   Status error(llvm::sys::fs::create_directory(temp_file_spec.GetPath()));
   if (error.Fail())
     return Status("Failed to create directory %s: %s",
                   temp_file_spec.GetCString(), error.AsCString());
 
   llvm::SmallString<64> temp_file_path;
   temp_file_spec.AppendPathComponent("port-file.%%%%%%");
   int FD;
while ((ch = getopt_long_only(argc, argv, short_options.c_str(),
 
     case 'c': // Log Channels
       if (optarg && optarg[0])
         log_channels = StringRef(optarg);
       break;
 
     case 'f': // Socket file
       if (optarg && optarg[0])
-        socket_file.SetFile(optarg, false, FileSpec::Style::native);
+        socket_file.SetFile(optarg, FileSpec::Style::native);
       break;
 
     case 'p': {
       if (!llvm::to_integer(optarg, port_offset)) {
         llvm::errs() << "error: invalid port offset string " << optarg << "\n";
         option_error = 4;
         break;
       }

tools/lldb-test/lldb-test.cpp

 }
 
 Error opts::symbols::findFunctions(lldb_private::Module &Module) {
   SymbolVendor &Vendor = *Module.GetSymbolVendor();
   SymbolContextList List;
   if (!File.empty()) {
     assert(Line != 0);
 
-    FileSpec src_file(File, false);
+    FileSpec src_file(File);
     size_t cu_count = Module.GetNumCompileUnits();
     for (size_t i = 0; i < cu_count; i++) {
       lldb::CompUnitSP cu_sp = Module.GetCompileUnitAtIndex(i);
       if (!cu_sp)
         continue;
 
       LineEntry le;
       cu_sp->FindLineEntry(0, Line, &src_file, false, &le);

 
 Error opts::symbols::findBlocks(lldb_private::Module &Module) {
   assert(!Regex);
   assert(!File.empty());
   assert(Line != 0);
 
   SymbolContextList List;
 
-  FileSpec src_file(File, false);
+  FileSpec src_file(File);
   size_t cu_count = Module.GetNumCompileUnits();
   for (size_t i = 0; i < cu_count; i++) {
     lldb::CompUnitSP cu_sp = Module.GetCompileUnitAtIndex(i);
     if (!cu_sp)
       continue;
 
     LineEntry le;
     cu_sp->FindLineEntry(0, Line, &src_file, false, &le);
if (!ActionOr) {
     logAllUnhandledErrors(ActionOr.takeError(), WithColor::error(), "");
     return 1;
   }
   auto Action = *ActionOr;
 
   int HadErrors = 0;
   for (const auto &File : InputFilenames) {
     outs() << "Module: " << File << "\n";
-    ModuleSpec Spec{FileSpec(File, false)};
-    Spec.GetSymbolFileSpec().SetFile(File, false, FileSpec::Style::native);
+    ModuleSpec Spec{FileSpec(File)};
+    Spec.GetSymbolFileSpec().SetFile(File, FileSpec::Style::native);
 
     auto ModulePtr = std::make_shared<lldb_private::Module>(Spec);
     SymbolVendor *Vendor = ModulePtr->GetSymbolVendor();
     if (!Vendor) {
       WithColor::error() << "Module has no symbol vendor.\n";
       HadErrors = 1;
       continue;
     }
 
     if (Error E = Action(*ModulePtr)) {
       WithColor::error() << toString(std::move(E)) << "\n";
       HadErrors = 1;
     }
 
     outs().flush();
   }
   return HadErrors;
 }
 
 static int dumpObjectFiles(Debugger &Dbg) {
   LinePrinter Printer(4, llvm::outs());
 
   int HadErrors = 0;
   for (const auto &File : opts::object::InputFilenames) {
-    ModuleSpec Spec{FileSpec(File, false)};
+    ModuleSpec Spec{FileSpec(File)};
 
     auto ModulePtr = std::make_shared<lldb_private::Module>(Spec);
     // Fetch symbol vendor before we get the section list to give the symbol
     // vendor a chance to populate it.
     ModulePtr->GetSymbolVendor();
     SectionList *Sections = ModulePtr->GetSectionList();
     if (!Sections) {
       llvm::errs() << "Could not load sections for module " << File << "\n";

unittests/Core/MangledTest.cpp

TEST(MangledTest, NameIndexes_FindFunctionSymbols) {
   const llvm::Optional<llvm::StringRef> redirects[] = {llvm::None, ObjRef,
                                                        llvm::None};
   ASSERT_EQ(0,
             llvm::sys::ExecuteAndWait(YAML2OBJ, Args, llvm::None, redirects));
   uint64_t Size;
   ASSERT_NO_ERROR(llvm::sys::fs::file_size(Obj, Size));
   ASSERT_GT(Size, 0u);
 
-  ModuleSpec Spec{FileSpec(Obj, false)};
-  Spec.GetSymbolFileSpec().SetFile(Obj, false, FileSpec::Style::native);
+  ModuleSpec Spec{FileSpec(Obj)};
+  Spec.GetSymbolFileSpec().SetFile(Obj, FileSpec::Style::native);
   auto M = std::make_shared<Module>(Spec);
 
   auto Count = [M](const char *Name, FunctionNameType Type) -> int {
     SymbolContextList SymList;
     return M->FindFunctionSymbols(ConstString(Name), Type, SymList);
   };
 
   // Unmangled

unittests/Expression/ClangParserTest.cpp

struct ClangHostTest : public testing::Test {
   static void TearDownTestCase() { HostInfo::Terminate(); }
 };
 } // namespace
 
 #ifdef __APPLE__
 static std::string ComputeClangDir(std::string lldb_shlib_path,
                                    bool verify = false) {
   FileSpec clang_dir;
-  FileSpec lldb_shlib_spec(lldb_shlib_path, false);
+  FileSpec lldb_shlib_spec(lldb_shlib_path);
   ComputeClangDirectory(lldb_shlib_spec, clang_dir, verify);
   return clang_dir.GetPath();
 }
 
 TEST_F(ClangHostTest, MacOSX) {
   // This returns whatever the POSIX fallback returns.
   std::string posix = "/usr/lib/liblldb.dylib";
   EXPECT_FALSE(ComputeClangDir(posix).empty());

unittests/Host/FileSystemTest.cpp

 public:
   void InitializeWithFileSystem(IntrusiveRefCntPtr<vfs::FileSystem> fs) {
     SetFileSystem(fs);
   }
 };
 
 TEST(FileSystemTest, FileAndDirectoryComponents) {
   using namespace std::chrono;
+  FileSystem fs;
 
-  const bool resolve = true;
 #ifdef _WIN32
-  FileSpec fs1("C:\\FILE\\THAT\\DOES\\NOT\\EXIST.TXT", !resolve);
+  FileSpec fs1("C:\\FILE\\THAT\\DOES\\NOT\\EXIST.TXT");
 #else
-  FileSpec fs1("/file/that/does/not/exist.txt", !resolve);
+  FileSpec fs1("/file/that/does/not/exist.txt");
 #endif
-  FileSpec fs2(TestMainArgv0, resolve);
+  FileSpec fs2(TestMainArgv0);
 
-  FileSystem fs;
+  fs.Resolve(fs2);
 
   EXPECT_EQ(system_clock::time_point(), fs.GetModificationTime(fs1));
   EXPECT_LT(system_clock::time_point() + hours(24 * 365 * 20),
             fs.GetModificationTime(fs2));
 }
 
 static IntrusiveRefCntPtr<DummyFileSystem> GetSimpleDummyFS() {
   IntrusiveRefCntPtr<DummyFileSystem> D(new DummyFileSystem());
   D->addRegularFile("/foo");
   D->addDirectory("/bar");
   D->addSymlink("/baz");
   D->addRegularFile("/qux", ~sys::fs::perms::all_read);
   D->setCurrentWorkingDirectory("/");
   return D;
 }
 
 TEST(FileSystemTest, Exists) {
   TestFileSystem fs;
   fs.InitializeWithFileSystem(GetSimpleDummyFS());
 
   EXPECT_TRUE(fs.Exists("/foo"));
-  EXPECT_TRUE(fs.Exists(FileSpec("/foo", false, FileSpec::Style::posix)));
+  EXPECT_TRUE(fs.Exists(FileSpec("/foo", FileSpec::Style::posix)));
 }
 
 TEST(FileSystemTest, Readable) {
   TestFileSystem fs;
   fs.InitializeWithFileSystem(GetSimpleDummyFS());
 
   EXPECT_TRUE(fs.Readable("/foo"));
-  EXPECT_TRUE(fs.Readable(FileSpec("/foo", false, FileSpec::Style::posix)));
+  EXPECT_TRUE(fs.Readable(FileSpec("/foo", FileSpec::Style::posix)));
 
   EXPECT_FALSE(fs.Readable("/qux"));
-  EXPECT_FALSE(fs.Readable(FileSpec("/qux", false, FileSpec::Style::posix)));
+  EXPECT_FALSE(fs.Readable(FileSpec("/qux", FileSpec::Style::posix)));
 }
 
 TEST(FileSystemTest, GetByteSize) {
   TestFileSystem fs;
   fs.InitializeWithFileSystem(GetSimpleDummyFS());
 
   EXPECT_EQ((uint64_t)1024, fs.GetByteSize("/foo"));
   EXPECT_EQ((uint64_t)1024,
-            fs.GetByteSize(FileSpec("/foo", false, FileSpec::Style::posix)));
+            fs.GetByteSize(FileSpec("/foo", FileSpec::Style::posix)));
 }
 
 TEST(FileSystemTest, GetPermissions) {
   TestFileSystem fs;
   fs.InitializeWithFileSystem(GetSimpleDummyFS());
 
   EXPECT_EQ(sys::fs::all_all, fs.GetPermissions("/foo"));
   EXPECT_EQ(sys::fs::all_all,
-            fs.GetPermissions(FileSpec("/foo", false, FileSpec::Style::posix)));
+            fs.GetPermissions(FileSpec("/foo", FileSpec::Style::posix)));
 }
 
 TEST(FileSystemTest, MakeAbsolute) {
   TestFileSystem fs;
   fs.InitializeWithFileSystem(GetSimpleDummyFS());
 
   {
     StringRef foo_relative = "foo";
     SmallString<16> foo(foo_relative);
     auto EC = fs.MakeAbsolute(foo);
     EXPECT_FALSE(EC);
     EXPECT_TRUE(foo.equals("/foo"));
   }
 
   {
-    FileSpec file_spec("foo", false);
+    FileSpec file_spec("foo");
     auto EC = fs.MakeAbsolute(file_spec);
     EXPECT_FALSE(EC);
     EXPECT_EQ("/foo", file_spec.GetPath());
   }
 }
 
 TEST(FileSystemTest, Resolve) {
   TestFileSystem fs;
   fs.InitializeWithFileSystem(GetSimpleDummyFS());
 
   {
     StringRef foo_relative = "foo";
     SmallString<16> foo(foo_relative);
     fs.Resolve(foo);
     EXPECT_TRUE(foo.equals("/foo"));
   }
 
   {
-    FileSpec file_spec("foo", false);
+    FileSpec file_spec("foo");
     fs.Resolve(file_spec);
     EXPECT_EQ("/foo", file_spec.GetPath());
   }
 
   {
     StringRef foo_relative = "bogus";
     SmallString<16> foo(foo_relative);
     fs.Resolve(foo);
     EXPECT_TRUE(foo.equals("bogus"));
   }
 
   {
-    FileSpec file_spec("bogus", false);
+    FileSpec file_spec("bogus");
     fs.Resolve(file_spec);
     EXPECT_EQ("bogus", file_spec.GetPath());
   }
 }
 
 FileSystem::EnumerateDirectoryResult
 VFSCallback(void *baton, llvm::sys::fs::file_type file_type,
             llvm::StringRef path) {

unittests/Host/SymbolsTest.cpp

TEST(SymbolsTest,
   EXPECT_TRUE(symbol_file_spec.GetFilename().IsEmpty());
 }
 
 TEST(SymbolsTest,
      LocateExecutableSymbolFileForUnknownExecutableAndMissingSymbolFile) {
   ModuleSpec module_spec;
   // using a GUID here because the symbol file shouldn't actually exist on disk
   module_spec.GetSymbolFileSpec().SetFile(
-      "4A524676-B24B-4F4E-968A-551D465EBAF1.so", false,
-      FileSpec::Style::native);
+      "4A524676-B24B-4F4E-968A-551D465EBAF1.so", FileSpec::Style::native);
   FileSpec symbol_file_spec = Symbols::LocateExecutableSymbolFile(module_spec);
   EXPECT_TRUE(symbol_file_spec.GetFilename().IsEmpty());
 }

unittests/ObjectFile/ELF/TestObjectFileELF.cpp

TEST_F(ObjectFileELFTest, SectionsResolveConsistently) {
   const llvm::Optional<llvm::StringRef> redirects[] = {llvm::None, obj_ref,
                                                        llvm::None};
   ASSERT_EQ(0,
             llvm::sys::ExecuteAndWait(YAML2OBJ, args, llvm::None, redirects));
   uint64_t size;
   ASSERT_NO_ERROR(llvm::sys::fs::file_size(obj, size));
   ASSERT_GT(size, 0u);
 
-  ModuleSpec spec{FileSpec(obj, false)};
-  spec.GetSymbolFileSpec().SetFile(obj, false, FileSpec::Style::native);
+  ModuleSpec spec{FileSpec(obj)};
+  spec.GetSymbolFileSpec().SetFile(obj, FileSpec::Style::native);
   auto module_sp = std::make_shared<Module>(spec);
   SectionList *list = module_sp->GetSectionList();
   ASSERT_NE(nullptr, list);
 
   auto bss_sp = list->FindSectionByName(ConstString(".bss"));
   ASSERT_NE(nullptr, bss_sp);
   auto data_sp = list->FindSectionByName(ConstString(".data"));
   ASSERT_NE(nullptr, data_sp);
- Name:            .text
     Address:         0x00000000004003D0
     AddressAlign:    0x0000000000000010
     Content:         DEADBEEFBAADF00D
 ...
 */
 TEST_F(ObjectFileELFTest, GetModuleSpecifications_EarlySectionHeaders) {
   std::string SO = GetInputFilePath("early-section-headers.so");
   ModuleSpecList Specs;
-  ASSERT_EQ(1u, ObjectFile::GetModuleSpecifications(FileSpec(SO, false), 0, 0, Specs));
+  ASSERT_EQ(1u, ObjectFile::GetModuleSpecifications(FileSpec(SO), 0, 0, Specs));
   ModuleSpec Spec;
   ASSERT_TRUE(Specs.GetModuleSpecAtIndex(0, Spec)) ;
   UUID Uuid;
   Uuid.SetFromStringRef("1b8a73ac238390e32a7ff4ac8ebe4d6a41ecf5c9", 20);
   EXPECT_EQ(Spec.GetUUID(), Uuid);
 }

unittests/Platform/PlatformDarwinTest.cpp

TEST(PlatformDarwinTest, TestParseVersionBuildDir) {
   EXPECT_EQ("", D);
 
   std::tie(V, D) = PlatformDarwin::ParseVersionBuildDir("3.4.5");
   EXPECT_EQ(llvm::VersionTuple(3, 4, 5), V);
 
   std::string base = "/Applications/Xcode.app/Contents/Developer/Platforms/";
   EXPECT_TRUE(PlatformDarwinTester::SDKSupportsModules(
       PlatformDarwin::SDKType::iPhoneSimulator,
-      FileSpec(base +
-          "iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator12.0.sdk",
-          false)));
+      FileSpec(
+          base +
+          "iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator12.0.sdk")));
   EXPECT_FALSE(PlatformDarwinTester::SDKSupportsModules(
       PlatformDarwin::SDKType::iPhoneSimulator,
-      FileSpec(base +
-          "iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator7.2.sdk",
-          false)));
+      FileSpec(
+          base +
+          "iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator7.2.sdk")));
   EXPECT_TRUE(PlatformDarwinTester::SDKSupportsModules(
       PlatformDarwin::SDKType::MacOSX,
-      FileSpec(base + "MacOSX.platform/Developer/SDKs/MacOSX10.10.sdk",
-               false)));
+      FileSpec(base + "MacOSX.platform/Developer/SDKs/MacOSX10.10.sdk")));
   EXPECT_FALSE(PlatformDarwinTester::SDKSupportsModules(
       PlatformDarwin::SDKType::MacOSX,
-      FileSpec(base + "MacOSX.platform/Developer/SDKs/MacOSX10.9.sdk", false)));
+      FileSpec(base + "MacOSX.platform/Developer/SDKs/MacOSX10.9.sdk")));
 }

unittests/Process/gdb-remote/GDBRemoteCommunicationClientTest.cpp

TEST_F(GDBRemoteCommunicationClientTest, SyncThreadState) {
   HandlePacket(server, "QSyncThreadState:0047;", "OK");
   ASSERT_TRUE(async_result.get());
 }
 
 TEST_F(GDBRemoteCommunicationClientTest, GetModulesInfo) {
   llvm::Triple triple("i386-pc-linux");
 
   FileSpec file_specs[] = {
-      FileSpec("/foo/bar.so", false, FileSpec::Style::posix),
-      FileSpec("/foo/baz.so", false, FileSpec::Style::posix),
+      FileSpec("/foo/bar.so", FileSpec::Style::posix),
+      FileSpec("/foo/baz.so", FileSpec::Style::posix),
 
       // This is a bit dodgy but we currently depend on GetModulesInfo not
       // performing denormalization. It can go away once the users
       // (DynamicLoaderPOSIXDYLD, at least) correctly set the path syntax for
       // the FileSpecs they create.
-      FileSpec("/foo/baw.so", false, FileSpec::Style::windows),
+      FileSpec("/foo/baw.so", FileSpec::Style::windows),
   };
   std::future<llvm::Optional<std::vector<ModuleSpec>>> async_result =
       std::async(std::launch::async,
                  [&] { return client.GetModulesInfo(file_specs, triple); });
   HandlePacket(
       server, "jModulesInfo:["
               R"({"file":"/foo/bar.so","triple":"i386-pc-linux"},)"
               R"({"file":"/foo/baz.so","triple":"i386-pc-linux"},)"
EXPECT_EQ(UUID::fromData("@ABCDEFGHIJKLMNO", 16),
             result.getValue()[0].GetUUID());
   EXPECT_EQ(0u, result.getValue()[0].GetObjectOffset());
   EXPECT_EQ(1234u, result.getValue()[0].GetObjectSize());
 }
 
 TEST_F(GDBRemoteCommunicationClientTest, GetModulesInfo_UUID20) {
   llvm::Triple triple("i386-pc-linux");
 
-  FileSpec file_spec("/foo/bar.so", false, FileSpec::Style::posix);
+  FileSpec file_spec("/foo/bar.so", FileSpec::Style::posix);
   std::future<llvm::Optional<std::vector<ModuleSpec>>> async_result =
       std::async(std::launch::async,
                  [&] { return client.GetModulesInfo(file_spec, triple); });
   HandlePacket(
       server,
       "jModulesInfo:["
       R"({"file":"/foo/bar.so","triple":"i386-pc-linux"}])",
       R"([{"uuid":"404142434445464748494a4b4c4d4e4f50515253","triple":"i386-pc-linux",)"
       R"("file_path":"/foo/bar.so","file_offset":0,"file_size":1234}]])");
 
   auto result = async_result.get();
   ASSERT_TRUE(result.hasValue());
   ASSERT_EQ(1u, result->size());
   EXPECT_EQ("/foo/bar.so", result.getValue()[0].GetFileSpec().GetPath());
   EXPECT_EQ(triple, result.getValue()[0].GetArchitecture().GetTriple());
   EXPECT_EQ(UUID::fromData("@ABCDEFGHIJKLMNOPQRS", 20),
             result.getValue()[0].GetUUID());
   EXPECT_EQ(0u, result.getValue()[0].GetObjectOffset());
   EXPECT_EQ(1234u, result.getValue()[0].GetObjectSize());
 }
 
 TEST_F(GDBRemoteCommunicationClientTest, GetModulesInfoInvalidResponse) {
   llvm::Triple triple("i386-pc-linux");
-  FileSpec file_spec("/foo/bar.so", false, FileSpec::Style::posix);
+  FileSpec file_spec("/foo/bar.so", FileSpec::Style::posix);
 
   const char *invalid_responses[] = {
       // no UUID
       R"([{"triple":"i386-pc-linux",)"
       R"("file_path":"/foo/bar.so","file_offset":0,"file_size":1234}]])",
       // invalid UUID
       R"([{"uuid":"XXXXXX","triple":"i386-pc-linux",)"
       R"("file_path":"/foo/bar.so","file_offset":0,"file_size":1234}]])",

unittests/Symbol/TestDWARFCallFrameInfo.cpp

const llvm::Optional<llvm::StringRef> redirects[] = {llvm::None, obj_ref,
                                                        llvm::None};
   ASSERT_EQ(0,
             llvm::sys::ExecuteAndWait(YAML2OBJ, args, llvm::None, redirects));
 
   uint64_t size;
   ASSERT_NO_ERROR(llvm::sys::fs::file_size(obj, size));
   ASSERT_GT(size, 0u);
 
-  auto module_sp = std::make_shared<Module>(ModuleSpec(FileSpec(obj, false)));
+  auto module_sp = std::make_shared<Module>(ModuleSpec(FileSpec(obj)));
   SectionList *list = module_sp->GetSectionList();
   ASSERT_NE(nullptr, list);
 
   auto section_sp = list->FindSectionByType(type == DWARFCallFrameInfo::EH
                                                 ? eSectionTypeEHFrame
                                                 : eSectionTypeDWARFDebugFrame,
                                             false);
   ASSERT_NE(nullptr, section_sp);

unittests/SymbolFile/DWARF/SymbolFileDWARFTests.cpp

// leak into the next test.
   }
 
 protected:
   std::string m_dwarf_test_exe;
 };
 
 TEST_F(SymbolFileDWARFTests, TestAbilitiesForDWARF) {
   // Test that when we have Dwarf debug info, SymbolFileDWARF is used.
-  FileSpec fspec(m_dwarf_test_exe, false);
+  FileSpec fspec(m_dwarf_test_exe);
   ArchSpec aspec("i686-pc-windows");
   lldb::ModuleSP module = std::make_shared<Module>(fspec, aspec);
 
   SymbolVendor *plugin = module->GetSymbolVendor();
   EXPECT_NE(nullptr, plugin);
   SymbolFile *symfile = plugin->GetSymbolFile();
   EXPECT_NE(nullptr, symfile);
   EXPECT_EQ(symfile->GetPluginName(), SymbolFileDWARF::GetPluginNameStatic());
 
   uint32_t expected_abilities = SymbolFile::kAllAbilities;
   EXPECT_EQ(expected_abilities, symfile->CalculateAbilities());
 }

unittests/Target/ModuleCacheTest.cpp

 static const char dummy_remote_dir[] = "bin";
 static const char module_name[] = "TestModule.so";
 static const char module_uuid[] =
     "F4E7E991-9B61-6AD4-0073-561AC3D9FA10-C043A476";
 static const uint32_t uuid_bytes = 20;
 static const size_t module_size = 5602;
 
 static FileSpec GetDummyRemotePath() {
-  FileSpec fs("/", false, FileSpec::Style::posix);
+  FileSpec fs("/", FileSpec::Style::posix);
   fs.AppendPathComponent(dummy_remote_dir);
   fs.AppendPathComponent(module_name);
   return fs;
 }
 
 static FileSpec GetUuidView(FileSpec spec) {
   spec.AppendPathComponent(".cache");
   spec.AppendPathComponent(module_uuid);

unittests/Target/PathMappingListTest.cpp

 #include <utility>
 
 using namespace lldb_private;
 
 namespace {
 struct Matches {
   FileSpec original;
   FileSpec remapped;
-  Matches(const char *o, const char *r)
-      : original(o, false), remapped(r, false) {}
+  Matches(const char *o, const char *r) : original(o), remapped(r) {}
 };
 } // namespace
 
 static void TestPathMappings(const PathMappingList &map,
                              llvm::ArrayRef<Matches> matches,
                              llvm::ArrayRef<ConstString> fails) {
   ConstString actual_remapped;
   for (const auto &fail : fails) {
     SCOPED_TRACE(fail.GetCString());
     EXPECT_FALSE(map.RemapPath(fail, actual_remapped))
         << "actual_remapped: " << actual_remapped.GetCString();
   }
   for (const auto &match : matches) {
     SCOPED_TRACE(match.original.GetPath() + " -> " + match.remapped.GetPath());
     std::string orig_normalized = match.original.GetPath();
     EXPECT_TRUE(
         map.RemapPath(ConstString(match.original.GetPath()), actual_remapped));
-    EXPECT_EQ(FileSpec(actual_remapped.GetStringRef(), false), match.remapped);
+    EXPECT_EQ(FileSpec(actual_remapped.GetStringRef()), match.remapped);
     FileSpec unmapped_spec;
     EXPECT_TRUE(map.ReverseRemapPath(match.remapped, unmapped_spec));
     std::string unmapped_path = unmapped_spec.GetPath();
     EXPECT_EQ(unmapped_path, orig_normalized);
   }
 }
 
 TEST(PathMappingListTest, RelativeTests) {

unittests/Utility/FileSpecTest.cpp

 //===-- FileSpecTest.cpp ----------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "gtest/gtest.h"
 
 #include "lldb/Utility/FileSpec.h"
 
 using namespace lldb_private;
 
 TEST(FileSpecTest, FileAndDirectoryComponents) {
-  FileSpec fs_posix("/foo/bar", false, FileSpec::Style::posix);
+  FileSpec fs_posix("/foo/bar", FileSpec::Style::posix);
   EXPECT_STREQ("/foo/bar", fs_posix.GetCString());
   EXPECT_STREQ("/foo", fs_posix.GetDirectory().GetCString());
   EXPECT_STREQ("bar", fs_posix.GetFilename().GetCString());
 
-  FileSpec fs_windows("F:\\bar", false, FileSpec::Style::windows);
+  FileSpec fs_windows("F:\\bar", FileSpec::Style::windows);
   EXPECT_STREQ("F:\\bar", fs_windows.GetCString());
   // EXPECT_STREQ("F:\\", fs_windows.GetDirectory().GetCString()); // It returns
   // "F:/"
   EXPECT_STREQ("bar", fs_windows.GetFilename().GetCString());
 
-  FileSpec fs_posix_root("/", false, FileSpec::Style::posix);
+  FileSpec fs_posix_root("/", FileSpec::Style::posix);
   EXPECT_STREQ("/", fs_posix_root.GetCString());
   EXPECT_EQ(nullptr, fs_posix_root.GetDirectory().GetCString());
   EXPECT_STREQ("/", fs_posix_root.GetFilename().GetCString());
 
-  FileSpec fs_net_drive("//net", false, FileSpec::Style::posix);
+  FileSpec fs_net_drive("//net", FileSpec::Style::posix);
   EXPECT_STREQ("//net", fs_net_drive.GetCString());
   EXPECT_EQ(nullptr, fs_net_drive.GetDirectory().GetCString());
   EXPECT_STREQ("//net", fs_net_drive.GetFilename().GetCString());
 
-  FileSpec fs_net_root("//net/", false, FileSpec::Style::posix);
+  FileSpec fs_net_root("//net/", FileSpec::Style::posix);
   EXPECT_STREQ("//net/", fs_net_root.GetCString());
   EXPECT_STREQ("//net", fs_net_root.GetDirectory().GetCString());
   EXPECT_STREQ("/", fs_net_root.GetFilename().GetCString());
 
-  FileSpec fs_windows_drive("F:", false, FileSpec::Style::windows);
+  FileSpec fs_windows_drive("F:", FileSpec::Style::windows);
   EXPECT_STREQ("F:", fs_windows_drive.GetCString());
   EXPECT_EQ(nullptr, fs_windows_drive.GetDirectory().GetCString());
   EXPECT_STREQ("F:", fs_windows_drive.GetFilename().GetCString());
 
-  FileSpec fs_windows_root("F:\\", false, FileSpec::Style::windows);
+  FileSpec fs_windows_root("F:\\", FileSpec::Style::windows);
   EXPECT_STREQ("F:\\", fs_windows_root.GetCString());
   EXPECT_STREQ("F:", fs_windows_root.GetDirectory().GetCString());
   // EXPECT_STREQ("\\", fs_windows_root.GetFilename().GetCString()); // It
   // returns "/"
 
-  FileSpec fs_posix_long("/foo/bar/baz", false, FileSpec::Style::posix);
+  FileSpec fs_posix_long("/foo/bar/baz", FileSpec::Style::posix);
   EXPECT_STREQ("/foo/bar/baz", fs_posix_long.GetCString());
   EXPECT_STREQ("/foo/bar", fs_posix_long.GetDirectory().GetCString());
   EXPECT_STREQ("baz", fs_posix_long.GetFilename().GetCString());
 
-  FileSpec fs_windows_long("F:\\bar\\baz", false, FileSpec::Style::windows);
+  FileSpec fs_windows_long("F:\\bar\\baz", FileSpec::Style::windows);
   EXPECT_STREQ("F:\\bar\\baz", fs_windows_long.GetCString());
   // EXPECT_STREQ("F:\\bar", fs_windows_long.GetDirectory().GetCString()); // It
   // returns "F:/bar"
   EXPECT_STREQ("baz", fs_windows_long.GetFilename().GetCString());
 
-  FileSpec fs_posix_trailing_slash("/foo/bar/", false, FileSpec::Style::posix);
+  FileSpec fs_posix_trailing_slash("/foo/bar/", FileSpec::Style::posix);
   EXPECT_STREQ("/foo/bar", fs_posix_trailing_slash.GetCString());
   EXPECT_STREQ("/foo", fs_posix_trailing_slash.GetDirectory().GetCString());
   EXPECT_STREQ("bar", fs_posix_trailing_slash.GetFilename().GetCString());
 
-  FileSpec fs_windows_trailing_slash("F:\\bar\\", false,
-                                     FileSpec::Style::windows);
+  FileSpec fs_windows_trailing_slash("F:\\bar\\", FileSpec::Style::windows);
   EXPECT_STREQ("F:\\bar", fs_windows_trailing_slash.GetCString());
   EXPECT_STREQ("bar", fs_windows_trailing_slash.GetFilename().GetCString());
 }
 
 TEST(FileSpecTest, AppendPathComponent) {
-  FileSpec fs_posix("/foo", false, FileSpec::Style::posix);
+  FileSpec fs_posix("/foo", FileSpec::Style::posix);
   fs_posix.AppendPathComponent("bar");
   EXPECT_STREQ("/foo/bar", fs_posix.GetCString());
   EXPECT_STREQ("/foo", fs_posix.GetDirectory().GetCString());
   EXPECT_STREQ("bar", fs_posix.GetFilename().GetCString());
 
-  FileSpec fs_posix_2("/foo", false, FileSpec::Style::posix);
+  FileSpec fs_posix_2("/foo", FileSpec::Style::posix);
   fs_posix_2.AppendPathComponent("//bar/baz");
   EXPECT_STREQ("/foo/bar/baz", fs_posix_2.GetCString());
   EXPECT_STREQ("/foo/bar", fs_posix_2.GetDirectory().GetCString());
   EXPECT_STREQ("baz", fs_posix_2.GetFilename().GetCString());
 
-  FileSpec fs_windows("F:\\bar", false, FileSpec::Style::windows);
+  FileSpec fs_windows("F:\\bar", FileSpec::Style::windows);
   fs_windows.AppendPathComponent("baz");
   EXPECT_STREQ("F:\\bar\\baz", fs_windows.GetCString());
   // EXPECT_STREQ("F:\\bar", fs_windows.GetDirectory().GetCString()); // It
   // returns "F:/bar"
   EXPECT_STREQ("baz", fs_windows.GetFilename().GetCString());
 
-  FileSpec fs_posix_root("/", false, FileSpec::Style::posix);
+  FileSpec fs_posix_root("/", FileSpec::Style::posix);
   fs_posix_root.AppendPathComponent("bar");
   EXPECT_STREQ("/bar", fs_posix_root.GetCString());
   EXPECT_STREQ("/", fs_posix_root.GetDirectory().GetCString());
   EXPECT_STREQ("bar", fs_posix_root.GetFilename().GetCString());
 
-  FileSpec fs_windows_root("F:\\", false, FileSpec::Style::windows);
+  FileSpec fs_windows_root("F:\\", FileSpec::Style::windows);
   fs_windows_root.AppendPathComponent("bar");
   EXPECT_STREQ("F:\\bar", fs_windows_root.GetCString());
   // EXPECT_STREQ("F:\\", fs_windows_root.GetDirectory().GetCString()); // It
   // returns "F:/"
   EXPECT_STREQ("bar", fs_windows_root.GetFilename().GetCString());
 }
 
 TEST(FileSpecTest, CopyByAppendingPathComponent) {
-  FileSpec fs = FileSpec("/foo", false, FileSpec::Style::posix)
+  FileSpec fs = FileSpec("/foo", FileSpec::Style::posix)
                     .CopyByAppendingPathComponent("bar");
   EXPECT_STREQ("/foo/bar", fs.GetCString());
   EXPECT_STREQ("/foo", fs.GetDirectory().GetCString());
   EXPECT_STREQ("bar", fs.GetFilename().GetCString());
 }
 
 TEST(FileSpecTest, PrependPathComponent) {
-  FileSpec fs_posix("foo", false, FileSpec::Style::posix);
+  FileSpec fs_posix("foo", FileSpec::Style::posix);
   fs_posix.PrependPathComponent("/bar");
   EXPECT_STREQ("/bar/foo", fs_posix.GetCString());
 
-  FileSpec fs_posix_2("foo/bar", false, FileSpec::Style::posix);
+  FileSpec fs_posix_2("foo/bar", FileSpec::Style::posix);
   fs_posix_2.PrependPathComponent("/baz");
   EXPECT_STREQ("/baz/foo/bar", fs_posix_2.GetCString());
 
-  FileSpec fs_windows("baz", false, FileSpec::Style::windows);
+  FileSpec fs_windows("baz", FileSpec::Style::windows);
   fs_windows.PrependPathComponent("F:\\bar");
   EXPECT_STREQ("F:\\bar\\baz", fs_windows.GetCString());
 
-  FileSpec fs_posix_root("bar", false, FileSpec::Style::posix);
+  FileSpec fs_posix_root("bar", FileSpec::Style::posix);
   fs_posix_root.PrependPathComponent("/");
   EXPECT_STREQ("/bar", fs_posix_root.GetCString());
 
-  FileSpec fs_windows_root("bar", false, FileSpec::Style::windows);
+  FileSpec fs_windows_root("bar", FileSpec::Style::windows);
   fs_windows_root.PrependPathComponent("F:\\");
   EXPECT_STREQ("F:\\bar", fs_windows_root.GetCString());
 }
 
 TEST(FileSpecTest, EqualSeparator) {
-  FileSpec backward("C:\\foo\\bar", false, FileSpec::Style::windows);
-  FileSpec forward("C:/foo/bar", false, FileSpec::Style::windows);
+  FileSpec backward("C:\\foo\\bar", FileSpec::Style::windows);
+  FileSpec forward("C:/foo/bar", FileSpec::Style::windows);
   EXPECT_EQ(forward, backward);
 }
 
 TEST(FileSpecTest, EqualDotsWindows) {
   std::pair<const char *, const char *> tests[] = {
       {R"(C:\foo\bar\baz)", R"(C:\foo\foo\..\bar\baz)"},
       {R"(C:\bar\baz)", R"(C:\foo\..\bar\baz)"},
       {R"(C:\bar\baz)", R"(C:/foo/../bar/baz)"},
       {R"(C:/bar/baz)", R"(C:\foo\..\bar\baz)"},
       {R"(C:\bar)", R"(C:\foo\..\bar)"},
       {R"(C:\foo\bar)", R"(C:\foo\.\bar)"},
       {R"(C:\foo\bar)", R"(C:\foo\bar\.)"},
   };
 
   for (const auto &test : tests) {
-    FileSpec one(test.first, false, FileSpec::Style::windows);
-    FileSpec two(test.second, false, FileSpec::Style::windows);
+    FileSpec one(test.first, FileSpec::Style::windows);
+    FileSpec two(test.second, FileSpec::Style::windows);
     EXPECT_EQ(one, two);
   }
 }
 
 TEST(FileSpecTest, EqualDotsPosix) {
   std::pair<const char *, const char *> tests[] = {
       {R"(/foo/bar/baz)", R"(/foo/foo/../bar/baz)"},
       {R"(/bar/baz)", R"(/foo/../bar/baz)"},
       {R"(/bar)", R"(/foo/../bar)"},
       {R"(/foo/bar)", R"(/foo/./bar)"},
       {R"(/foo/bar)", R"(/foo/bar/.)"},
   };
 
   for (const auto &test : tests) {
-    FileSpec one(test.first, false, FileSpec::Style::posix);
-    FileSpec two(test.second, false, FileSpec::Style::posix);
+    FileSpec one(test.first, FileSpec::Style::posix);
+    FileSpec two(test.second, FileSpec::Style::posix);
     EXPECT_EQ(one, two);
   }
 }
 
 TEST(FileSpecTest, EqualDotsPosixRoot) {
   std::pair<const char *, const char *> tests[] = {
       {R"(/)", R"(/..)"},
       {R"(/)", R"(/.)"},
       {R"(/)", R"(/foo/..)"},
   };
 
   for (const auto &test : tests) {
-    FileSpec one(test.first, false, FileSpec::Style::posix);
-    FileSpec two(test.second, false, FileSpec::Style::posix);
+    FileSpec one(test.first, FileSpec::Style::posix);
+    FileSpec two(test.second, FileSpec::Style::posix);
     EXPECT_EQ(one, two);
   }
 }
 
 TEST(FileSpecTest, GetNormalizedPath) {
   std::pair<const char *, const char *> posix_tests[] = {
       {"/foo/.././bar", "/bar"},
       {"/foo/./../bar", "/bar"},
std::pair<const char *, const char *> posix_tests[] = {
       {"./foo", "foo"},
       {"././foo", "foo"},
       {"../foo", "../foo"},
       {"../../foo", "../../foo"},
   };
   for (auto test : posix_tests) {
     SCOPED_TRACE(llvm::Twine("test.first = ") + test.first);
     EXPECT_EQ(test.second,
-              FileSpec(test.first, false, FileSpec::Style::posix).GetPath());
+              FileSpec(test.first, FileSpec::Style::posix).GetPath());
   }
 
   std::pair<const char *, const char *> windows_tests[] = {
       {R"(c:\bar\..\bar)", R"(c:\bar)"},
       {R"(c:\bar\.\bar)", R"(c:\bar\bar)"},
       {R"(c:\bar\..)", R"(c:\)"},
       {R"(c:\bar\.)", R"(c:\bar)"},
       {R"(c:\.\bar)", R"(c:\bar)"},
std::pair<const char *, const char *> windows_tests[] = {
       {R"(..\foo\..)", R"(..)"},
       {R"(.\foo)", R"(foo)"},
       {R"(.\.\foo)", R"(foo)"},
       {R"(..\foo)", R"(..\foo)"},
       {R"(..\..\foo)", R"(..\..\foo)"},
   };
   for (auto test : windows_tests) {
     EXPECT_EQ(test.second,
-              FileSpec(test.first, false, FileSpec::Style::windows).GetPath())
+              FileSpec(test.first, FileSpec::Style::windows).GetPath())
         << "Original path: " << test.first;
   }
 }
 
 TEST(FileSpecTest, FormatFileSpec) {
   auto win = FileSpec::Style::windows;
 
   FileSpec F;
   EXPECT_EQ("(empty)", llvm::formatv("{0}", F).str());
   EXPECT_EQ("(empty)", llvm::formatv("{0:D}", F).str());
   EXPECT_EQ("(empty)", llvm::formatv("{0:F}", F).str());
 
-  F = FileSpec("C:\\foo\\bar.txt", false, win);
+  F = FileSpec("C:\\foo\\bar.txt", win);
   EXPECT_EQ("C:\\foo\\bar.txt", llvm::formatv("{0}", F).str());
   EXPECT_EQ("C:\\foo\\", llvm::formatv("{0:D}", F).str());
   EXPECT_EQ("bar.txt", llvm::formatv("{0:F}", F).str());
 
-  F = FileSpec("foo\\bar.txt", false, win);
+  F = FileSpec("foo\\bar.txt", win);
   EXPECT_EQ("foo\\bar.txt", llvm::formatv("{0}", F).str());
   EXPECT_EQ("foo\\", llvm::formatv("{0:D}", F).str());
   EXPECT_EQ("bar.txt", llvm::formatv("{0:F}", F).str());
 
-  F = FileSpec("foo", false, win);
+  F = FileSpec("foo", win);
   EXPECT_EQ("foo", llvm::formatv("{0}", F).str());
   EXPECT_EQ("foo", llvm::formatv("{0:F}", F).str());
   EXPECT_EQ("(empty)", llvm::formatv("{0:D}", F).str());
 }
 
 TEST(FileSpecTest, IsRelative) {
   llvm::StringRef not_relative[] = {
     "/",
llvm::StringRef not_relative[] = {
     "~/a/b"
     "~/a/b/",
     "/foo/.",
     "/foo/..",
     "/foo/../",
     "/foo/../.",
   };
   for (const auto &path: not_relative) {
-    FileSpec spec(path, false, FileSpec::Style::posix);
+    FileSpec spec(path, FileSpec::Style::posix);
     EXPECT_FALSE(spec.IsRelative());
   }
   llvm::StringRef is_relative[] = {
     ".",
     "./",
     ".///",
     "a",
     "./a",
     "./a/",
     "./a/",
     "./a/b",
     "./a/b/",
     "../foo",
     "foo/bar.c",
     "./foo/bar.c"
   };
   for (const auto &path: is_relative) {
-    FileSpec spec(path, false, FileSpec::Style::posix);
+    FileSpec spec(path, FileSpec::Style::posix);
     EXPECT_TRUE(spec.IsRelative());
   }
 }
 
 TEST(FileSpecTest, RemoveLastPathComponent) {
-  FileSpec fs_posix("/foo/bar/baz", false, FileSpec::Style::posix);
+  FileSpec fs_posix("/foo/bar/baz", FileSpec::Style::posix);
   EXPECT_STREQ("/foo/bar/baz", fs_posix.GetCString());
   EXPECT_TRUE(fs_posix.RemoveLastPathComponent());
   EXPECT_STREQ("/foo/bar", fs_posix.GetCString());
   EXPECT_TRUE(fs_posix.RemoveLastPathComponent());
   EXPECT_STREQ("/foo", fs_posix.GetCString());
   EXPECT_TRUE(fs_posix.RemoveLastPathComponent());
   EXPECT_STREQ("/", fs_posix.GetCString());
   EXPECT_FALSE(fs_posix.RemoveLastPathComponent());
   EXPECT_STREQ("/", fs_posix.GetCString());
 
-  FileSpec fs_posix_relative("./foo/bar/baz", false, FileSpec::Style::posix);
+  FileSpec fs_posix_relative("./foo/bar/baz", FileSpec::Style::posix);
   EXPECT_STREQ("foo/bar/baz", fs_posix_relative.GetCString());
   EXPECT_TRUE(fs_posix_relative.RemoveLastPathComponent());
   EXPECT_STREQ("foo/bar", fs_posix_relative.GetCString());
   EXPECT_TRUE(fs_posix_relative.RemoveLastPathComponent());
   EXPECT_STREQ("foo", fs_posix_relative.GetCString());
   EXPECT_FALSE(fs_posix_relative.RemoveLastPathComponent());
   EXPECT_STREQ("foo", fs_posix_relative.GetCString());
 
-  FileSpec fs_posix_relative2("./", false, FileSpec::Style::posix);
+  FileSpec fs_posix_relative2("./", FileSpec::Style::posix);
   EXPECT_STREQ(".", fs_posix_relative2.GetCString());
   EXPECT_FALSE(fs_posix_relative2.RemoveLastPathComponent());
   EXPECT_STREQ(".", fs_posix_relative2.GetCString());
   EXPECT_FALSE(fs_posix_relative.RemoveLastPathComponent());
   EXPECT_STREQ(".", fs_posix_relative2.GetCString());
 
-  FileSpec fs_windows("C:\\foo\\bar\\baz", false, FileSpec::Style::windows);
+  FileSpec fs_windows("C:\\foo\\bar\\baz", FileSpec::Style::windows);
   EXPECT_STREQ("C:\\foo\\bar\\baz", fs_windows.GetCString());
   EXPECT_TRUE(fs_windows.RemoveLastPathComponent());
   EXPECT_STREQ("C:\\foo\\bar", fs_windows.GetCString());
   EXPECT_TRUE(fs_windows.RemoveLastPathComponent());
   EXPECT_STREQ("C:\\foo", fs_windows.GetCString());
   EXPECT_TRUE(fs_windows.RemoveLastPathComponent());
   EXPECT_STREQ("C:\\", fs_windows.GetCString());
   EXPECT_TRUE(fs_windows.RemoveLastPathComponent());
   EXPECT_STREQ("C:", fs_windows.GetCString());
   EXPECT_FALSE(fs_windows.RemoveLastPathComponent());
   EXPECT_STREQ("C:", fs_windows.GetCString());
 }

unittests/Utility/StructuredDataTest.cpp

for (auto P : TestCases) {
     StructuredData::String(P.first).Dump(S, pretty_print);
     EXPECT_EQ(P.second, S.GetString());
   }
 }
 
 TEST(StructuredDataTest, ParseJSONFromFile) {
   Status status;
   auto object_sp = StructuredData::ParseJSONFromFile(
-      FileSpec("non-existing-file.json", false), status);
+      FileSpec("non-existing-file.json"), status);
   EXPECT_EQ(nullptr, object_sp);
 
   std::string input = GetInputFilePath("StructuredData-basic.json");
-  object_sp = StructuredData::ParseJSONFromFile(FileSpec(input, false), status);
+  object_sp = StructuredData::ParseJSONFromFile(FileSpec(input), status);
   ASSERT_NE(nullptr, object_sp);
 
   StreamString S;
   object_sp->Dump(S, false);
   EXPECT_EQ("[1,2,3]", S.GetString());
 }