[FileSystem] Extend file system and have it use the VFS.

[JDevlieghere]

Summary

This patch extends the FileSystem class with a bunch of operations that are currently implemented as methods of the FileSpec class.

The implementation uses the virtual file system which means that the class is now stateful. I've turned it into a singleton because:

• We need it for the shared module cache which lives above the debugger.
• Passing it around would be inconvenient as we'll need it wherever we want to manipulate a file. I also don't think passing the FS as a parameter convey any useful information from an API standpoint.

This is the first patch in a series that will remove methods manipulating the filesystem from FileSpec. As I make more changes I might have to updated it or extend it with new methods.

[labath]

Back when the FileSystem class was introduced, the idea was that *it* would eventually become the gateway to the real filesystem, and FileSpec would just deal with abstract path manipulation.

I still think that is a good idea, particularly in light of this patch. So I would propose to integrate this VFS functionality into that class, and then remove any operations that touch real files from the file spec class.

(Also, given that now about 50% of filesystem operations go through FileSpec and the other half through FileSystem (or other methods), any attempts to use FileSpec to control how filenames are interpreted will not be complete).

[JDevlieghere]

Note that there's also a File class which we'll need to patch up separately together with all other uses that actually open or read a file. For this class we can do the same as we did for FileSpec: deferring relevant operations to the FileSystem class.

[zturner]

It seems like FileSpec was moved out of Utility and into Host. I’m not a
fan of this change, because it took a lot of effort to get it into Utility,
which helped break a lot of bad dependencies. Can we invert this dependency
and move FileSpec back into Utility?

[labath]

I also think it we should try to keep FileSpec in the Utility module. We should be able to do that by deleting the "utility" functions in the FileSpec class, and updating everything to go through the FileSystem class.

After the VFS introduction, something like file_spec.Exists() will not even be well-defined anyway, as one will have to specify which file system are we checking the existence in. So, it would be more correct to say file_spec.Exists(my_vfs), at which point it's not too much of a stretch to change this into my_vfs.Exists(file_spec).

(This is the same argument I was giving earlier, since even before VFS we kinda were dealing with multiple file systems (host, remote device). In fact, after this it might be a nice cleanup to change the Platform class from vending a bunch of FS-like methods to (FileExists, Unlink, CreateSymlink, ...), to have a single getRemoteFS method returning a VFS which does the right thing "under the hood").

tl;dr: I'd propose to (in two or more patches):

• replace FileSpec "utility" methods with equivalent FileSystem functionality
• do the necessary FileSystem changes to support VFS

source/Host/common/FileSystem.cpp

24–29

replace with static FileSystem *g_fs = new FileSystem();

33–35

I'm not sure what's your use case here, but would it make more sense instead of modifying the singleton object to have more that one FileSystem instance floating around? It could be local to each Debugger (?) object and everyone would fetch it from there when needed.

[JDevlieghere]

While I don't disagree with the proposed approach, it needs to be highlighted that extracting all file system operations would be very intrusive.

• Almost all logic in FileSpec deals with the filesystem. You can't even resolve a path without it. How do you imagine this would work?
• This will significantly increase the verbosity of working with FileSpec. Depending on the solution to the previous bullet point, you might have to do something like FileSpec spec(path);FS.Resolve(spec);FS.Exists(spec).

Additionally, if we make the FileSystem a member of the debugger, we'd have to pass it everywhere we pass a FileSpec. I'm not convinced that's something we want. We could put the FileSpec and the FileSystem in a wrapper object but then we're essentially where we are today. Furthermore, for the reproducers, we need the FileSystem to live above the debugger because of the shared module cache. I can't really imagine a scenario where we'd need two debuggers with a different VFS.

[zturner]

I envision FileSpec as being more of a PathSpec. It should be able manipulate paths as strings and nothing more. There is indeed some logic that still remains that resolves paths, but it manages to do this using LLVM's file system APIs and the only reason it's still there is because it was baked in and a bit hard to remove.

One idea for removing it would be to have FileSpec FileSystem::Resolve(const FileSpec &). Then instead of saying FileSpec foo(path, /*resolve = */ true);, they could say FileSpec foo = FileSystem::Resolve(FileSpec(path)); or something.

[JDevlieghere]

Thanks for the feedback! I totally agree it's a good solution and it was one of the things I considered. It didn't make it to the top of the list because it is very intrusive and changes the semantics of FileSpec quite a bit (i.e. it becomes a PathSpec as Zachary noted). Anyway, I'm happy to do this and I'll split this up in two patches as Pavel suggested. I'll extend the FileSystem first, so that we can do the VFS stuff straight away instead of implementing these methods twice.

[zturner]

In D53532#1276463, @JDevlieghere wrote:

Thanks for the feedback! I totally agree it's a good solution and it was one of the things I considered. It didn't make it to the top of the list because it is very intrusive and changes the semantics of FileSpec quite a bit (i.e. it becomes a PathSpec as Zachary noted). Anyway, I'm happy to do this and I'll split this up in two patches as Pavel suggested. I'll extend the FileSystem first, so that we can do the VFS stuff straight away instead of implementing these methods twice.

It does change them, but that's always been the sort of "end goal" of FileSpec anyway, it just hasn't been reached yet. Hopefully we can get there with your help :)

[JDevlieghere]

I'll recycle this differential for the first patch that changes the FileSystem class.

[labath]

Now that I know your use case (I forgot that you're working on the replay now, and the mention of VFS threw me off in a completely different direction), I agree that having a single global filesystem is fine. As for the increased verbosity, I wonder if we should make the fs accessor a free function instead of a member (so that you write something like hostFS().Symlink(..) instead of FileSystem::instance().Symlink(...).

(Theoretically, we might even make the VFS instance a global variable, and then we could keep the current pattern of accessing stuff via static methods, but I like the fact that this VFS thingy could then be reused for working with files on remote devices. Also, you may need a working FS instance in the guts of the replay code, to e.g., read the replay data.)

include/lldb/Host/FileSystem.h

42

I am wondering if we could make this work without exposing the ability to change the FS implementation mid-flight to everyone. How are you planning to initialize the record/replay? Would it be possible to pass in the VFS instance via some kind of an Initialize function (and have it be immutable from that point on)?

include/lldb/Utility/FileSpec.h

423

accidental change?

[JDevlieghere]

Address Pavel's feedback:

• Change to Initialize method which can only be called once.
• Fix accidental change in comment.

[labath]

In D53532#1279022, @JDevlieghere wrote:

Address Pavel's feedback:

• Change to Initialize method which can only be called once.

I suppose this is slightly better, but what I meant was to have a static (like all other functions with the same name) Initialize function, which has to be called before the first call to Instance(). During normal startup, this could be called from SystemInitializer, but I am not sure how would that work for record/replay (that's why I was asking how you planned to initialize those). It would require to setup the record/replay machinery very early on, which may be tricky. But on the other hand, you probably want to initialize these as early as possible anyway.

Do you think something like that would be possible?

[JDevlieghere]

In D53532#1280018, @labath wrote:

In D53532#1279022, @JDevlieghere wrote:

Address Pavel's feedback:

• Change to Initialize method which can only be called once.

I suppose this is slightly better, but what I meant was to have a static (like all other functions with the same name) Initialize function, which has to be called before the first call to Instance(). During normal startup, this could be called from SystemInitializer, but I am not sure how would that work for record/replay (that's why I was asking how you planned to initialize those). It would require to setup the record/replay machinery very early on, which may be tricky. But on the other hand, you probably want to initialize these as early as possible anyway.

Do you think something like that would be possible?

Alright, I see what you mean. You know more about the architecture, but it looks like we initialize the system before even reading the command line arguments in the driver. I have to read the reproducer before I can set the appropriate file system, so I'm not sure if this is possible.

[labath]

In D53532#1280734, @JDevlieghere wrote:

In D53532#1280018, @labath wrote:

In D53532#1279022, @JDevlieghere wrote:

Address Pavel's feedback:

• Change to Initialize method which can only be called once.

I suppose this is slightly better, but what I meant was to have a static (like all other functions with the same name) Initialize function, which has to be called before the first call to Instance(). During normal startup, this could be called from SystemInitializer, but I am not sure how would that work for record/replay (that's why I was asking how you planned to initialize those). It would require to setup the record/replay machinery very early on, which may be tricky. But on the other hand, you probably want to initialize these as early as possible anyway.

Do you think something like that would be possible?

Alright, I see what you mean. You know more about the architecture, but it looks like we initialize the system before even reading the command line arguments in the driver. I have to read the reproducer before I can set the appropriate file system, so I'm not sure if this is possible.

Yes, right now it certainly seems to be the case that we parse cmdline late in the game. However, it's not clear to me whether that has to be the case.

I can't say I have thought this through to the end, but it seems to me that setting up the repro engine should be one of the first (if not THE first) SB calls from the driver. Right now the parsing happens too late (e.g. we already have an SBDebugger instance created at that point). I am not sure you could safely initialize record/replay at that point, even if you got FileSystem switching working.

Architecturally, the cleanest solution to me seems to be doing the command line parsing (even if it's just the repro-related args) before SBDebugger::Initialize, and then have special versions of the Initialize function like Initialize(args_for_record) and Initialize(args_for_replay). The interesting repro-related stuff would then happen in these functions, which can then call the Initialize functions of relevant components (like FileSystem) and pass appropriate arguments.

However, I can't say how would that fit into your intended design or any code you already have implemented.

[JDevlieghere]

In D53532#1280880, @labath wrote:

Yes, right now it certainly seems to be the case that we parse cmdline late in the game. However, it's not clear to me whether that has to be the case.

I can't say I have thought this through to the end, but it seems to me that setting up the repro engine should be one of the first (if not THE first) SB calls from the driver. Right now the parsing happens too late (e.g. we already have an SBDebugger instance created at that point). I am not sure you could safely initialize record/replay at that point, even if you got FileSystem switching working.

Architecturally, the cleanest solution to me seems to be doing the command line parsing (even if it's just the repro-related args) before SBDebugger::Initialize, and then have special versions of the Initialize function like Initialize(args_for_record) and Initialize(args_for_replay). The interesting repro-related stuff would then happen in these functions, which can then call the Initialize functions of relevant components (like FileSystem) and pass appropriate arguments.

However, I can't say how would that fit into your intended design or any code you already have implemented.

Sounds reasonable. Let's go with the static Initialize approach now and figure out the details about initializing the reproducer later.

[JDevlieghere]

Add static initializers.

[labath]

Thanks for bearing with me. I am very happy with how this turned out in the end. I have more suggestion on how to clean up the initialization, which you can incorporate if you like it, but I don't want to hold up the patch over that.

include/lldb/Host/FileSystem.h

21

Not needed anymore?

include/lldb/Utility/FileSpec.h

423

It seems this is still here... :(

source/Host/common/FileSystem.cpp

30

Instead of manual m_initialized management, what would you say to this:

• have a private InstanceImpl (or whatever) function, which returns an Optional<FileSystem> &
• Initialize does InstanceImpl().emplace(VFS); (it can check that the value is None beforehand if you want, but I am not worried about people accidentally calling Initialize twice).
• Terminate does InstanceImpl().reset();
• Instance does return *InstanceImpl();

I think this would be a bit cleaner as it would allow is to specify the VFS directly during construction. We would avoid having to construct a FileSystem object with a dummy VFS, only to replace it with another one later. And also you wouldn't need to subclass FileSystem in the unit tests just to change the implementation.

unittests/Host/FileSystemTest.cpp

293–301

You can write this more concisely (and with better error messages) as EXPECT_THAT(visited, testing::UnorderedElementsAre("/foo", "/bar", "/baz", "/qux")); (you need to include gmock.h for that to work).

include/lldb/Breakpoint/BreakpointResolver.h

 
 // C Includes
 // C++ Includes
 // Other libraries and framework includes
 // Project includes
 #include "lldb/Breakpoint/Breakpoint.h"
 #include "lldb/Core/Address.h"
 #include "lldb/Core/SearchFilter.h"
+#include "lldb/Host/FileSpec.h"
 #include "lldb/Utility/ConstString.h"
-#include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/RegularExpression.h"
 #include "lldb/lldb-private.h"
 
 namespace lldb_private {
 
 //----------------------------------------------------------------------
 /// @class BreakpointResolver BreakpointResolver.h
 /// "lldb/Breakpoint/BreakpointResolver.h" This class works with SearchFilter

include/lldb/Core/AddressResolverFileLine.h

 //===-- AddressResolverFileLine.h -------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_AddressResolverFileLine_h_
 #define liblldb_AddressResolverFileLine_h_
 
 #include "lldb/Core/AddressResolver.h"
 #include "lldb/Core/SearchFilter.h" // for Searcher, Searcher::CallbackR...
-#include "lldb/Utility/FileSpec.h"  // for FileSpec
+#include "lldb/Host/FileSpec.h"     // for FileSpec
 #include "lldb/lldb-defines.h"      // for DISALLOW_COPY_AND_ASSIGN
 
 #include <stdint.h> // for uint32_t
 
 namespace lldb_private {
 class Address;
 }
 namespace lldb_private {

include/lldb/Core/Debugger.h

 
 // Other libraries and framework includes
 // Project includes
 #include "lldb/Core/Broadcaster.h"
 #include "lldb/Core/FormatEntity.h"
 #include "lldb/Core/IOHandler.h"
 #include "lldb/Core/SourceManager.h"
 #include "lldb/Core/UserSettingsController.h"
+#include "lldb/Host/FileSpec.h" // for FileSpec
 #include "lldb/Host/HostThread.h"
 #include "lldb/Host/Terminal.h"
 #include "lldb/Target/ExecutionContext.h" // for ExecutionContext
 #include "lldb/Target/Platform.h"
 #include "lldb/Target/TargetList.h"
 #include "lldb/Utility/ConstString.h" // for ConstString
-#include "lldb/Utility/FileSpec.h"    // for FileSpec
 #include "lldb/Utility/Status.h"      // for Status
 #include "lldb/Utility/UserID.h"
 #include "lldb/lldb-defines.h"              // for DISALLOW_COPY_AND_ASSIGN
 #include "lldb/lldb-enumerations.h"         // for ScriptLanguage, Langua...
 #include "lldb/lldb-forward.h"              // for StreamFileSP, DebuggerSP
 #include "lldb/lldb-private-enumerations.h" // for VarSetOperationType
 #include "lldb/lldb-private-types.h"        // for LoadPluginCallbackType
 #include "lldb/lldb-types.h"                // for LogOutputCallback, thr...

include/lldb/Core/Disassembler.h

 #ifndef liblldb_Disassembler_h_
 #define liblldb_Disassembler_h_
 
 #include "lldb/Core/Address.h"
 #include "lldb/Core/EmulateInstruction.h"
 #include "lldb/Core/FormatEntity.h" // for FormatEntity
 #include "lldb/Core/Opcode.h"
 #include "lldb/Core/PluginInterface.h"
+#include "lldb/Host/FileSpec.h"
 #include "lldb/Interpreter/OptionValue.h"
 #include "lldb/Symbol/LineEntry.h"
 #include "lldb/Target/ExecutionContext.h" // for ExecutionContext
 #include "lldb/Utility/ArchSpec.h"
-#include "lldb/Utility/ConstString.h" // for ConstString
-#include "lldb/Utility/FileSpec.h"
-#include "lldb/lldb-defines.h"      // for DISALLOW_COPY_AND_ASSIGN
-#include "lldb/lldb-forward.h"      // for InstructionSP, DisassemblerSP
+#include "lldb/Utility/ConstString.h"       // for ConstString
+#include "lldb/lldb-defines.h"              // for DISALLOW_COPY_AND_ASSIGN
+#include "lldb/lldb-forward.h"              // for InstructionSP, DisassemblerSP
 #include "lldb/lldb-private-enumerations.h" // for AddressClass
-#include "lldb/lldb-types.h"        // for addr_t, offset_t
+#include "lldb/lldb-types.h"                // for addr_t, offset_t
 
 #include "llvm/ADT/StringRef.h" // for StringRef
 
 #include <functional> // for function
 #include <map>
 #include <memory> // for enable_shared_from_this
 #include <set>
 #include <string>

include/lldb/Core/FileLineResolver.h

 //===-- FileLineResolver.h --------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_FileLineResolver_h_
 #define liblldb_FileLineResolver_h_
 
 #include "lldb/Core/SearchFilter.h" // for Searcher, Searcher::CallbackR...
+#include "lldb/Host/FileSpec.h"     // for FileSpec
 #include "lldb/Symbol/SymbolContext.h"
-#include "lldb/Utility/FileSpec.h" // for FileSpec
-#include "lldb/lldb-defines.h"     // for DISALLOW_COPY_AND_ASSIGN
+#include "lldb/lldb-defines.h" // for DISALLOW_COPY_AND_ASSIGN
 
 #include <stdint.h> // for uint32_t, UINT32_MAX
 
 namespace lldb_private {
 class Address;
 }
 namespace lldb_private {
 class Stream;

include/lldb/Core/FileSpecList.h

 //===-- FileSpecList.h ------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_FileSpecList_h_
 #define liblldb_FileSpecList_h_
 #if defined(__cplusplus)
 
-#include "lldb/Utility/FileSpec.h"
+#include "lldb/Host/FileSpec.h"
 
 #include <vector>
 
 #include <stddef.h> // for size_t
 
 namespace lldb_private {
 class Stream;
 }

include/lldb/Core/FormatEntity.h

 //===-- FormatEntity.h ------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_FormatEntity_h_
 #define liblldb_FormatEntity_h_
 
+#include "lldb/Host/FileSpec.h" // for FileSpec
 #include "lldb/Utility/CompletionRequest.h"
-#include "lldb/Utility/FileSpec.h" // for FileSpec
 #include "lldb/Utility/Status.h"
 #include "lldb/lldb-enumerations.h" // for Format::eFormatDefault, Format
 #include "lldb/lldb-types.h"        // for addr_t
 #include <algorithm>                // for min
 #include <stddef.h>                 // for size_t
 #include <stdint.h>                 // for uint32_t, uint64_t
 
 #include <string>

include/lldb/Core/Module.h

 //===-- Module.h ------------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_Module_h_
 #define liblldb_Module_h_
 
 #include "lldb/Core/Address.h"    // for Address
 #include "lldb/Core/ModuleSpec.h" // for ModuleSpec
+#include "lldb/Host/FileSpec.h"
 #include "lldb/Symbol/ObjectFile.h" // for ObjectFile
 #include "lldb/Symbol/SymbolContextScope.h"
 #include "lldb/Symbol/TypeSystem.h"
 #include "lldb/Target/PathMappingList.h"
 #include "lldb/Utility/ArchSpec.h"
 #include "lldb/Utility/ConstString.h" // for ConstString
-#include "lldb/Utility/FileSpec.h"
-#include "lldb/Utility/Status.h" // for Status
+#include "lldb/Utility/Status.h"      // for Status
 #include "lldb/Utility/UUID.h"
 #include "lldb/lldb-defines.h"      // for DISALLOW_COPY_AND_ASSIGN
 #include "lldb/lldb-enumerations.h" // for LanguageType, SymbolType
 #include "lldb/lldb-forward.h"
 #include "lldb/lldb-types.h" // for addr_t, offset_t
 
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/StringRef.h"

include/lldb/Core/ModuleList.h

 //===-- ModuleList.h --------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_ModuleList_h_
 #define liblldb_ModuleList_h_
 
 #include "lldb/Core/Address.h"     // for Address
 #include "lldb/Core/ModuleSpec.h"  // for ModuleSpec
 #include "lldb/Core/UserSettingsController.h"
-#include "lldb/Utility/FileSpec.h" // for FileSpec
+#include "lldb/Host/FileSpec.h" // for FileSpec
 #include "lldb/Utility/Iterable.h"
 #include "lldb/Utility/Status.h" // for Status
 #include "lldb/lldb-enumerations.h"
 #include "lldb/lldb-forward.h"
 #include "lldb/lldb-types.h"
 
 #include "llvm/ADT/DenseSet.h"
 

include/lldb/Core/ModuleSpec.h

 //===-- ModuleSpec.h --------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_ModuleSpec_h_
 #define liblldb_ModuleSpec_h_
 
 // Project includes
+#include "lldb/Host/FileSpec.h"
 #include "lldb/Target/PathMappingList.h"
 #include "lldb/Utility/ArchSpec.h"
-#include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/Stream.h"
 #include "lldb/Utility/UUID.h"
 
 // Other libraries and framework includes
 #include "llvm/Support/Chrono.h"
 
 // C Includes
 // C++ Includes

include/lldb/Core/PluginManager.h

 //===-- PluginManager.h -----------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_PluginManager_h_
 #define liblldb_PluginManager_h_
 
 #include "lldb/Core/Architecture.h"
-#include "lldb/Utility/FileSpec.h"
+#include "lldb/Host/FileSpec.h"
 #include "lldb/Utility/Status.h"          // for Status
 #include "lldb/lldb-enumerations.h"       // for ScriptLanguage
 #include "lldb/lldb-forward.h"            // for OptionValuePropertiesSP
 #include "lldb/lldb-private-interfaces.h" // for DebuggerInitializeCallback
 #include "llvm/ADT/StringRef.h"           // for StringRef
 
 #include <stddef.h> // for size_t
 #include <stdint.h> // for uint32_t

include/lldb/Core/SearchFilter.h

 //===-- SearchFilter.h ------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_SearchFilter_h_
 #define liblldb_SearchFilter_h_
 
 #include "lldb/Core/FileSpecList.h"
 #include "lldb/Utility/StructuredData.h"
 
-#include "lldb/Utility/FileSpec.h" // for FileSpec
+#include "lldb/Host/FileSpec.h"    // for FileSpec
 #include "lldb/lldb-forward.h"     // for SearchFilterSP, TargetSP, Modu...
 
 #include <stdint.h> // for uint32_t
 
 namespace lldb_private {
 class Address;
 }
 namespace lldb_private {

include/lldb/Core/SourceManager.h

 //===-- SourceManager.h -----------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_SourceManager_h_
 #define liblldb_SourceManager_h_
 
-#include "lldb/Utility/FileSpec.h"
+#include "lldb/Host/FileSpec.h"
 #include "lldb/lldb-defines.h" // for DISALLOW_COPY_AND_ASSIGN
 #include "lldb/lldb-forward.h" // for DebuggerSP, DebuggerWP, DataBufferSP
 
 #include "llvm/Support/Chrono.h"
 
 #include <cstdint> // for uint32_t, UINT32_MAX
 #include <map>
 #include <memory>

include/lldb/Host/Editline.h

 #include <histedit.h>
 #endif
 
 #include <mutex>
 #include <string>
 #include <vector>
 
 #include "lldb/Host/ConnectionFileDescriptor.h"
-#include "lldb/Utility/FileSpec.h"
+#include "lldb/Host/FileSpec.h"
 #include "lldb/Utility/Predicate.h"
 
 namespace lldb_private {
 namespace line_editor {
 
 // type alias's to help manage 8 bit and wide character versions of libedit
 #if LLDB_EDITLINE_USE_WCHAR
 using EditLineStringType = std::wstring;

include/lldb/Host/FileCache.h

 #define liblldb_Host_FileCache_h
 
 #include <map>
 #include <stdint.h>
 
 #include "lldb/lldb-forward.h"
 #include "lldb/lldb-types.h"
 
-#include "lldb/Utility/FileSpec.h"
+#include "lldb/Host/FileSpec.h"
 #include "lldb/Utility/Status.h"
 
 namespace lldb_private {
 class FileCache {
 private:
   FileCache() {}
 
   typedef std::map<lldb::user_id_t, lldb::FileSP> FDToFileMap;

include/lldb/Host/FileSystem.h

 //===-- FileSystem.h --------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_Host_FileSystem_h
 #define liblldb_Host_FileSystem_h
 
-#include "lldb/Utility/FileSpec.h"
+#include "lldb/Host/FileSpec.h"
 #include "lldb/Utility/Status.h"
+
 #include "llvm/Support/Chrono.h"
+#include "llvm/Support/VirtualFileSystem.h"
 
 #include "lldb/lldb-types.h"
 
 #include <stdint.h>
 #include <stdio.h>
 #include <sys/stat.h>
 
 namespace lldb_private {
 class FileSystem {
 public:
   static const char *DEV_NULL;
   static const char *PATH_CONVERSION_ERROR;
 
+  FileSystem() : m_fs(llvm::vfs::getRealFileSystem()) {}
+
+  static FileSystem &Instance();
+
+  void ChangeFileSystem(llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> fs);
+
   static Status Symlink(const FileSpec &src, const FileSpec &dst);
   static Status Readlink(const FileSpec &src, FileSpec &dst);
 
   static Status ResolveSymbolicLink(const FileSpec &src, FileSpec &dst);
 
   /// Wraps ::fopen in a platform-independent way. Once opened, FILEs can be
   /// manipulated and closed with the normal ::fread, ::fclose, etc. functions.
   static FILE *Fopen(const char *path, const char *mode);
 
-  static llvm::sys::TimePoint<> GetModificationTime(const FileSpec &file_spec);
+  /// Returns the modification time of the given file.
+  /// @{
+  llvm::sys::TimePoint<> GetModificationTime(const FileSpec &file_spec) const;
+  llvm::sys::TimePoint<> GetModificationTime(const llvm::Twine &path) const;
+  /// @}
+
+  /// Returns the on-disk size of the given file in bytes.
+  /// @{
+  uint64_t GetByteSize(const FileSpec &file_spec) const;
+  uint64_t GetByteSize(const llvm::Twine &path) const;
+  /// @}
+
+  /// Return the current permissions of the given file.
+  ///
+  /// Returns a bitmask for the current permissions of the file (zero or more
+  /// of the permission bits defined in File::Permissions).
+  /// @{
+  uint32_t GetPermissions(const FileSpec &file_spec) const;
+  uint32_t GetPermissions(const llvm::Twine &path) const;
+  /// @}
+
+  /// Returns whether the given file exists.
+  /// @{
+  bool Exists(const FileSpec &file_spec) const;
+  bool Exists(const llvm::Twine &path) const;
+  /// @}
+
+  /// Make the given file path absolute.
+  /// @{
+  std::error_code MakeAbsolute(llvm::SmallVectorImpl<char> &path) const;
+  std::error_code MakeAbsolute(FileSpec &file_spec) const;
+  /// @}
+
+  enum EnumerateDirectoryResult {
+    /// Enumerate next entry in the current directory.
+    eEnumerateDirectoryResultNext,
+    /// Recurse into the current entry if it is a directory or symlink, or next
+    /// if not.
+    eEnumerateDirectoryResultEnter,
+    /// Stop directory enumerations at any level.
+    eEnumerateDirectoryResultQuit
+  };
+
+  typedef EnumerateDirectoryResult (*EnumerateDirectoryCallbackType)(
+      void *baton, llvm::sys::fs::file_type file_type, llvm::StringRef);
+
+  typedef std::function<EnumerateDirectoryResult(
+      llvm::sys::fs::file_type file_type, llvm::StringRef)>
+      DirectoryCallback;
+
+  void EnumerateDirectory(llvm::Twine path, bool find_directories,
+                          bool find_files, bool find_other,
+                          EnumerateDirectoryCallbackType callback,
+                          void *callback_baton);
+
+  std::error_code GetRealPath(const llvm::Twine &path,
+                              llvm::SmallVectorImpl<char> &output) const;
+
+private:
+  llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> m_fs;
 };
-}
+} // namespace lldb_private
 
 #endif

include/lldb/Host/Host.h

 //===-- Host.h --------------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_HOST_HOST_H
 #define LLDB_HOST_HOST_H
 
 #include "lldb/Host/File.h"
+#include "lldb/Host/FileSpec.h"
 #include "lldb/Host/HostThread.h"
 #include "lldb/Utility/Environment.h"
-#include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/Timeout.h"
 #include "lldb/lldb-private-forward.h"
 #include "lldb/lldb-private.h"
 #include <cerrno>
 #include <map>
 #include <stdarg.h>
 #include <string>
 #include <type_traits>

include/lldb/Host/HostInfoBase.h

 //===-- HostInfoBase.h ------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef lldb_Host_HostInfoBase_h_
 #define lldb_Host_HostInfoBase_h_
 
+#include "lldb/Host/FileSpec.h"
 #include "lldb/Utility/ArchSpec.h"
-#include "lldb/Utility/FileSpec.h"
 #include "lldb/lldb-enumerations.h"
 
 #include "llvm/ADT/StringRef.h"
 
 #include <stdint.h>
 
 #include <string>
 

include/lldb/Host/Symbols.h

 #define liblldb_Symbols_h_
 
 // C Includes
 #include <stdint.h>
 
 // C++ Includes
 // Other libraries and framework includes
 // Project includes
-#include "lldb/Utility/FileSpec.h"
+#include "lldb/Host/FileSpec.h"
 
 namespace lldb_private {
 
 class ArchSpec;
 class ModuleSpec;
 class UUID;
 
 class Symbols {

include/lldb/Host/freebsd/HostInfoFreeBSD.h

 //===-- HostInfoFreeBSD.h ---------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef lldb_Host_freebsd_HostInfoFreeBSD_h_
 #define lldb_Host_freebsd_HostInfoFreeBSD_h_
 
+#include "lldb/Host/FileSpec.h"
 #include "lldb/Host/posix/HostInfoPosix.h"
-#include "lldb/Utility/FileSpec.h"
 #include "llvm/Support/VersionTuple.h"
 
 namespace lldb_private {
 
 class HostInfoFreeBSD : public HostInfoPosix {
 public:
   static llvm::VersionTuple GetOSVersion();
   static bool GetOSBuildString(std::string &s);
   static bool GetOSKernelDescription(std::string &s);
   static FileSpec GetProgramFileSpec();
 };
 }
 
 #endif

include/lldb/Host/linux/HostInfoLinux.h

 //===-- HostInfoLinux.h -----------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef lldb_Host_linux_HostInfoLinux_h_
 #define lldb_Host_linux_HostInfoLinux_h_
 
+#include "lldb/Host/FileSpec.h"
 #include "lldb/Host/posix/HostInfoPosix.h"
-#include "lldb/Utility/FileSpec.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/VersionTuple.h"
 
 #include <string>
 
 namespace lldb_private {
 
 class HostInfoLinux : public HostInfoPosix {

include/lldb/Host/macosx/HostInfoMacOSX.h

 //===-- HostInfoMacOSX.h ----------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef lldb_Host_macosx_HostInfoMacOSX_h_
 #define lldb_Host_macosx_HostInfoMacOSX_h_
 
+#include "lldb/Host/FileSpec.h"
 #include "lldb/Host/posix/HostInfoPosix.h"
-#include "lldb/Utility/FileSpec.h"
 #include "llvm/Support/VersionTuple.h"
 
 namespace lldb_private {
 
 class ArchSpec;
 
 class HostInfoMacOSX : public HostInfoPosix {
   friend class HostInfoBase;

include/lldb/Host/netbsd/HostInfoNetBSD.h

 //===-- HostInfoNetBSD.h ---------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef lldb_Host_netbsd_HostInfoNetBSD_h_
 #define lldb_Host_netbsd_HostInfoNetBSD_h_
 
+#include "lldb/Host/FileSpec.h"
 #include "lldb/Host/posix/HostInfoPosix.h"
-#include "lldb/Utility/FileSpec.h"
 #include "llvm/Support/VersionTuple.h"
 
 namespace lldb_private {
 
 class HostInfoNetBSD : public HostInfoPosix {
 public:
   static llvm::VersionTuple GetOSVersion();
   static bool GetOSBuildString(std::string &s);
   static bool GetOSKernelDescription(std::string &s);
   static FileSpec GetProgramFileSpec();
 };
 }
 
 #endif

include/lldb/Host/openbsd/HostInfoOpenBSD.h

 //===-- HostInfoOpenBSD.h --------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef lldb_Host_openbsd_HostInfoOpenBSD_h_
 #define lldb_Host_openbsd_HostInfoOpenBSD_h_
 
+#include "lldb/Host/FileSpec.h"
 #include "lldb/Host/posix/HostInfoPosix.h"
-#include "lldb/Utility/FileSpec.h"
 
 namespace lldb_private {
 
 class HostInfoOpenBSD : public HostInfoPosix {
 public:
   static bool GetOSVersion(uint32_t &major, uint32_t &minor, uint32_t &update);
   static bool GetOSBuildString(std::string &s);
   static bool GetOSKernelDescription(std::string &s);
   static FileSpec GetProgramFileSpec();
 };
 }
 
 #endif

include/lldb/Host/posix/HostInfoPosix.h

 //===-- HostInfoPosix.h -----------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef lldb_Host_posix_HostInfoPosix_h_
 #define lldb_Host_posix_HostInfoPosix_h_
 
+#include "lldb/Host/FileSpec.h"
 #include "lldb/Host/HostInfoBase.h"
-#include "lldb/Utility/FileSpec.h"
 
 namespace lldb_private {
 
 class HostInfoPosix : public HostInfoBase {
   friend class HostInfoBase;
 
 public:
   static size_t GetPageSize();

include/lldb/Host/windows/HostInfoWindows.h

 //===-- HostInfoWindows.h ---------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef lldb_Host_windows_HostInfoWindows_h_
 #define lldb_Host_windows_HostInfoWindows_h_
 
+#include "lldb/Host/FileSpec.h"
 #include "lldb/Host/HostInfoBase.h"
-#include "lldb/Utility/FileSpec.h"
 #include "llvm/Support/VersionTuple.h"
 
 namespace lldb_private {
 
 class HostInfoWindows : public HostInfoBase {
   friend class HostInfoBase;
 
 private:

include/lldb/Interpreter/OptionValueFileSpec.h

 //===-- OptionValueFileSpec.h -----------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_OptionValueFileSpec_h_
 #define liblldb_OptionValueFileSpec_h_
 
 #include "lldb/Interpreter/OptionValue.h"
 
-#include "lldb/Utility/FileSpec.h"
+#include "lldb/Host/FileSpec.h"
 #include "llvm/Support/Chrono.h"
 
 namespace lldb_private {
 
 class OptionValueFileSpec : public OptionValue {
 public:
   OptionValueFileSpec(bool resolve = true);
 

include/lldb/Symbol/Declaration.h

 //===-- Declaration.h -------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_Declaration_h_
 #define liblldb_Declaration_h_
 
-#include "lldb/Utility/FileSpec.h"
+#include "lldb/Host/FileSpec.h"
 #include "lldb/lldb-private.h"
 
 namespace lldb_private {
 
 //----------------------------------------------------------------------
 /// @class Declaration Declaration.h "lldb/Symbol/Declaration.h"
 /// A class that describes the declaration location of a
 ///        lldb object.

include/lldb/Symbol/LineEntry.h

 //===-- LineEntry.h ---------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_LineEntry_h_
 #define liblldb_LineEntry_h_
 
 #include "lldb/Core/AddressRange.h"
-#include "lldb/Utility/FileSpec.h"
+#include "lldb/Host/FileSpec.h"
 #include "lldb/lldb-private.h"
 
 namespace lldb_private {
 
 //----------------------------------------------------------------------
 /// @class LineEntry LineEntry.h "lldb/Symbol/LineEntry.h"
 /// A line table entry class.
 //----------------------------------------------------------------------

include/lldb/Symbol/ObjectContainer.h

 #define liblldb_ObjectContainer_h_
 
 // C Includes
 // C++ Includes
 // Other libraries and framework includes
 // Project includes
 #include "lldb/Core/ModuleChild.h"
 #include "lldb/Core/PluginInterface.h"
+#include "lldb/Host/FileSpec.h"
 #include "lldb/Utility/DataExtractor.h"
 #include "lldb/Utility/Endian.h"
-#include "lldb/Utility/FileSpec.h"
 #include "lldb/lldb-private.h"
 
 namespace lldb_private {
 
 //----------------------------------------------------------------------
 /// @class ObjectContainer ObjectContainer.h "lldb/Symbol/ObjectContainer.h"
 /// A plug-in interface definition class for object containers.
 ///

include/lldb/Symbol/ObjectFile.h

 //===-- ObjectFile.h --------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_ObjectFile_h_
 #define liblldb_ObjectFile_h_
 
 #include "lldb/Core/FileSpecList.h"
 #include "lldb/Core/ModuleChild.h"
 #include "lldb/Core/PluginInterface.h"
+#include "lldb/Host/FileSpec.h"
 #include "lldb/Symbol/Symtab.h"
 #include "lldb/Symbol/UnwindTable.h"
 #include "lldb/Utility/DataExtractor.h"
 #include "lldb/Utility/Endian.h"
-#include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/UUID.h"
 #include "lldb/lldb-private.h"
 #include "llvm/Support/VersionTuple.h"
 
 namespace lldb_private {
 
 class ObjectFileJITDelegate {
 public:

include/lldb/Target/DynamicLoader.h

 //===-- DynamicLoader.h -----------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_DynamicLoader_h_
 #define liblldb_DynamicLoader_h_
 
 // Project includes
 #include "lldb/Core/PluginInterface.h"
-#include "lldb/Utility/FileSpec.h" // for FileSpec
+#include "lldb/Host/FileSpec.h" // for FileSpec
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/UUID.h"
 #include "lldb/lldb-defines.h"              // for LLDB_INVALID_ADDRESS
 #include "lldb/lldb-forward.h"              // for ModuleSP, ThreadPlanSP
 #include "lldb/lldb-private-enumerations.h" // for LazyBool, LazyBool::eLaz...
 #include "lldb/lldb-types.h"                // for addr_t
 
 #include <stddef.h> // for size_t

include/lldb/Target/FileAction.h

 //===-- FileAction.h --------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_Target_FileAction_h
 #define liblldb_Target_FileAction_h
 
-#include "lldb/Utility/FileSpec.h"
+#include "lldb/Host/FileSpec.h"
 #include <string>
 
 namespace lldb_private {
 
 class FileAction {
 public:
   enum Action {
     eFileActionNone,

include/lldb/Target/ModuleCache.h

 //===-- ModuleCache.h -------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_TARGET_MODULECACHE_H
 #define LLDB_TARGET_MODULECACHE_H
 
 #include "lldb/lldb-forward.h"
 #include "lldb/lldb-types.h"
 
 #include "lldb/Host/File.h"
-#include "lldb/Utility/FileSpec.h"
+#include "lldb/Host/FileSpec.h"
 #include "lldb/Utility/Status.h"
 
 #include <functional>
 #include <string>
 #include <unordered_map>
 
 namespace lldb_private {
 

include/lldb/Target/Platform.h

 #include <mutex>
 #include <string>
 #include <vector>
 
 // Other libraries and framework includes
 // Project includes
 #include "lldb/Core/PluginInterface.h"
 #include "lldb/Core/UserSettingsController.h"
+#include "lldb/Host/FileSpec.h"
 #include "lldb/Interpreter/Options.h"
 #include "lldb/Utility/ArchSpec.h"
 #include "lldb/Utility/ConstString.h"
-#include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/Timeout.h"
 #include "lldb/lldb-private-forward.h"
 #include "lldb/lldb-public.h"
 #include "llvm/Support/VersionTuple.h"
 
 namespace lldb_private {
 
 class ModuleCache;

include/lldb/Target/ProcessInfo.h

 //===-- ProcessInfo.h -------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_ProcessInfo_h_
 #define liblldb_ProcessInfo_h_
 
 // LLDB headers
+#include "lldb/Host/FileSpec.h"
 #include "lldb/Utility/ArchSpec.h"
 #include "lldb/Utility/Args.h"
 #include "lldb/Utility/Environment.h"
-#include "lldb/Utility/FileSpec.h"
 
 namespace lldb_private {
 //----------------------------------------------------------------------
 // ProcessInfo
 //
 // A base class for information for a process. This can be used to fill
 // out information for a process prior to launching it, or it can be used for
 // an instance of a process and can be filled in with the existing values for

include/lldb/Target/ProcessLaunchInfo.h

 #define liblldb_ProcessLaunch_Info_h
 
 // C++ Headers
 #include <string>
 
 // LLDB Headers
 #include "lldb/Utility/Flags.h"
 
+#include "lldb/Host/FileSpec.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Host/PseudoTerminal.h"
 #include "lldb/Target/FileAction.h"
 #include "lldb/Target/ProcessInfo.h"
-#include "lldb/Utility/FileSpec.h"
 
 namespace lldb_private {
 
 //----------------------------------------------------------------------
 // ProcessLaunchInfo
 //
 // Describes any information that is required to launch a process.
 //----------------------------------------------------------------------

include/lldb/Utility/Args.h

 //===-- Args.h --------------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_UTILITY_ARGS_H
 #define LLDB_UTILITY_ARGS_H
 
+#include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/Environment.h"
 #include "lldb/lldb-private-types.h"
 #include "lldb/lldb-types.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/StringRef.h"
 #include <string>
 #include <utility>
 #include <vector>
public:
   }
 
   static lldb::Encoding
   StringToEncoding(llvm::StringRef s,
                    lldb::Encoding fail_value = lldb::eEncodingInvalid);
 
   static uint32_t StringToGenericRegister(llvm::StringRef s);
 
-  static const char *GetShellSafeArgument(const FileSpec &shell,
+  static const char *GetShellSafeArgument(ConstString shell,
                                           const char *unsafe_arg,
                                           std::string &safe_arg);
 
   // EncodeEscapeSequences will change the textual representation of common
   // escape sequences like "\n" (two characters) into a single '\n'. It does
   // this for all of the supported escaped sequences and for the \0ooo (octal)
   // and \xXX (hex). The resulting "dst" string will contain the character
   // versions of all supported escape sequences. The common supported escape

include/lldb/Utility/StructuredData.h

 //===-- StructuredData.h ----------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_StructuredData_h_
 #define liblldb_StructuredData_h_
 
 #include "llvm/ADT/StringRef.h"
 
 #include "lldb/Utility/ConstString.h"
-#include "lldb/Utility/FileSpec.h"  // for FileSpec
 #include "lldb/lldb-enumerations.h" // for StructuredDataType
 
 #include <cassert> // for assert
 #include <cstddef> // for size_t
 #include <cstdint> // for uint64_t
 #include <functional>
 #include <map>
 #include <memory>
public:
 
     void Dump(Stream &s, bool pretty_print = true) const override;
 
   private:
     void *m_object;
   };
 
   static ObjectSP ParseJSON(std::string json_text);
-
-  static ObjectSP ParseJSONFromFile(const FileSpec &file, Status &error);
 };
 
 } // namespace lldb_private
 
 #endif // liblldb_StructuredData_h_

source/API/SBFileSpec.cpp

 //===-- SBFileSpec.cpp ------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include <inttypes.h> // PRIu64
 #include <limits.h>
 
 #include "lldb/API/SBFileSpec.h"
 #include "lldb/API/SBStream.h"
+#include "lldb/Host/FileSpec.h"
 #include "lldb/Host/PosixApi.h"
-#include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/Stream.h"
 
 #include "llvm/ADT/SmallString.h"
 
 using namespace lldb;
 using namespace lldb_private;
 

source/API/SBFileSpecList.cpp

 //===-- SBFileSpecList.cpp --------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include <limits.h>
 
 #include "lldb/API/SBFileSpec.h"
 #include "lldb/API/SBFileSpecList.h"
 #include "lldb/API/SBStream.h"
 #include "lldb/Core/FileSpecList.h"
+#include "lldb/Host/FileSpec.h"
 #include "lldb/Host/PosixApi.h"
-#include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/Stream.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 SBFileSpecList::SBFileSpecList() : m_opaque_ap(new FileSpecList()) {}
 

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/FileSpec.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"
 
 #include "Plugins/ExpressionParser/Clang/ClangHost.h"
 #ifndef LLDB_DISABLE_PYTHON
 #include "Plugins/ScriptInterpreter/Python/ScriptInterpreterPython.h"
 #endif
 
 #include "llvm/ADT/SmallString.h"

source/API/SBTarget.cpp

 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/STLUtils.h"
 #include "lldb/Core/SearchFilter.h"
 #include "lldb/Core/Section.h"
 #include "lldb/Core/StructuredDataImpl.h"
 #include "lldb/Core/ValueObjectConstResult.h"
 #include "lldb/Core/ValueObjectList.h"
 #include "lldb/Core/ValueObjectVariable.h"
+#include "lldb/Host/FileSpec.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Symbol/ClangASTContext.h"
 #include "lldb/Symbol/DeclVendor.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/SymbolFile.h"
 #include "lldb/Symbol/SymbolVendor.h"
 #include "lldb/Symbol/VariableList.h"
 #include "lldb/Target/ABI.h"
 #include "lldb/Target/Language.h"
 #include "lldb/Target/LanguageRuntime.h"
 #include "lldb/Target/ObjCLanguageRuntime.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/StackFrame.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/TargetList.h"
 #include "lldb/Utility/ArchSpec.h"
 #include "lldb/Utility/Args.h"
-#include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/RegularExpression.h"
 
 #include "Commands/CommandObjectBreakpoint.h"
 #include "lldb/Interpreter/CommandReturnObject.h"
 #include "llvm/Support/PrettyStackTrace.h"
 #include "llvm/Support/Regex.h"
 

source/Commands/CommandCompletions.cpp

 // Other libraries and framework includes
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringSet.h"
 
 // Project includes
 #include "lldb/Core/FileSpecList.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/PluginManager.h"
+#include "lldb/Host/FileSpec.h"
 #include "lldb/Host/FileSystem.h"
 #include "lldb/Interpreter/CommandCompletions.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Interpreter/OptionValueProperties.h"
 #include "lldb/Symbol/CompileUnit.h"
 #include "lldb/Symbol/Variable.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/Args.h"
-#include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/StreamString.h"
 #include "lldb/Utility/TildeExpressionResolver.h"
 
 #include "llvm/ADT/SmallString.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Path.h"
 
 using namespace lldb_private;

source/Commands/CommandObjectLog.cpp

 // C Includes
 // C++ Includes
 // Other libraries and framework includes
 // Project includes
 #include "CommandObjectLog.h"
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/StreamFile.h"
+#include "lldb/Host/FileSpec.h"
 #include "lldb/Host/OptionParser.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Interpreter/CommandReturnObject.h"
 #include "lldb/Interpreter/OptionArgParser.h"
 #include "lldb/Interpreter/Options.h"
 #include "lldb/Symbol/LineTable.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/SymbolFile.h"
 #include "lldb/Symbol/SymbolVendor.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/Args.h"
-#include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/RegularExpression.h"
 #include "lldb/Utility/Stream.h"
 #include "lldb/Utility/Timer.h"
 
 using namespace lldb;
 using namespace lldb_private;
 

source/Commands/CommandObjectSource.cpp

 // C++ Includes
 // Other libraries and framework includes
 // Project includes
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/FileLineResolver.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/SourceManager.h"
+#include "lldb/Host/FileSpec.h"
 #include "lldb/Host/OptionParser.h"
 #include "lldb/Interpreter/CommandCompletions.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Interpreter/CommandReturnObject.h"
 #include "lldb/Interpreter/OptionArgParser.h"
 #include "lldb/Interpreter/Options.h"
 #include "lldb/Symbol/CompileUnit.h"
 #include "lldb/Symbol/Function.h"
 #include "lldb/Symbol/Symbol.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/SectionLoadList.h"
 #include "lldb/Target/StackFrame.h"
 #include "lldb/Target/TargetList.h"
-#include "lldb/Utility/FileSpec.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 #pragma mark CommandObjectSourceInfo
 //----------------------------------------------------------------------
 // CommandObjectSourceInfo - debug line entries dumping command
 //----------------------------------------------------------------------

source/Core/Address.cpp

 //===-- Address.cpp ---------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Core/Address.h"
 #include "lldb/Core/DumpDataExtractor.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleList.h" // for ModuleList
 #include "lldb/Core/Section.h"
+#include "lldb/Host/FileSpec.h" // for FileSpec
 #include "lldb/Symbol/Block.h"
 #include "lldb/Symbol/Declaration.h" // for Declaration
 #include "lldb/Symbol/LineEntry.h"   // for LineEntry
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/Symbol.h"        // for Symbol
 #include "lldb/Symbol/SymbolContext.h" // for SymbolContext
 #include "lldb/Symbol/SymbolVendor.h"
 #include "lldb/Symbol/Symtab.h" // for Symtab
 #include "lldb/Symbol/Type.h"   // for Type
 #include "lldb/Symbol/Variable.h"
 #include "lldb/Symbol/VariableList.h"
 #include "lldb/Target/ExecutionContext.h"
 #include "lldb/Target/ExecutionContextScope.h" // for ExecutionContextScope
 #include "lldb/Target/Process.h"
 #include "lldb/Target/SectionLoadList.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/ConstString.h"   // for ConstString
 #include "lldb/Utility/DataExtractor.h" // for DataExtractor
 #include "lldb/Utility/Endian.h"        // for InlHostByteOrder
-#include "lldb/Utility/FileSpec.h"      // for FileSpec
 #include "lldb/Utility/Status.h"        // for Status
 #include "lldb/Utility/Stream.h"        // for Stream
 #include "lldb/Utility/StreamString.h"  // for StreamString
 
 #include "llvm/ADT/StringRef.h" // for StringRef
 #include "llvm/ADT/Triple.h"
 #include "llvm/Support/Compiler.h" // for LLVM_FALLTHROUGH
 

source/Core/AddressRange.cpp

 //===-- AddressRange.cpp ----------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Core/AddressRange.h"
 #include "lldb/Core/Module.h"
+#include "lldb/Host/FileSpec.h" // for FileSpec
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/ConstString.h" // for ConstString
-#include "lldb/Utility/FileSpec.h"    // for FileSpec
 #include "lldb/Utility/Stream.h"
 #include "lldb/lldb-defines.h" // for LLDB_INVALID_ADDRESS
 
 #include "llvm/Support/Compiler.h" // for LLVM_FALLTHROUGH
 
 #include <memory> // for shared_ptr
 
 #include <inttypes.h> // for PRIx64

source/Core/Debugger.cpp

 #include "lldb/Core/Mangled.h"    // for Mangled
 #include "lldb/Core/ModuleList.h" // for Mangled
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/StreamAsynchronousIO.h"
 #include "lldb/Core/StreamFile.h"
 #include "lldb/DataFormatters/DataVisualization.h"
 #include "lldb/Expression/REPL.h"
 #include "lldb/Host/File.h" // for File, File::kInv...
+#include "lldb/Host/FileSystem.h"
 #include "lldb/Host/HostInfo.h"
 #include "lldb/Host/Terminal.h"
 #include "lldb/Host/ThreadLauncher.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Interpreter/OptionValue.h" // for OptionValue, Opt...
 #include "lldb/Interpreter/OptionValueProperties.h"
 #include "lldb/Interpreter/OptionValueSInt64.h"
 #include "lldb/Interpreter/OptionValueString.h"
if (g_load_plugin_callback) {
     // The g_load_plugin_callback is registered in SBDebugger::Initialize() and
     // if the public API layer isn't available (code is linking against all of
     // the internal LLDB static libraries), then we can't load plugins
     error.SetErrorString("Public API layer is not available");
   }
   return false;
 }
 
-static FileSpec::EnumerateDirectoryResult
+static FileSystem::EnumerateDirectoryResult
 LoadPluginCallback(void *baton, llvm::sys::fs::file_type ft,
-                   const FileSpec &file_spec) {
+                   llvm::StringRef path) {
   Status error;
 
   static ConstString g_dylibext(".dylib");
   static ConstString g_solibext(".so");
 
   if (!baton)
-    return FileSpec::eEnumerateDirectoryResultQuit;
+    return FileSystem::eEnumerateDirectoryResultQuit;
 
   Debugger *debugger = (Debugger *)baton;
 
   namespace fs = llvm::sys::fs;
   // If we have a regular file, a symbolic link or unknown file type, try and
   // process the file. We must handle unknown as sometimes the directory
   // enumeration might be enumerating a file system that doesn't have correct
   // file type information.
   if (ft == fs::file_type::regular_file || ft == fs::file_type::symlink_file ||
       ft == fs::file_type::type_unknown) {
-    FileSpec plugin_file_spec(file_spec);
+    FileSpec plugin_file_spec(path, false);
     plugin_file_spec.ResolvePath();
 
     if (plugin_file_spec.GetFileNameExtension() != g_dylibext &&
         plugin_file_spec.GetFileNameExtension() != g_solibext) {
-      return FileSpec::eEnumerateDirectoryResultNext;
+      return FileSystem::eEnumerateDirectoryResultNext;
     }
 
     Status plugin_load_error;
     debugger->LoadPlugin(plugin_file_spec, plugin_load_error);
 
-    return FileSpec::eEnumerateDirectoryResultNext;
+    return FileSystem::eEnumerateDirectoryResultNext;
   } else if (ft == fs::file_type::directory_file ||
              ft == fs::file_type::symlink_file ||
              ft == fs::file_type::type_unknown) {
     // Try and recurse into anything that a directory or symbolic link. We must
     // also do this for unknown as sometimes the directory enumeration might be
     // enumerating a file system that doesn't have correct file type
     // information.
-    return FileSpec::eEnumerateDirectoryResultEnter;
+    return FileSystem::eEnumerateDirectoryResultEnter;
   }
 
-  return FileSpec::eEnumerateDirectoryResultNext;
+  return FileSystem::eEnumerateDirectoryResultNext;
 }
 
 void Debugger::InstanceInitialize() {
   const bool find_directories = true;
   const bool find_files = true;
   const bool find_other = true;
   char dir_path[PATH_MAX];
   if (FileSpec dir_spec = HostInfo::GetSystemPluginDir()) {
     if (dir_spec.Exists() && dir_spec.GetPath(dir_path, sizeof(dir_path))) {
-      FileSpec::EnumerateDirectory(dir_path, find_directories, find_files,
-                                   find_other, LoadPluginCallback, this);
+      FileSystem::Instance().EnumerateDirectory(dir_path, find_directories,
+                                                find_files, find_other,
+                                                LoadPluginCallback, this);
     }
   }
 
   if (FileSpec dir_spec = HostInfo::GetUserPluginDir()) {
     if (dir_spec.Exists() && dir_spec.GetPath(dir_path, sizeof(dir_path))) {
-      FileSpec::EnumerateDirectory(dir_path, find_directories, find_files,
-                                   find_other, LoadPluginCallback, this);
+      FileSystem::Instance().EnumerateDirectory(dir_path, find_directories,
+                                                find_files, find_other,
+                                                LoadPluginCallback, this);
     }
   }
 
   PluginManager::DebuggerInitialize(*this);
 }
 
 DebuggerSP Debugger::CreateInstance(lldb::LogOutputCallback log_callback,
                                     void *baton) {

source/Core/FormatEntity.cpp

 #include "lldb/Core/Module.h"
 #include "lldb/Core/ValueObject.h"
 #include "lldb/Core/ValueObjectVariable.h"
 #include "lldb/DataFormatters/DataVisualization.h"
 #include "lldb/DataFormatters/FormatClasses.h" // for TypeNameSpecifier...
 #include "lldb/DataFormatters/FormatManager.h"
 #include "lldb/DataFormatters/TypeSummary.h" // for TypeSummaryImpl::...
 #include "lldb/Expression/ExpressionVariable.h"
+#include "lldb/Host/FileSpec.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Symbol/Block.h"
 #include "lldb/Symbol/CompileUnit.h"
 #include "lldb/Symbol/CompilerType.h" // for CompilerType
 #include "lldb/Symbol/Function.h"
 #include "lldb/Symbol/LineEntry.h"
 #include "lldb/Symbol/Symbol.h"
 #include "lldb/Symbol/SymbolContext.h" // for SymbolContext
 #include "lldb/Symbol/VariableList.h"
 #include "lldb/Target/ExecutionContext.h"
 #include "lldb/Target/ExecutionContextScope.h" // for ExecutionContextS...
 #include "lldb/Target/Language.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/RegisterContext.h"
 #include "lldb/Target/SectionLoadList.h"
 #include "lldb/Target/StackFrame.h"
 #include "lldb/Target/StopInfo.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/AnsiTerminal.h"
-#include "lldb/Utility/ArchSpec.h"    // for ArchSpec
-#include "lldb/Utility/ConstString.h" // for ConstString, oper...
-#include "lldb/Utility/FileSpec.h"
+#include "lldb/Utility/ArchSpec.h"      // for ArchSpec
+#include "lldb/Utility/ConstString.h"   // for ConstString, oper...
 #include "lldb/Utility/Log.h"           // for Log
 #include "lldb/Utility/Logging.h"       // for GetLogIfAllCatego...
 #include "lldb/Utility/RegisterValue.h" // for RegisterValue
 #include "lldb/Utility/SharingPtr.h"    // for SharingPtr
 #include "lldb/Utility/Stream.h"
 #include "lldb/Utility/StreamString.h"
 #include "lldb/Utility/StringList.h"     // for StringList
 #include "lldb/Utility/StructuredData.h" // for StructuredData::O...

source/Core/Module.cpp

if (!modules_specs.FindMatchingModuleSpec(module_spec,
                                             matching_module_spec)) {
     if (log) {
       log->Printf("Found local object file but the specs didn't match");
     }
     return;
   }
 
   if (module_spec.GetFileSpec())
-    m_mod_time = FileSystem::GetModificationTime(module_spec.GetFileSpec());
-  else if (matching_module_spec.GetFileSpec())
     m_mod_time =
-        FileSystem::GetModificationTime(matching_module_spec.GetFileSpec());
+        FileSystem::Instance().GetModificationTime(module_spec.GetFileSpec());
+  else if (matching_module_spec.GetFileSpec())
+    m_mod_time = FileSystem::Instance().GetModificationTime(
+        matching_module_spec.GetFileSpec());
 
   // Copy the architecture from the actual spec if we got one back, else use
   // the one that was specified
   if (matching_module_spec.GetArchitecture().IsValid())
     m_arch = matching_module_spec.GetArchitecture();
   else if (module_spec.GetArchitecture().IsValid())
     m_arch = module_spec.GetArchitecture();
 
Module::Module(const ModuleSpec &module_spec)
   // specification
   m_object_offset = matching_module_spec.GetObjectOffset();
   m_object_mod_time = matching_module_spec.GetObjectModificationTime();
 }
 
 Module::Module(const FileSpec &file_spec, const ArchSpec &arch,
                const ConstString *object_name, lldb::offset_t object_offset,
                const llvm::sys::TimePoint<> &object_mod_time)
-    : m_mod_time(FileSystem::GetModificationTime(file_spec)), m_arch(arch),
-      m_file(file_spec), m_object_offset(object_offset),
+    : m_mod_time(FileSystem::Instance().GetModificationTime(file_spec)),
+      m_arch(arch), m_file(file_spec), m_object_offset(object_offset),
       m_object_mod_time(object_mod_time), m_file_has_changed(false),
       m_first_file_changed_log(false) {
   // Scope for locker below...
   {
     std::lock_guard<std::recursive_mutex> guard(
         GetAllocationModuleCollectionMutex());
     GetModuleCollection().push_back(this);
   }
SymbolVendor *Module::GetSymbolVendor(bool can_create,
   return m_symfile_ap.get();
 }
 
 void Module::SetFileSpecAndObjectName(const FileSpec &file,
                                       const ConstString &object_name) {
   // Container objects whose paths do not specify a file directly can call this
   // function to correct the file and object names.
   m_file = file;
-  m_mod_time = FileSystem::GetModificationTime(file);
+  m_mod_time = FileSystem::Instance().GetModificationTime(file);
   m_object_name = object_name;
 }
 
 const ArchSpec &Module::GetArchitecture() const { return m_arch; }
 
 std::string Module::GetSpecificationDescription() const {
   std::string spec(GetFileSpec().GetPath());
   if (m_object_name) {
if (format && format[0]) {
     }
     Host::SystemLog(Host::eSystemLogError, "%s", strm.GetData());
   }
 }
 
 bool Module::FileHasChanged() const {
   if (!m_file_has_changed)
     m_file_has_changed =
-        (FileSystem::GetModificationTime(m_file) != m_mod_time);
+        (FileSystem::Instance().GetModificationTime(m_file) != m_mod_time);
   return m_file_has_changed;
 }
 
 void Module::ReportErrorIfModifyDetected(const char *format, ...) {
   if (!m_first_file_changed_log) {
     if (FileHasChanged()) {
       m_first_file_changed_log = true;
       if (format) {

source/Core/ModuleList.cpp

if (located_binary_modulespec.GetFileSpec() != module_file_spec) {
     ModuleList matching_module_list;
     if (shared_module_list.FindModules(platform_module_spec,
                                        matching_module_list) > 0) {
       module_sp = matching_module_list.GetModuleAtIndex(0);
 
       // If we didn't have a UUID in mind when looking for the object file,
       // then we should make sure the modification time hasn't changed!
       if (platform_module_spec.GetUUIDPtr() == nullptr) {
-        auto file_spec_mod_time = FileSystem::GetModificationTime(
+        auto file_spec_mod_time = FileSystem::Instance().GetModificationTime(
             located_binary_modulespec.GetFileSpec());
         if (file_spec_mod_time != llvm::sys::TimePoint<>()) {
           if (file_spec_mod_time != module_sp->GetModificationTime()) {
             if (old_module_sp_ptr)
               *old_module_sp_ptr = module_sp;
             shared_module_list.Remove(module_sp);
             module_sp.reset();
           }

source/Core/PluginManager.cpp

 //===-- PluginManager.cpp ---------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Core/PluginManager.h"
 
 #include "lldb/Core/Debugger.h"
+#include "lldb/Host/FileSpec.h"
+#include "lldb/Host/FileSystem.h"
 #include "lldb/Host/HostInfo.h"
 #include "lldb/Interpreter/OptionValueProperties.h"
 #include "lldb/Utility/ConstString.h" // for ConstString
-#include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/StringList.h" // for StringList
 
 #if defined(_WIN32)
 #include "lldb/Host/windows/PosixApi.h" // for PATH_MAX
 #endif
 
 #include "llvm/ADT/StringRef.h"
static void SetPluginInfo(const FileSpec &plugin_file_spec,
   assert(plugin_map.find(plugin_file_spec) == plugin_map.end());
   plugin_map[plugin_file_spec] = plugin_info;
 }
 
 template <typename FPtrTy> static FPtrTy CastToFPtr(void *VPtr) {
   return reinterpret_cast<FPtrTy>(reinterpret_cast<intptr_t>(VPtr));
 }
 
-static FileSpec::EnumerateDirectoryResult
+static FileSystem::EnumerateDirectoryResult
 LoadPluginCallback(void *baton, llvm::sys::fs::file_type ft,
-                   const FileSpec &file_spec) {
+                   llvm::StringRef path) {
   //    PluginManager *plugin_manager = (PluginManager *)baton;
   Status error;
 
   namespace fs = llvm::sys::fs;
   // If we have a regular file, a symbolic link or unknown file type, try and
   // process the file. We must handle unknown as sometimes the directory
   // enumeration might be enumerating a file system that doesn't have correct
   // file type information.
   if (ft == fs::file_type::regular_file || ft == fs::file_type::symlink_file ||
       ft == fs::file_type::type_unknown) {
-    FileSpec plugin_file_spec(file_spec);
+    FileSpec plugin_file_spec(path, false);
     plugin_file_spec.ResolvePath();
 
     if (PluginIsLoaded(plugin_file_spec))
-      return FileSpec::eEnumerateDirectoryResultNext;
+      return FileSystem::eEnumerateDirectoryResultNext;
     else {
       PluginInfo plugin_info;
 
       std::string pluginLoadError;
       plugin_info.library = llvm::sys::DynamicLibrary::getPermanentLibrary(
           plugin_file_spec.GetPath().c_str(), &pluginLoadError);
       if (plugin_info.library.isValid()) {
         bool success = false;
else {
           // instance to invalidate it.
           plugin_info = PluginInfo();
         }
 
         // Regardless of success or failure, cache the plug-in load in our
         // plug-in info so we don't try to load it again and again.
         SetPluginInfo(plugin_file_spec, plugin_info);
 
-        return FileSpec::eEnumerateDirectoryResultNext;
+        return FileSystem::eEnumerateDirectoryResultNext;
       }
     }
   }
 
   if (ft == fs::file_type::directory_file ||
       ft == fs::file_type::symlink_file || ft == fs::file_type::type_unknown) {
     // Try and recurse into anything that a directory or symbolic link. We must
     // also do this for unknown as sometimes the directory enumeration might be
     // enumerating a file system that doesn't have correct file type
     // information.
-    return FileSpec::eEnumerateDirectoryResultEnter;
+    return FileSystem::eEnumerateDirectoryResultEnter;
   }
 
-  return FileSpec::eEnumerateDirectoryResultNext;
+  return FileSystem::eEnumerateDirectoryResultNext;
 }
 
 void PluginManager::Initialize() {
 #if 1
   const bool find_directories = true;
   const bool find_files = true;
   const bool find_other = true;
   char dir_path[PATH_MAX];
   if (FileSpec dir_spec = HostInfo::GetSystemPluginDir()) {
     if (dir_spec.Exists() && dir_spec.GetPath(dir_path, sizeof(dir_path))) {
-      FileSpec::EnumerateDirectory(dir_path, find_directories, find_files,
-                                   find_other, LoadPluginCallback, nullptr);
+      FileSystem::Instance().EnumerateDirectory(dir_path, find_directories,
+                                                find_files, find_other,
+                                                LoadPluginCallback, nullptr);
     }
   }
 
   if (FileSpec dir_spec = HostInfo::GetUserPluginDir()) {
     if (dir_spec.Exists() && dir_spec.GetPath(dir_path, sizeof(dir_path))) {
-      FileSpec::EnumerateDirectory(dir_path, find_directories, find_files,
-                                   find_other, LoadPluginCallback, nullptr);
+      FileSystem::Instance().EnumerateDirectory(dir_path, find_directories,
+                                                find_files, find_other,
+                                                LoadPluginCallback, nullptr);
     }
   }
 #endif
 }
 
 void PluginManager::Terminate() {
   std::lock_guard<std::recursive_mutex> guard(GetPluginMapMutex());
   PluginTerminateMap &plugin_map = GetPluginMap();

source/Core/Section.cpp

 //===-- Section.cpp ---------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Core/Section.h"
 #include "lldb/Core/Address.h" // for Address
 #include "lldb/Core/Module.h"
+#include "lldb/Host/FileSpec.h" // for FileSpec
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Target/SectionLoadList.h"
 #include "lldb/Target/Target.h"
-#include "lldb/Utility/FileSpec.h" // for FileSpec
-#include "lldb/Utility/Stream.h"   // for Stream
-#include "lldb/Utility/VMRange.h"  // for VMRange
+#include "lldb/Utility/Stream.h"  // for Stream
+#include "lldb/Utility/VMRange.h" // for VMRange
 
 #include <inttypes.h> // for PRIx64
 #include <limits>     // for numeric_limits
 #include <utility>    // for distance
 
 namespace lldb_private {
 class DataExtractor;
 }

source/Core/SourceManager.cpp

if (!file_sp)
     return;
   return file_sp->FindLinesMatchingRegex(regex, start_line, end_line,
                                          match_lines);
 }
 
 SourceManager::File::File(const FileSpec &file_spec,
                           lldb::DebuggerSP debugger_sp)
     : m_file_spec_orig(file_spec), m_file_spec(file_spec),
-      m_mod_time(FileSystem::GetModificationTime(file_spec)),
+      m_mod_time(FileSystem::Instance().GetModificationTime(file_spec)),
       m_debugger_wp(debugger_sp) {
   CommonInitializer(file_spec, nullptr);
 }
 
 SourceManager::File::File(const FileSpec &file_spec, Target *target)
     : m_file_spec_orig(file_spec), m_file_spec(file_spec),
-      m_mod_time(FileSystem::GetModificationTime(file_spec)),
+      m_mod_time(FileSystem::Instance().GetModificationTime(file_spec)),
       m_debugger_wp(target ? target->GetDebugger().shared_from_this()
                            : DebuggerSP()) {
   CommonInitializer(file_spec, target);
 }
 
 void SourceManager::File::CommonInitializer(const FileSpec &file_spec,
                                             Target *target) {
   if (m_mod_time == llvm::sys::TimePoint<>()) {
if (target) {
                   test_cu_spec = sc.comp_unit;
               }
             }
           }
           if (!got_multiple) {
             SymbolContext sc;
             sc_list.GetContextAtIndex(0, sc);
             m_file_spec = sc.comp_unit;
-            m_mod_time = FileSystem::GetModificationTime(m_file_spec);
+            m_mod_time =
+                FileSystem::Instance().GetModificationTime(m_file_spec);
           }
         }
       }
       // Try remapping if m_file_spec does not correspond to an existing file.
       if (!m_file_spec.Exists()) {
         FileSpec new_file_spec;
         // Check target specific source remappings first, then fall back to
         // modules objects can have individual path remappings that were
         // detected when the debug info for a module was found. then
         if (target->GetSourcePathMap().FindFile(m_file_spec, new_file_spec) ||
             target->GetImages().FindSourceFile(m_file_spec, new_file_spec)) {
           m_file_spec = new_file_spec;
-          m_mod_time = FileSystem::GetModificationTime(m_file_spec);
+          m_mod_time = FileSystem::Instance().GetModificationTime(m_file_spec);
         }
       }
     }
   }
 
   if (m_mod_time != llvm::sys::TimePoint<>())
     m_data_sp = DataBufferLLVM::CreateFromPath(m_file_spec.GetPath());
 }
if (CalculateLineOffsets(line))
     return line < m_offsets.size();
   return false;
 }
 
 void SourceManager::File::UpdateIfNeeded() {
   // TODO: use host API to sign up for file modifications to anything in our
   // source cache and only update when we determine a file has been updated.
   // For now we check each time we want to display info for the file.
-  auto curr_mod_time = FileSystem::GetModificationTime(m_file_spec);
+  auto curr_mod_time = FileSystem::Instance().GetModificationTime(m_file_spec);
 
   if (curr_mod_time != llvm::sys::TimePoint<>() &&
       m_mod_time != curr_mod_time) {
     m_mod_time = curr_mod_time;
     m_data_sp = DataBufferLLVM::CreateFromPath(m_file_spec.GetPath());
     m_offsets.clear();
   }
 }

source/Core/Value.cpp

 //===-- Value.cpp -----------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Core/Value.h"
 
 #include "lldb/Core/Address.h" // for Address
 #include "lldb/Core/Module.h"
+#include "lldb/Host/FileSpec.h" // for FileSpec
 #include "lldb/Symbol/CompilerType.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/SymbolContext.h"
 #include "lldb/Symbol/Type.h"
 #include "lldb/Symbol/Variable.h"
 #include "lldb/Target/ExecutionContext.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/SectionLoadList.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/ConstString.h" // for ConstString
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/DataExtractor.h"
-#include "lldb/Utility/Endian.h"   // for InlHostByteOrder
-#include "lldb/Utility/FileSpec.h" // for FileSpec
+#include "lldb/Utility/Endian.h" // for InlHostByteOrder
 #include "lldb/Utility/State.h"
 #include "lldb/Utility/Stream.h"
 #include "lldb/lldb-defines.h" // for LLDB_INVALID_ADDRESS
 #include "lldb/lldb-forward.h" // for DataBufferSP, ModuleSP
 #include "lldb/lldb-types.h"   // for addr_t
 
 #include <memory> // for make_shared
 #include <string> // for string

source/Host/CMakeLists.txt

macro(remove_module_flags)
   string(REGEX REPLACE "-fmodules-cache-path=[^ ]+" "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
   string(REGEX REPLACE "-fmodules" "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
   string(REGEX REPLACE "-fcxx-modules" "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
 endmacro()
 
 add_host_subdirectory(common
   common/File.cpp
   common/FileCache.cpp
+  common/FileSpec.cpp
   common/FileSystem.cpp
   common/GetOptInc.cpp
   common/Host.cpp
   common/HostInfoBase.cpp
   common/HostNativeThreadBase.cpp
   common/HostProcess.cpp
   common/HostThread.cpp
   common/LockFileBase.cpp

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/FileSpec.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"
 
 #include "llvm/Support/FileSystem.h"

source/Host/common/File.cpp

 #endif
 
 #include "llvm/Support/ConvertUTF.h"
 #include "llvm/Support/Errno.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Process.h" // for llvm::sys::Process::FileDescriptorHasColors()
 
 #include "lldb/Host/Config.h"
+#include "lldb/Host/FileSpec.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Utility/DataBufferHeap.h"
-#include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/Log.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 static const char *GetStreamOpenModeFromOptions(uint32_t options) {
   if (options & File::eOpenOptionAppend) {
     if (options & File::eOpenOptionRead) {

source/Host/common/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/Host/FileSpec.h"
+#include "lldb/Host/FileSystem.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"

 bool needsNormalization(const llvm::StringRef &path) {
   if (path.empty())
     return false;
   // We strip off leading "." values so these paths need to be normalized
   if (path[0] == '.')
     return true;
   for (auto i = path.find_first_of("\\/"); i != llvm::StringRef::npos;
        i = path.find_first_of("\\/", i + 1)) {
-    const auto next = safeCharAtIndex(path, i+1);
+    const auto next = safeCharAtIndex(path, i + 1);
     switch (next) {
-      case 0:
-        // path separator char at the end of the string which should be
-        // stripped unless it is the one and only character
-        return i > 0;
-      case '/':
-      case '\\':
-        // two path separator chars in the middle of a path needs to be
-        // normalized
-        if (i > 0)
-          return true;
-        ++i;
-        break;
 
-      case '.': {
-          const auto next_next = safeCharAtIndex(path, i+2);
-          switch (next_next) {
-            default: break;
-            case 0: return true; // ends with "/."
-            case '/':
-            case '\\':
-              return true; // contains "/./"
-            case '.': {
-              const auto next_next_next = safeCharAtIndex(path, i+3);
-              switch (next_next_next) {
-                default: break;
-                case 0: return true; // ends with "/.."
-                case '/':
-                case '\\':
-                  return true; // contains "/../"
-              }
-              break;
-            }
-          }
-        }
-        break;
+      const auto next_next = safeCharAtIndex(path, i + 2);
+      default:
+        break;
+      case 0:
+        return true; // ends with "/."
+        const auto next_next_next = safeCharAtIndex(path, i + 3);
+        default:
+          break;
+        case 0:
+          return true; // ends with "/.."
+    } break;
 
-      default:
-        break;
     }
   }
   return false;
 }
 
-
-}
+} // namespace
 //------------------------------------------------------------------
 // Assignment operator.
 //------------------------------------------------------------------
 const FileSpec &FileSpec::operator=(const FileSpec &rhs) {
   if (this != &rhs) {
     m_directory = rhs.m_directory;
     m_filename = rhs.m_filename;
     m_is_resolved = rhs.m_is_resolved;
if (resolved.empty()) {
     // 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())
+  if (!filename.empty())
     m_filename.SetString(filename);
   llvm::StringRef directory = llvm::sys::path::parent_path(resolved, m_style);
-  if(!directory.empty())
+  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);
 }
int FileSpec::Compare(const FileSpec &a, const FileSpec &b, bool full) {
   }
   return ConstString::Compare(a.m_filename, b.m_filename, case_sensitive);
 }
 
 bool FileSpec::Equal(const FileSpec &a, const FileSpec &b, bool full) {
   // case sensitivity of equality test
   const bool case_sensitive = a.IsCaseSensitive() || b.IsCaseSensitive();
 
-  const bool filenames_equal = ConstString::Equals(a.m_filename,
-                                                   b.m_filename,
-                                                   case_sensitive);
+  const bool filenames_equal =
+      ConstString::Equals(a.m_filename, b.m_filename, case_sensitive);
 
   if (!filenames_equal)
     return false;
 
   if (!full && (a.GetDirectory().IsEmpty() || b.GetDirectory().IsEmpty()))
     return filenames_equal;
 
   return a == b;
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;
 }
 
 uint64_t FileSpec::GetByteSize() const {
-  uint64_t Size = 0;
-  if (llvm::sys::fs::file_size(GetPath(), Size))
-    return 0;
-  return Size;
+  return FileSystem::Instance().GetByteSize(GetPath());
 }
 
 FileSpec::Style FileSpec::GetPathStyle() const { return m_style; }
 
 uint32_t FileSpec::GetPermissions() const {
-  namespace fs = llvm::sys::fs;
-  fs::file_status st;
-  if (fs::status(GetPath(), st, false))
-    return fs::perms::perms_not_known;
-
-  return st.permissions();
+  return FileSystem::Instance().GetPermissions(GetPath());
 }
 
 //------------------------------------------------------------------
 // Directory string get accessor.
 //------------------------------------------------------------------
 ConstString &FileSpec::GetDirectory() { return m_directory; }
 
 //------------------------------------------------------------------

 //------------------------------------------------------------------
 // Return the size in bytes that this object takes in memory. This returns the
 // size in bytes of this object, not any shared string values it may refer to.
 //------------------------------------------------------------------
 size_t FileSpec::MemorySize() const {
   return m_filename.MemorySize() + m_directory.MemorySize();
 }
 
-void FileSpec::EnumerateDirectory(llvm::StringRef dir_path,
-                                  bool find_directories, bool find_files,
-                                  bool find_other,
-                                  EnumerateDirectoryCallbackType callback,
-                                  void *callback_baton) {
-  namespace fs = llvm::sys::fs;
-  std::error_code EC;
-  fs::recursive_directory_iterator Iter(dir_path, EC);
-  fs::recursive_directory_iterator End;
-  for (; Iter != End && !EC; Iter.increment(EC)) {
-    const auto &Item = *Iter;
-    llvm::ErrorOr<fs::basic_file_status> Status = Item.status();
-    if (!Status)
-      break;
-    if (!find_files && fs::is_regular_file(*Status))
-      continue;
-    if (!find_directories && fs::is_directory(*Status))
-      continue;
-    if (!find_other && fs::is_other(*Status))
-      continue;
-
-    FileSpec Spec(Item.path(), false);
-    auto Result = callback(callback_baton, Status->type(), Spec);
-    if (Result == eEnumerateDirectoryResultQuit)
-      return;
-    if (Result == eEnumerateDirectoryResultNext) {
-      // Default behavior is to recurse.  Opt out if the callback doesn't want
-      // this behavior.
-      Iter.no_push();
-    }
-  }
-}
-
 FileSpec
 FileSpec::CopyByAppendingPathComponent(llvm::StringRef component) const {
   FileSpec ret = *this;
   ret.AppendPathComponent(component);
   return ret;
 }
 
 FileSpec FileSpec::CopyByRemovingLastPathComponent() const {
bool FileSpec::IsSourceImplementationFile() const {
   static RegularExpression g_source_file_regex(llvm::StringRef(
       "^.([cC]|[mM]|[mM][mM]|[cC][pP][pP]|[cC]\\+\\+|[cC][xX][xX]|[cC][cC]|["
       "cC][pP]|[sS]|[aA][sS][mM]|[fF]|[fF]77|[fF]90|[fF]95|[fF]03|[fF][oO]["
       "rR]|[fF][tT][nN]|[fF][pP][pP]|[aA][dD][aA]|[aA][dD][bB]|[aA][dD][sS])"
       "$"));
   return g_source_file_regex.Execute(extension.GetStringRef());
 }
 
-bool FileSpec::IsRelative() const {
-  return !IsAbsolute();
-}
+bool FileSpec::IsRelative() const { return !IsAbsolute(); }
 
 bool FileSpec::IsAbsolute() const {
   llvm::SmallString<64> current_path;
   GetPath(current_path, false);
 
   // Early return if the path is empty.
   if (current_path.empty())
     return false;

source/Host/common/FileSystem.cpp

 //===-- FileSystem.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/Host/FileSystem.h"
 
 #include "llvm/Support/FileSystem.h"
+#include "llvm/Support/Threading.h"
 
 #include <algorithm>
 #include <fstream>
 #include <vector>
 
 using namespace lldb;
 using namespace lldb_private;
+using namespace llvm;
+
+FileSystem &FileSystem::Instance() {
+  static FileSystem *g_fs;
+  static llvm::once_flag g_once_flag;
+  llvm::call_once(g_once_flag, []() {
+    if (g_fs == nullptr)
+      g_fs = new FileSystem();
+  });
+  return *g_fs;
+}
+
+void FileSystem::ChangeFileSystem(IntrusiveRefCntPtr<vfs::FileSystem> fs) {
+  m_fs = fs;
+}
 
 llvm::sys::TimePoint<>
-FileSystem::GetModificationTime(const FileSpec &file_spec) {
-  llvm::sys::fs::file_status status;
-  std::error_code ec = llvm::sys::fs::status(file_spec.GetPath(), status);
-  if (ec)
+FileSystem::GetModificationTime(const FileSpec &file_spec) const {
+  return GetModificationTime(file_spec.GetPath());
+}
+
+llvm::sys::TimePoint<>
+FileSystem::GetModificationTime(const Twine &path) const {
+  llvm::ErrorOr<llvm::vfs::Status> status = m_fs->status(path);
+  if (!status)
     return llvm::sys::TimePoint<>();
-  return status.getLastModificationTime();
+  return status->getLastModificationTime();
+}
+
+uint64_t FileSystem::GetByteSize(const FileSpec &file_spec) const {
+  return GetByteSize(file_spec.GetPath());
+}
+
+uint64_t FileSystem::GetByteSize(const Twine &path) const {
+  llvm::ErrorOr<llvm::vfs::Status> status = m_fs->status(path);
+  if (!status)
+    return 0;
+  return status->getSize();
+}
+
+uint32_t FileSystem::GetPermissions(const FileSpec &file_spec) const {
+  return GetPermissions(file_spec.GetPath());
+}
+
+uint32_t FileSystem::GetPermissions(const Twine &path) const {
+  llvm::ErrorOr<llvm::vfs::Status> status = m_fs->status(path);
+  if (!status)
+    return llvm::sys::fs::perms::perms_not_known;
+  return status->getPermissions();
+}
+
+bool FileSystem::Exists(const llvm::Twine &path) const {
+  return m_fs->exists(path);
+}
+
+bool FileSystem::Exists(const FileSpec &file_spec) const {
+  return Exists(file_spec.GetPath());
+}
+
+void FileSystem::EnumerateDirectory(Twine path, bool find_directories,
+                                    bool find_files, bool find_other,
+                                    EnumerateDirectoryCallbackType callback,
+                                    void *callback_baton) {
+  std::error_code EC;
+  llvm::vfs::recursive_directory_iterator Iter(*m_fs, path, EC);
+  llvm::vfs::recursive_directory_iterator End;
+  for (; Iter != End && !EC; Iter.increment(EC)) {
+    const auto &Item = *Iter;
+    llvm::ErrorOr<llvm::vfs::Status> Status = m_fs->status(Item.path());
+    if (!Status)
+      break;
+    if (!find_files && Status->isRegularFile())
+      continue;
+    if (!find_directories && Status->isDirectory())
+      continue;
+    if (!find_other && Status->isOther())
+      continue;
+
+    auto Result = callback(callback_baton, Status->getType(), Item.path());
+    if (Result == eEnumerateDirectoryResultQuit)
+      return;
+    if (Result == eEnumerateDirectoryResultNext) {
+      // Default behavior is to recurse. Opt out if the callback doesn't want
+      // this behavior.
+      Iter.no_push();
+    }
+  }
+}
+
+std::error_code FileSystem::MakeAbsolute(SmallVectorImpl<char> &path) const {
+  return m_fs->makeAbsolute(path);
+}
+
+std::error_code FileSystem::MakeAbsolute(FileSpec &file_spec) const {
+  llvm::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());
+  file_spec = new_file_spec;
+  return {};
+}
+
+std::error_code
+FileSystem::GetRealPath(const llvm::Twine &path,
+                        llvm::SmallVectorImpl<char> &output) const {
+  return m_fs->getRealPath(path, output);
 }

source/Host/common/Host.cpp

 
 #if defined(__NetBSD__)
 #include <lwp.h>
 #endif
 
 // C++ Includes
 #include <csignal>
 
+#include "lldb/Host/FileSpec.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Host/HostInfo.h"
 #include "lldb/Host/HostProcess.h"
 #include "lldb/Host/MonitoringProcessLauncher.h"
 #include "lldb/Host/ProcessLauncher.h"
 #include "lldb/Host/ThreadLauncher.h"
 #include "lldb/Host/posix/ConnectionFileDescriptorPosix.h"
 #include "lldb/Target/FileAction.h"
 #include "lldb/Target/ProcessLaunchInfo.h"
 #include "lldb/Target/UnixSignals.h"
 #include "lldb/Utility/DataBufferLLVM.h"
-#include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/Predicate.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/lldb-private-forward.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/Support/Errno.h"
 #include "llvm/Support/FileSystem.h"

source/Host/macosx/objcxx/Host.mm

 #include <stdlib.h>
 #include <sys/proc.h>
 #include <sys/stat.h>
 #include <sys/sysctl.h>
 #include <sys/types.h>
 #include <unistd.h>
 
 #include "lldb/Host/ConnectionFileDescriptor.h"
+#include "lldb/Host/FileSpec.h"
 #include "lldb/Host/HostInfo.h"
 #include "lldb/Host/ThreadLauncher.h"
-#include "lldb/Target/ProcessLaunchInfo.h"
 #include "lldb/Target/Process.h"
+#include "lldb/Target/ProcessLaunchInfo.h"
 #include "lldb/Utility/ArchSpec.h"
 #include "lldb/Utility/CleanUp.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/DataExtractor.h"
 #include "lldb/Utility/Endian.h"
-#include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/NameMatches.h"
 #include "lldb/Utility/StreamString.h"
 #include "lldb/Utility/StructuredData.h"
 #include "lldb/lldb-defines.h"
 
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Errno.h"

source/Host/posix/ProcessLauncherPosixFork.cpp

 //===-- ProcessLauncherLinux.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/Host/posix/ProcessLauncherPosixFork.h"
+#include "lldb/Host/FileSpec.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Host/HostProcess.h"
 #include "lldb/Host/Pipe.h"
 #include "lldb/Target/ProcessLaunchInfo.h"
-#include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/Log.h"
 #include "llvm/Support/Errno.h"
 
 #include <limits.h>
 #include <sys/ptrace.h>
 #include <sys/wait.h>
 #include <unistd.h>
 

source/Host/windows/HostProcessWindows.cpp

 //===-- HostProcessWindows.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/Host/windows/HostProcessWindows.h"
+#include "lldb/Host/FileSpec.h"
 #include "lldb/Host/HostThread.h"
 #include "lldb/Host/ThreadLauncher.h"
 #include "lldb/Host/windows/windows.h"
-#include "lldb/Utility/FileSpec.h"
 
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/Support/ConvertUTF.h"
 
 #include <psapi.h>
 
 using namespace lldb_private;
 

source/Interpreter/CommandObject.cpp

 #include "lldb/Core/Address.h"
 #include "lldb/Interpreter/Options.h"
 #include "lldb/Utility/ArchSpec.h"
 
 // These are for the Sourcename completers.
 // FIXME: Make a separate file for the completers.
 #include "lldb/Core/FileSpecList.h"
 #include "lldb/DataFormatters/FormatManager.h"
+#include "lldb/Host/FileSpec.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Target.h"
-#include "lldb/Utility/FileSpec.h"
 
 #include "lldb/Target/Language.h"
 
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Interpreter/CommandReturnObject.h"
 
 using namespace lldb;
 using namespace lldb_private;

source/Interpreter/OptionValueFileSpec.cpp

size_t OptionValueFileSpec::AutoComplete(CommandInterpreter &interpreter,
   request.SetWordComplete(false);
   CommandCompletions::InvokeCommonCompletionCallbacks(
       interpreter, m_completion_mask, request, nullptr);
   return request.GetNumberOfMatches();
 }
 
 const lldb::DataBufferSP &OptionValueFileSpec::GetFileContents() {
   if (m_current_value) {
-    const auto file_mod_time = FileSystem::GetModificationTime(m_current_value);
+    const auto file_mod_time =
+        FileSystem::Instance().GetModificationTime(m_current_value);
     if (m_data_sp && m_data_mod_time == file_mod_time)
       return m_data_sp;
     m_data_sp = DataBufferLLVM::CreateFromPath(m_current_value.GetPath());
     m_data_mod_time = file_mod_time;
   }
   return m_data_sp;
 }

source/Interpreter/OptionValuePathMappings.cpp

 //===-- OptionValuePathMappings.cpp -----------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Interpreter/OptionValuePathMappings.h"
 
 // C Includes
 // C++ Includes
 // Other libraries and framework includes
 // Project includes
+#include "lldb/Host/FileSpec.h"
 #include "lldb/Host/StringConvert.h"
 #include "lldb/Utility/Args.h"
-#include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/Stream.h"
 
 using namespace lldb;
 using namespace lldb_private;
 namespace {
 static bool VerifyPathExists(const char *path) {
   if (path && path[0])
     return FileSpec(path, false).Exists();

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

 #include <string>
 #include <vector>
 
 // Other libraries and framework includes
 
 #include "lldb/Host/SafeMachO.h"
 
 // Project includes
+#include "lldb/Host/FileSpec.h"
 #include "lldb/Target/DynamicLoader.h"
 #include "lldb/Target/Process.h"
-#include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/UUID.h"
 
 class DynamicLoaderDarwinKernel : public lldb_private::DynamicLoader {
 public:
   DynamicLoaderDarwinKernel(lldb_private::Process *process,
                             lldb::addr_t kernel_addr);
 
   ~DynamicLoaderDarwinKernel() override;

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

 // C Includes
 // C++ Includes
 #include <map>
 #include <mutex>
 #include <vector>
 
 // Other libraries and framework includes
 // Project includes
+#include "lldb/Host/FileSpec.h"
 #include "lldb/Host/SafeMachO.h"
 #include "lldb/Target/DynamicLoader.h"
 #include "lldb/Target/Process.h"
-#include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/StructuredData.h"
 #include "lldb/Utility/UUID.h"
 
 #include "llvm/ADT/Triple.h"
 
 namespace lldb_private {
 
 class DynamicLoaderDarwin : public lldb_private::DynamicLoader {

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

ModuleSP DynamicLoaderDarwin::FindTargetModuleForImageInfo(
   module_spec.GetUUID() = image_info.uuid;
   ModuleSP module_sp(target_images.FindFirstModule(module_spec));
 
   if (module_sp && !module_spec.GetUUID().IsValid() &&
       !module_sp->GetUUID().IsValid()) {
     // No UUID, we must rely upon the cached module modification time and the
     // modification time of the file on disk
     if (module_sp->GetModificationTime() !=
-        FileSystem::GetModificationTime(module_sp->GetFileSpec()))
+        FileSystem::Instance().GetModificationTime(module_sp->GetFileSpec()))
       module_sp.reset();
   }
 
   if (!module_sp) {
     if (can_create) {
       module_sp = target.GetSharedModule(module_spec);
       if (!module_sp || module_sp->GetObjectFile() == NULL)
         module_sp = m_process->ReadModuleFromMemory(image_info.file_spec,

source/Plugins/DynamicLoader/MacOSX-DYLD/DynamicLoaderMacOS.h

 
 // C Includes
 // C++ Includes
 #include <mutex>
 #include <vector>
 
 // Other libraries and framework includes
 // Project includes
+#include "lldb/Host/FileSpec.h"
 #include "lldb/Target/DynamicLoader.h"
 #include "lldb/Target/Process.h"
-#include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/StructuredData.h"
 #include "lldb/Utility/UUID.h"
 
 #include "DynamicLoaderDarwin.h"
 
 class DynamicLoaderMacOS : public lldb_private::DynamicLoaderDarwin {
 public:
   DynamicLoaderMacOS(lldb_private::Process *process);

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

 
 // C Includes
 // C++ Includes
 #include <mutex>
 #include <vector>
 
 // Other libraries and framework includes
 // Project includes
+#include "lldb/Host/FileSpec.h"
 #include "lldb/Host/SafeMachO.h"
 #include "lldb/Target/DynamicLoader.h"
 #include "lldb/Target/Process.h"
-#include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/StructuredData.h"
 #include "lldb/Utility/UUID.h"
 
 #include "DynamicLoaderDarwin.h"
 
 class DynamicLoaderMacOSXDYLD : public lldb_private::DynamicLoaderDarwin {
 public:
   DynamicLoaderMacOSXDYLD(lldb_private::Process *process);

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

 #define liblldb_Rendezvous_H_
 
 // C Includes
 // C++ Includes
 #include <list>
 #include <string>
 
 // Other libraries and framework includes
-#include "lldb/Utility/FileSpec.h"
+#include "lldb/Host/FileSpec.h"
 #include "lldb/lldb-defines.h"
 #include "lldb/lldb-types.h"
 
 #include "lldb/Core/LoadedModuleInfoList.h"
 
 using lldb_private::LoadedModuleInfoList;
 
 namespace lldb_private {

source/Plugins/DynamicLoader/Static/DynamicLoaderStatic.h

 //===-- DynamicLoaderStatic.h -----------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_DynamicLoaderStatic_h_
 #define liblldb_DynamicLoaderStatic_h_
 
 // C Includes
 // C++ Includes
 // Other libraries and framework includes
 // Project includes
+#include "lldb/Host/FileSpec.h"
 #include "lldb/Target/DynamicLoader.h"
 #include "lldb/Target/Process.h"
-#include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/UUID.h"
 
 class DynamicLoaderStatic : public lldb_private::DynamicLoader {
 public:
   DynamicLoaderStatic(lldb_private::Process *process);
 
   ~DynamicLoaderStatic() override;
 

source/Plugins/ExpressionParser/Clang/ClangHost.cpp

 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Threading.h"
 
 // Project includes
 #include "lldb/Host/HostInfo.h"
 #if !defined(_WIN32)
 #include "lldb/Host/posix/HostInfoPosix.h"
 #endif
-#include "lldb/Utility/FileSpec.h"
+#include "lldb/Host/FileSpec.h"
 #include "lldb/Utility/Log.h"
 
 #include <string>
 
 using namespace lldb_private;
 
 #if defined(_WIN32)
 static bool ComputeClangDirectory(FileSpec &file_spec) { return false; }

source/Plugins/ExpressionParser/Clang/ClangModulesDeclVendor.cpp

 #include "llvm/Support/Path.h"
 #include "llvm/Support/Threading.h"
 
 // Project includes
 #include "ClangHost.h"
 #include "ClangModulesDeclVendor.h"
 
 #include "lldb/Core/ModuleList.h"
+#include "lldb/Host/FileSpec.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Host/HostInfo.h"
 #include "lldb/Symbol/CompileUnit.h"
 #include "lldb/Target/Target.h"
-#include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/LLDBAssert.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/StreamString.h"
 
 using namespace lldb_private;
 
 namespace {
 // Any Clang compiler requires a consumer for diagnostics.  This one stores

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

 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/StreamFile.h"
 #include "lldb/Core/Value.h"
 #include "lldb/Expression/DiagnosticManager.h"
 #include "lldb/Expression/FunctionCaller.h"
 #include "lldb/Expression/UserExpression.h"
 #include "lldb/Expression/UtilityFunction.h"
+#include "lldb/Host/FileSpec.h"
 #include "lldb/Symbol/ClangASTContext.h"
 #include "lldb/Symbol/Symbol.h"
 #include "lldb/Target/ABI.h"
 #include "lldb/Target/ExecutionContext.h"
 #include "lldb/Target/ObjCLanguageRuntime.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/RegisterContext.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Target/ThreadPlanRunToAddress.h"
 #include "lldb/Utility/ConstString.h"
-#include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/Log.h"
 
 #include "llvm/ADT/STLExtras.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 const char *AppleObjCTrampolineHandler::g_lookup_implementation_function_name =

source/Plugins/ObjectContainer/BSD-Archive/ObjectContainerBSDArchive.h

 //===-- ObjectContainerBSDArchive.h -----------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_ObjectContainerBSDArchive_h_
 #define liblldb_ObjectContainerBSDArchive_h_
 
 #include "lldb/Core/UniqueCStringMap.h"
+#include "lldb/Host/FileSpec.h"
 #include "lldb/Symbol/ObjectContainer.h"
 #include "lldb/Utility/ArchSpec.h"
 #include "lldb/Utility/ConstString.h"
-#include "lldb/Utility/FileSpec.h"
 
 // Other libraries and framework includes
 #include "llvm/Support/Chrono.h"
 
 // C Includes
 // C++ Includes
 #include <map>
 #include <memory>

source/Plugins/ObjectContainer/BSD-Archive/ObjectContainerBSDArchive.cpp

size_t ObjectContainerBSDArchive::GetModuleSpecifications(
   // see if the magic bytes match and if they do, read the entire table of
   // contents for the archive and cache it
   DataExtractor data;
   data.SetData(data_sp, data_offset, data_sp->GetByteSize());
   if (!file || !data_sp || !ObjectContainerBSDArchive::MagicBytesMatch(data))
     return 0;
 
   const size_t initial_count = specs.GetSize();
-  llvm::sys::TimePoint<> file_mod_time = FileSystem::GetModificationTime(file);
+  llvm::sys::TimePoint<> file_mod_time =
+      FileSystem::Instance().GetModificationTime(file);
   Archive::shared_ptr archive_sp(
       Archive::FindCachedArchive(file, ArchSpec(), file_mod_time, file_offset));
   bool set_archive_arch = false;
   if (!archive_sp) {
     set_archive_arch = true;
     data_sp =
         DataBufferLLVM::CreateSliceFromPath(file.GetPath(), file_size, file_offset);
     if (data_sp) {

source/Plugins/ObjectContainer/Universal-Mach-O/ObjectContainerUniversalMachO.h

 //===-- ObjectContainerUniversalMachO.h -------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_ObjectContainerUniversalMachO_h_
 #define liblldb_ObjectContainerUniversalMachO_h_
 
 // C Includes
 // C++ Includes
 // Other libraries and framework includes
 // Project includes
+#include "lldb/Host/FileSpec.h"
 #include "lldb/Host/SafeMachO.h"
 #include "lldb/Symbol/ObjectContainer.h"
-#include "lldb/Utility/FileSpec.h"
 
 class ObjectContainerUniversalMachO : public lldb_private::ObjectContainer {
 public:
   ObjectContainerUniversalMachO(const lldb::ModuleSP &module_sp,
                                 lldb::DataBufferSP &data_sp,
                                 lldb::offset_t data_offset,
                                 const lldb_private::FileSpec *file,
                                 lldb::offset_t offset, lldb::offset_t length);

source/Plugins/ObjectFile/ELF/ObjectFileELF.h

 #define liblldb_ObjectFileELF_h_
 
 // C Includes
 #include <stdint.h>
 
 // C++ Includes
 #include <vector>
 
+#include "lldb/Host/FileSpec.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Utility/ArchSpec.h"
-#include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/UUID.h"
 #include "lldb/lldb-private.h"
 
 #include "ELFHeader.h"
 
 struct ELFNote {
   elf::elf_word n_namesz;
   elf::elf_word n_descsz;

source/Plugins/ObjectFile/JIT/ObjectFileJIT.cpp

 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/FileSpecList.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/RangeMap.h"
 #include "lldb/Core/Section.h"
 #include "lldb/Core/StreamFile.h"
+#include "lldb/Host/FileSpec.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Target/Platform.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/SectionLoadList.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/ArchSpec.h"
 #include "lldb/Utility/DataBuffer.h"
 #include "lldb/Utility/DataBufferHeap.h"
-#include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/StreamString.h"
 #include "lldb/Utility/Timer.h"
 #include "lldb/Utility/UUID.h"
 
 #ifndef __APPLE__
 #include "Utility/UuidCompatibility.h"
 #endif

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

 
 // C Includes
 // C++ Includes
 // Other libraries and framework includes
 // Project includes
 #include "lldb/Core/Address.h"
 #include "lldb/Core/FileSpecList.h"
 #include "lldb/Core/RangeMap.h"
+#include "lldb/Host/FileSpec.h"
 #include "lldb/Host/SafeMachO.h"
 #include "lldb/Symbol/ObjectFile.h"
-#include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/UUID.h"
 
 //----------------------------------------------------------------------
 // This class needs to be hidden as eventually belongs in a plugin that
 // will export the ObjectFile protocol
 //----------------------------------------------------------------------
 class ObjectFileMachO : public lldb_private::ObjectFile {
 public:

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

 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/FileSpecList.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/RangeMap.h"
 #include "lldb/Core/Section.h"
 #include "lldb/Core/StreamFile.h"
+#include "lldb/Host/FileSpec.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Symbol/DWARFCallFrameInfo.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Target/DynamicLoader.h"
 #include "lldb/Target/MemoryRegionInfo.h"
 #include "lldb/Target/Platform.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/SectionLoadList.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Target/ThreadList.h"
 #include "lldb/Utility/ArchSpec.h"
 #include "lldb/Utility/DataBuffer.h"
-#include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/RegisterValue.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/StreamString.h"
 #include "lldb/Utility/Timer.h"
 #include "lldb/Utility/UUID.h"
 
 #include "lldb/Host/SafeMachO.h"

source/Plugins/ObjectFile/PECOFF/ObjectFilePECOFF.cpp

 #include "WindowsMiniDump.h"
 
 #include "lldb/Core/FileSpecList.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/Section.h"
 #include "lldb/Core/StreamFile.h"
+#include "lldb/Host/FileSpec.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/SectionLoadList.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/ArchSpec.h"
 #include "lldb/Utility/DataBufferHeap.h"
-#include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/StreamString.h"
 #include "lldb/Utility/Timer.h"
 #include "lldb/Utility/UUID.h"
 #include "llvm/BinaryFormat/COFF.h"
 
 #include "llvm/Support/MemoryBuffer.h"
 
 #define IMAGE_DOS_SIGNATURE 0x5A4D    // MZ

source/Plugins/ObjectFile/PECOFF/WindowsMiniDump.cpp

 //===-- WindowsMiniDump.cpp -------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // This function is separated out from ObjectFilePECOFF.cpp to name avoid name
 // collisions with WinAPI preprocessor macros.
 
 #include "WindowsMiniDump.h"
-#include "lldb/Utility/FileSpec.h"
+#include "lldb/Host/FileSpec.h"
 #include "llvm/Support/ConvertUTF.h"
 
 #ifdef _WIN32
 #include "lldb/Host/windows/windows.h"
 #include <dbghelp.h> // for MiniDumpWriteDump
 #endif
 
 namespace lldb_private {

source/Plugins/Platform/Android/AdbClient.cpp

 #include "AdbClient.h"
 
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/FileUtilities.h"
 
 #include "lldb/Host/ConnectionFileDescriptor.h"
+#include "lldb/Host/FileSpec.h"
 #include "lldb/Host/FileSystem.h"
 #include "lldb/Host/PosixApi.h"
 #include "lldb/Utility/DataBuffer.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/DataEncoder.h"
 #include "lldb/Utility/DataExtractor.h"
-#include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/StreamString.h"
 #include "lldb/Utility/Timeout.h"
 
 #include <limits.h>
 
 #include <algorithm>
 #include <cstdlib>
 #include <fstream>
Status AdbClient::SyncService::internalPushFile(const FileSpec &local_file,
   char chunk[kMaxPushData];
   while (!src.eof() && !src.read(chunk, kMaxPushData).bad()) {
     size_t chunk_size = src.gcount();
     error = SendSyncRequest(kDATA, chunk_size, chunk);
     if (error.Fail())
       return Status("Failed to send file chunk: %s", error.AsCString());
   }
   error = SendSyncRequest(
-      kDONE, llvm::sys::toTimeT(FileSystem::GetModificationTime(local_file)),
+      kDONE,
+      llvm::sys::toTimeT(
+          FileSystem::Instance().GetModificationTime(local_file)),
       nullptr);
   if (error.Fail())
     return error;
 
   std::string response_id;
   uint32_t data_len;
   error = ReadSyncHeader(response_id, data_len);
   if (error.Fail())

source/Plugins/Platform/FreeBSD/PlatformFreeBSD.cpp

 
 // C++ Includes
 // Other libraries and framework includes
 // Project includes
 #include "lldb/Breakpoint/BreakpointLocation.h"
 #include "lldb/Breakpoint/BreakpointSite.h"
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/PluginManager.h"
+#include "lldb/Host/FileSpec.h"
 #include "lldb/Host/HostInfo.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Target.h"
-#include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/State.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/StreamString.h"
 
 // Define these constants from FreeBSD mman.h for use when targeting remote
 // FreeBSD systems even when host has different values.
 #define MAP_PRIVATE 0x0002

source/Plugins/Platform/Kalimba/PlatformKalimba.cpp

 // C++ Includes
 // Other libraries and framework includes
 // Project includes
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleList.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/PluginManager.h"
+#include "lldb/Host/FileSpec.h"
 #include "lldb/Host/HostInfo.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Target.h"
-#include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/StreamString.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 static uint32_t g_initialize_count = 0;
 

source/Plugins/Platform/Linux/PlatformLinux.cpp

 #include <sys/utsname.h>
 #endif
 
 // C++ Includes
 // Other libraries and framework includes
 // Project includes
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/PluginManager.h"
+#include "lldb/Host/FileSpec.h"
 #include "lldb/Host/HostInfo.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Target.h"
-#include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/State.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/StreamString.h"
 
 // Define these constants from Linux mman.h for use when targeting remote linux
 // systems even when host has different values.
 #define MAP_PRIVATE 2

source/Plugins/Platform/MacOSX/PlatformAppleSimulator.h

 // C Includes
 // C++ Includes
 #include <mutex>
 
 // Other libraries and framework includes
 // Project includes
 #include "Plugins/Platform/MacOSX/PlatformDarwin.h"
 #include "Plugins/Platform/MacOSX/objcxx/PlatformiOSSimulatorCoreSimulatorSupport.h"
-#include "lldb/Utility/FileSpec.h"
+#include "lldb/Host/FileSpec.h"
 
 #include "llvm/ADT/Optional.h"
 
 class PlatformAppleSimulator : public PlatformDarwin {
 public:
   //------------------------------------------------------------
   // Class Functions
   //------------------------------------------------------------

source/Plugins/Platform/MacOSX/PlatformAppleTVSimulator.cpp

 // C++ Includes
 // Other libraries and framework includes
 // Project includes
 #include "lldb/Breakpoint/BreakpointLocation.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleList.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/PluginManager.h"
+#include "lldb/Host/FileSpec.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Host/HostInfo.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/ArchSpec.h"
-#include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/StreamString.h"
 
 #include "llvm/Support/FileSystem.h"
 
 using namespace lldb;
 using namespace lldb_private;
Status PlatformAppleTVSimulator::ResolveExecutable(
   } else {
     error.SetErrorStringWithFormat("'%s' does not exist",
                                    module_spec.GetFileSpec().GetPath().c_str());
   }
 
   return error;
 }
 
-static FileSpec::EnumerateDirectoryResult
+static FileSystem::EnumerateDirectoryResult
 EnumerateDirectoryCallback(void *baton, llvm::sys::fs::file_type ft,
-                           const FileSpec &file_spec) {
+                           llvm::StringRef path) {
   if (ft == llvm::sys::fs::file_type::directory_file) {
+    FileSpec file_spec(path, false);
     const char *filename = file_spec.GetFilename().GetCString();
     if (filename &&
         strncmp(filename, "AppleTVSimulator", strlen("AppleTVSimulator")) ==
             0) {
       ::snprintf((char *)baton, PATH_MAX, "%s", filename);
-      return FileSpec::eEnumerateDirectoryResultQuit;
+      return FileSystem::eEnumerateDirectoryResultQuit;
     }
   }
-  return FileSpec::eEnumerateDirectoryResultNext;
+  return FileSystem::eEnumerateDirectoryResultNext;
 }
 
 const char *PlatformAppleTVSimulator::GetSDKDirectoryAsCString() {
   std::lock_guard<std::mutex> guard(m_sdk_dir_mutex);
   if (m_sdk_directory.empty()) {
     const char *developer_dir = GetDeveloperDirectory();
     if (developer_dir) {
       char sdks_directory[PATH_MAX];
       char sdk_dirname[PATH_MAX];
       sdk_dirname[0] = '\0';
       snprintf(sdks_directory, sizeof(sdks_directory),
                "%s/Platforms/AppleTVSimulator.platform/Developer/SDKs",
                developer_dir);
       FileSpec simulator_sdk_spec;
       bool find_directories = true;
       bool find_files = false;
       bool find_other = false;
-      FileSpec::EnumerateDirectory(sdks_directory, find_directories, find_files,
-                                   find_other, EnumerateDirectoryCallback,
-                                   sdk_dirname);
+      FileSystem::Instance().EnumerateDirectory(
+          sdks_directory, find_directories, find_files, find_other,
+          EnumerateDirectoryCallback, sdk_dirname);
 
       if (sdk_dirname[0]) {
         m_sdk_directory = sdks_directory;
         m_sdk_directory.append(1, '/');
         m_sdk_directory.append(sdk_dirname);
         return m_sdk_directory.c_str();
       }
     }

source/Plugins/Platform/MacOSX/PlatformAppleWatchSimulator.cpp

 // C++ Includes
 // Other libraries and framework includes
 // Project includes
 #include "lldb/Breakpoint/BreakpointLocation.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleList.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/PluginManager.h"
+#include "lldb/Host/FileSpec.h"
+#include "lldb/Host/FileSystem.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Host/HostInfo.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/ArchSpec.h"
-#include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/StreamString.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 //------------------------------------------------------------------
Status PlatformAppleWatchSimulator::ResolveExecutable(
   } else {
     error.SetErrorStringWithFormat("'%s' does not exist",
                                    module_spec.GetFileSpec().GetPath().c_str());
   }
 
   return error;
 }
 
-static FileSpec::EnumerateDirectoryResult
+static FileSystem::EnumerateDirectoryResult
 EnumerateDirectoryCallback(void *baton, llvm::sys::fs::file_type ft,
-                           const FileSpec &file_spec) {
+                           llvm::StringRef path) {
   if (ft == llvm::sys::fs::file_type::directory_file) {
+    FileSpec file_spec(path, false);
     const char *filename = file_spec.GetFilename().GetCString();
     if (filename &&
         strncmp(filename, "AppleWatchSimulator",
                 strlen("AppleWatchSimulator")) == 0) {
       ::snprintf((char *)baton, PATH_MAX, "%s", filename);
-      return FileSpec::eEnumerateDirectoryResultQuit;
+      return FileSystem::eEnumerateDirectoryResultQuit;
     }
   }
-  return FileSpec::eEnumerateDirectoryResultNext;
+  return FileSystem::eEnumerateDirectoryResultNext;
 }
 
 const char *PlatformAppleWatchSimulator::GetSDKDirectoryAsCString() {
   std::lock_guard<std::mutex> guard(m_sdk_dir_mutex);
   if (m_sdk_directory.empty()) {
     const char *developer_dir = GetDeveloperDirectory();
     if (developer_dir) {
       char sdks_directory[PATH_MAX];
       char sdk_dirname[PATH_MAX];
       sdk_dirname[0] = '\0';
       snprintf(sdks_directory, sizeof(sdks_directory),
                "%s/Platforms/AppleWatchSimulator.platform/Developer/SDKs",
                developer_dir);
       FileSpec simulator_sdk_spec;
       bool find_directories = true;
       bool find_files = false;
       bool find_other = false;
-      FileSpec::EnumerateDirectory(sdks_directory, find_directories, find_files,
-                                   find_other, EnumerateDirectoryCallback,
-                                   sdk_dirname);
+      FileSystem::Instance().EnumerateDirectory(
+          sdks_directory, find_directories, find_files, find_other,
+          EnumerateDirectoryCallback, sdk_dirname);
 
       if (sdk_dirname[0]) {
         m_sdk_directory = sdks_directory;
         m_sdk_directory.append(1, '/');
         m_sdk_directory.append(sdk_dirname);
         return m_sdk_directory.c_str();
       }
     }

source/Plugins/Platform/MacOSX/PlatformDarwin.h

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

source/Plugins/Platform/MacOSX/PlatformDarwin.cpp

 #include <mutex>
 
 // Project includes
 #include "lldb/Breakpoint/BreakpointLocation.h"
 #include "lldb/Breakpoint/BreakpointSite.h"
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleSpec.h"
+#include "lldb/Host/FileSystem.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Host/HostInfo.h"
 #include "lldb/Host/Symbols.h"
 #include "lldb/Host/XML.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/SymbolFile.h"
 #include "lldb/Symbol/SymbolVendor.h"
if (last_path_component) {
     if (version.tryParse(version_part))
       return false;
     return SDKSupportsModules(desired_type, version);
   }
 
   return false;
 }
 
-FileSpec::EnumerateDirectoryResult PlatformDarwin::DirectoryEnumerator(
-    void *baton, llvm::sys::fs::file_type file_type, const FileSpec &spec) {
+FileSystem::EnumerateDirectoryResult PlatformDarwin::DirectoryEnumerator(
+    void *baton, llvm::sys::fs::file_type file_type, llvm::StringRef path) {
   SDKEnumeratorInfo *enumerator_info = static_cast<SDKEnumeratorInfo *>(baton);
 
+  FileSpec spec(path, false);
   if (SDKSupportsModules(enumerator_info->sdk_type, spec)) {
     enumerator_info->found_path = spec;
-    return FileSpec::EnumerateDirectoryResult::eEnumerateDirectoryResultNext;
+    return FileSystem::EnumerateDirectoryResult::eEnumerateDirectoryResultNext;
   }
 
-  return FileSpec::EnumerateDirectoryResult::eEnumerateDirectoryResultNext;
+  return FileSystem::EnumerateDirectoryResult::eEnumerateDirectoryResultNext;
 }
 
 FileSpec PlatformDarwin::FindSDKInXcodeForModules(SDKType sdk_type,
                                                   const FileSpec &sdks_spec) {
   // Look inside Xcode for the required installed iOS SDK version
 
   if (!llvm::sys::fs::is_directory(sdks_spec.GetPath())) {
     return FileSpec();
   }
 
   const bool find_directories = true;
   const bool find_files = false;
   const bool find_other = true; // include symlinks
 
   SDKEnumeratorInfo enumerator_info;
 
   enumerator_info.sdk_type = sdk_type;
 
-  FileSpec::EnumerateDirectory(sdks_spec.GetPath(), find_directories,
-                               find_files, find_other, DirectoryEnumerator,
-                               &enumerator_info);
+  FileSystem::Instance().EnumerateDirectory(
+      sdks_spec.GetPath(), find_directories, find_files, find_other,
+      DirectoryEnumerator, &enumerator_info);
 
   if (llvm::sys::fs::is_directory(enumerator_info.found_path.GetPath()))
     return enumerator_info.found_path;
   else
     return FileSpec();
 }
 
 FileSpec PlatformDarwin::GetSDKDirectoryForModules(SDKType sdk_type) {

source/Plugins/Platform/MacOSX/PlatformDarwinKernel.h

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

source/Plugins/Platform/MacOSX/PlatformDarwinKernel.cpp

 // C++ Includes
 // Other libraries and framework includes
 // Project includes
 #include "lldb/Breakpoint/BreakpointLocation.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleList.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/PluginManager.h"
+#include "lldb/Host/FileSpec.h"
+#include "lldb/Host/FileSystem.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Interpreter/OptionValueFileSpecList.h"
 #include "lldb/Interpreter/OptionValueProperties.h"
 #include "lldb/Interpreter/Property.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Target/Platform.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/ArchSpec.h"
-#include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/StreamString.h"
 
 #include "llvm/Support/FileSystem.h"
 
 #include <CoreFoundation/CoreFoundation.h>
 

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

source/Plugins/Platform/MacOSX/PlatformMacOSX.cpp

 
 // Other libraries and framework includes
 // Project includes
 #include "lldb/Breakpoint/BreakpointLocation.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleList.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/PluginManager.h"
+#include "lldb/Host/FileSpec.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Host/HostInfo.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/DataBufferHeap.h"
-#include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/StreamString.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 static uint32_t g_initialize_count = 0;

source/Plugins/Platform/MacOSX/PlatformRemoteAppleBridge.h

 #define liblldb_PlatformRemoteAppleBridge_h_
 
 // C Includes
 // C++ Includes
 #include <string>
 
 // Other libraries and framework includes
 // Project includes
-#include "lldb/Utility/FileSpec.h"
+#include "lldb/Host/FileSpec.h"
 
 #include "llvm/Support/FileSystem.h"
 
 #include "PlatformRemoteDarwinDevice.h"
 
 class PlatformRemoteAppleBridge : public PlatformRemoteDarwinDevice {
 public:
   PlatformRemoteAppleBridge();

source/Plugins/Platform/MacOSX/PlatformRemoteAppleBridge.cpp

 // Project includes
 #include "PlatformRemoteAppleBridge.h"
 
 #include "lldb/Breakpoint/BreakpointLocation.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleList.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/PluginManager.h"
+#include "lldb/Host/FileSpec.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/ArchSpec.h"
-#include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/StreamString.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 //------------------------------------------------------------------
 /// Default Constructor

source/Plugins/Platform/MacOSX/PlatformRemoteAppleTV.h

 #define liblldb_PlatformRemoteAppleTV_h_
 
 // C Includes
 // C++ Includes
 #include <string>
 
 // Other libraries and framework includes
 // Project includes
-#include "lldb/Utility/FileSpec.h"
+#include "lldb/Host/FileSpec.h"
 
 #include "llvm/Support/FileSystem.h"
 
 #include "PlatformRemoteDarwinDevice.h"
 
 class PlatformRemoteAppleTV : public PlatformRemoteDarwinDevice {
 public:
   PlatformRemoteAppleTV();

source/Plugins/Platform/MacOSX/PlatformRemoteAppleTV.cpp

 // Project includes
 #include "PlatformRemoteAppleTV.h"
 
 #include "lldb/Breakpoint/BreakpointLocation.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleList.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/PluginManager.h"
+#include "lldb/Host/FileSpec.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/ArchSpec.h"
-#include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/StreamString.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 //------------------------------------------------------------------

source/Plugins/Platform/MacOSX/PlatformRemoteAppleWatch.h

 
 // C Includes
 // C++ Includes
 #include <string>
 #include <vector>
 
 // Other libraries and framework includes
 // Project includes
-#include "lldb/Utility/FileSpec.h"
+#include "lldb/Host/FileSpec.h"
 
 #include "PlatformRemoteDarwinDevice.h"
 
 #include "llvm/Support/FileSystem.h"
 
 class PlatformRemoteAppleWatch : public PlatformRemoteDarwinDevice {
 public:
   PlatformRemoteAppleWatch();

source/Plugins/Platform/MacOSX/PlatformRemoteAppleWatch.cpp

 // Project includes
 #include "PlatformRemoteAppleWatch.h"
 
 #include "lldb/Breakpoint/BreakpointLocation.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleList.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/PluginManager.h"
+#include "lldb/Host/FileSpec.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/ArchSpec.h"
-#include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/StreamString.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 //------------------------------------------------------------------

source/Plugins/Platform/MacOSX/PlatformRemoteDarwinDevice.h

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

source/Plugins/Platform/MacOSX/PlatformRemoteDarwinDevice.cpp

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

source/Plugins/Platform/MacOSX/PlatformRemoteiOS.h

 
 // C Includes
 // C++ Includes
 #include <string>
 
 // Other libraries and framework includes
 // Project includes
 #include "PlatformRemoteDarwinDevice.h"
-#include "lldb/Utility/FileSpec.h"
+#include "lldb/Host/FileSpec.h"
 
 #include "llvm/Support/FileSystem.h"
 
 class PlatformRemoteiOS : public PlatformRemoteDarwinDevice {
 public:
   PlatformRemoteiOS();
 
   ~PlatformRemoteiOS() override = default;

source/Plugins/Platform/MacOSX/PlatformRemoteiOS.cpp

 // C++ Includes
 // Other libraries and framework includes
 // Project includes
 #include "lldb/Breakpoint/BreakpointLocation.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleList.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/PluginManager.h"
+#include "lldb/Host/FileSpec.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/ArchSpec.h"
-#include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/StreamString.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 //------------------------------------------------------------------

source/Plugins/Platform/MacOSX/PlatformiOSSimulator.cpp

 // C++ Includes
 // Other libraries and framework includes
 // Project includes
 #include "lldb/Breakpoint/BreakpointLocation.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleList.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/PluginManager.h"
+#include "lldb/Host/FileSpec.h"
+#include "lldb/Host/FileSystem.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Host/HostInfo.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/ArchSpec.h"
-#include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/StreamString.h"
 
 #include "llvm/Support/FileSystem.h"
 
 using namespace lldb;
 using namespace lldb_private;
Status PlatformiOSSimulator::ResolveExecutable(
   } else {
     error.SetErrorStringWithFormat("'%s' does not exist",
                                    module_spec.GetFileSpec().GetPath().c_str());
   }
 
   return error;
 }
 
-static FileSpec::EnumerateDirectoryResult
+static FileSystem::EnumerateDirectoryResult
 EnumerateDirectoryCallback(void *baton, llvm::sys::fs::file_type ft,
-                           const FileSpec &file_spec) {
+                           llvm::StringRef path) {
   if (ft == llvm::sys::fs::file_type::directory_file) {
+    FileSpec file_spec(path, false);
     const char *filename = file_spec.GetFilename().GetCString();
     if (filename &&
         strncmp(filename, "iPhoneSimulator", strlen("iPhoneSimulator")) == 0) {
       ::snprintf((char *)baton, PATH_MAX, "%s", filename);
-      return FileSpec::eEnumerateDirectoryResultQuit;
+      return FileSystem::eEnumerateDirectoryResultQuit;
     }
   }
-  return FileSpec::eEnumerateDirectoryResultNext;
+  return FileSystem::eEnumerateDirectoryResultNext;
 }
 
 const char *PlatformiOSSimulator::GetSDKDirectoryAsCString() {
   std::lock_guard<std::mutex> guard(m_sdk_dir_mutex);
   if (m_sdk_directory.empty()) {
     const char *developer_dir = GetDeveloperDirectory();
     if (developer_dir) {
       char sdks_directory[PATH_MAX];
       char sdk_dirname[PATH_MAX];
       sdk_dirname[0] = '\0';
       snprintf(sdks_directory, sizeof(sdks_directory),
                "%s/Platforms/iPhoneSimulator.platform/Developer/SDKs",
                developer_dir);
       FileSpec simulator_sdk_spec;
       bool find_directories = true;
       bool find_files = false;
       bool find_other = false;
-      FileSpec::EnumerateDirectory(sdks_directory, find_directories, find_files,
-                                   find_other, EnumerateDirectoryCallback,
-                                   sdk_dirname);
+      FileSystem::Instance().EnumerateDirectory(
+          sdks_directory, find_directories, find_files, find_other,
+          EnumerateDirectoryCallback, sdk_dirname);
 
       if (sdk_dirname[0]) {
         m_sdk_directory = sdks_directory;
         m_sdk_directory.append(1, '/');
         m_sdk_directory.append(sdk_dirname);
         return m_sdk_directory.c_str();
       }
     }

source/Plugins/Platform/NetBSD/PlatformNetBSD.cpp

 #include <sys/utsname.h>
 #endif
 
 // C++ Includes
 // Other libraries and framework includes
 // Project includes
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/PluginManager.h"
+#include "lldb/Host/FileSpec.h"
 #include "lldb/Host/HostInfo.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Target.h"
-#include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/State.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/StreamString.h"
 
 // Define these constants from NetBSD mman.h for use when targeting remote
 // netbsd systems even when host has different values.
 #define MAP_PRIVATE 0x0002

source/Plugins/Platform/OpenBSD/PlatformOpenBSD.cpp

 #include <sys/utsname.h>
 #endif
 
 // C++ Includes
 // Other libraries and framework includes
 // Project includes
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/PluginManager.h"
+#include "lldb/Host/FileSpec.h"
 #include "lldb/Host/HostInfo.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Target.h"
-#include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/State.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/StreamString.h"
 
 // Define these constants from OpenBSD mman.h for use when targeting remote
 // openbsd systems even when host has different values.
 #define MAP_PRIVATE 0x0002

source/Plugins/Platform/POSIX/PlatformPOSIX.cpp

 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/ValueObject.h"
 #include "lldb/Expression/DiagnosticManager.h"
 #include "lldb/Expression/FunctionCaller.h"
 #include "lldb/Expression/UserExpression.h"
 #include "lldb/Expression/UtilityFunction.h"
 #include "lldb/Host/File.h"
 #include "lldb/Host/FileCache.h"
+#include "lldb/Host/FileSpec.h"
 #include "lldb/Host/FileSystem.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Host/HostInfo.h"
 #include "lldb/Symbol/ClangASTContext.h"
 #include "lldb/Target/DynamicLoader.h"
 #include "lldb/Target/ExecutionContext.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/ProcessLaunchInfo.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/CleanUp.h"
 #include "lldb/Utility/DataBufferHeap.h"
-#include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/StreamString.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 //------------------------------------------------------------------
 /// Default Constructor

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

 #include "lldb/Breakpoint/BreakpointLocation.h"
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleList.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/StreamFile.h"
 #include "lldb/Host/ConnectionFileDescriptor.h"
+#include "lldb/Host/FileSpec.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Host/HostInfo.h"
 #include "lldb/Host/PosixApi.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Target.h"
-#include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/StreamString.h"
 #include "lldb/Utility/UriParser.h"
 
 #include "Plugins/Process/Utility/GDBRemoteSignals.h"
 
 using namespace lldb;

source/Plugins/Process/Darwin/NativeProcessDarwin.h

 #include <mach/mach_types.h>
 
 // C++ includes
 #include <mutex>
 #include <unordered_set>
 
 // Other libraries and framework includes
 #include "lldb/Host/Debug.h"
+#include "lldb/Host/FileSpec.h"
 #include "lldb/Host/HostThread.h"
 #include "lldb/Host/Pipe.h"
 #include "lldb/Host/common/NativeProcessProtocol.h"
 #include "lldb/Target/MemoryRegionInfo.h"
 #include "lldb/Utility/ArchSpec.h"
-#include "lldb/Utility/FileSpec.h"
 #include "lldb/lldb-types.h"
 
 #include "LaunchFlavor.h"
 #include "MachException.h"
 #include "NativeThreadDarwin.h"
 #include "NativeThreadListDarwin.h"
 
 namespace lldb_private {

source/Plugins/Process/FreeBSD/ProcessFreeBSD.cpp

 #include "ProcessMonitor.h"
 
 // Other libraries and framework includes
 #include "lldb/Breakpoint/BreakpointLocation.h"
 #include "lldb/Breakpoint/Watchpoint.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/PluginManager.h"
+#include "lldb/Host/FileSpec.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Target/DynamicLoader.h"
 #include "lldb/Target/Platform.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/DataBufferHeap.h"
-#include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/State.h"
 
 #include "lldb/Host/posix/Fcntl.h"
 
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Threading.h"
 
 using namespace lldb;

source/Plugins/Process/FreeBSD/ProcessMonitor.h

 // C Includes
 #include <semaphore.h>
 #include <signal.h>
 
 // C++ Includes
 #include <mutex>
 
 // Other libraries and framework includes
+#include "lldb/Host/FileSpec.h"
 #include "lldb/Host/HostThread.h"
-#include "lldb/Utility/FileSpec.h"
 #include "lldb/lldb-types.h"
 
 namespace lldb_private {
 class Status;
 class Module;
 class Scalar;
 } // End lldb_private namespace.
 

source/Plugins/Process/Linux/NativeProcessLinux.h

 //===-- NativeProcessLinux.h ---------------------------------- -*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_NativeProcessLinux_H_
 #define liblldb_NativeProcessLinux_H_
 
 #include <csignal>
 #include <unordered_set>
 
 #include "lldb/Host/Debug.h"
+#include "lldb/Host/FileSpec.h"
 #include "lldb/Host/HostThread.h"
 #include "lldb/Host/linux/Support.h"
 #include "lldb/Target/MemoryRegionInfo.h"
 #include "lldb/Utility/ArchSpec.h"
-#include "lldb/Utility/FileSpec.h"
 #include "lldb/lldb-types.h"
 
 #include "NativeThreadLinux.h"
 #include "ProcessorTrace.h"
 #include "lldb/Host/common/NativeProcessProtocol.h"
 
 namespace lldb_private {
 class Status;

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

 #include <errno.h>
 #include <limits.h>
 #include <string.h>
 
 // C++ Includes
 
 // Other libraries and framework includes
 #include "lldb/Core/DumpDataExtractor.h"
+#include "lldb/Host/FileSpec.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/DataExtractor.h"
-#include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/State.h"
 #include "lldb/Utility/UUID.h"
 
 // Project includes
 #include "ProcessKDPLog.h"
 
 using namespace lldb;

source/Plugins/Process/NetBSD/NativeProcessNetBSD.h

 //===-- NativeProcessNetBSD.h --------------------------------- -*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_NativeProcessNetBSD_H_
 #define liblldb_NativeProcessNetBSD_H_
 
+#include "lldb/Host/FileSpec.h"
 #include "lldb/Target/MemoryRegionInfo.h"
 #include "lldb/Utility/ArchSpec.h"
-#include "lldb/Utility/FileSpec.h"
 
 #include "NativeThreadNetBSD.h"
 #include "lldb/Host/common/NativeProcessProtocol.h"
 
 namespace lldb_private {
 namespace process_netbsd {
 /// @class NativeProcessNetBSD
 /// Manages communication with the inferior (debugee) process.

source/Plugins/Process/Windows/Common/DebuggerThread.cpp

 //===-- DebuggerThread.cpp --------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "DebuggerThread.h"
 #include "ExceptionRecord.h"
 #include "IDebugDelegate.h"
 
 #include "lldb/Core/ModuleSpec.h"
+#include "lldb/Host/FileSpec.h"
 #include "lldb/Host/ThreadLauncher.h"
 #include "lldb/Host/windows/HostProcessWindows.h"
 #include "lldb/Host/windows/HostThreadWindows.h"
 #include "lldb/Host/windows/ProcessLauncherWindows.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/ProcessLaunchInfo.h"
-#include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/Predicate.h"
 #include "lldb/Utility/Status.h"
 
 #include "Plugins/Process/Windows/Common/ProcessWindowsLog.h"
 
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/Support/ConvertUTF.h"

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

 #include <limits.h>
 #include <string.h>
 #include <sys/stat.h>
 
 // C++ Includes
 // Other libraries and framework includes
 #include "lldb/Core/StreamFile.h"
 #include "lldb/Host/ConnectionFileDescriptor.h"
+#include "lldb/Host/FileSpec.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Host/HostInfo.h"
 #include "lldb/Host/Pipe.h"
 #include "lldb/Host/Socket.h"
 #include "lldb/Host/StringConvert.h"
 #include "lldb/Host/ThreadLauncher.h"
 #include "lldb/Target/Platform.h"
 #include "lldb/Target/Process.h"
-#include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/RegularExpression.h"
 #include "lldb/Utility/StreamString.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/Support/ScopedPrinter.h"
 
 // Project includes
 #include "ProcessGDBRemoteLog.h"

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

 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/StreamFile.h"
 #include "lldb/Core/Value.h"
 #include "lldb/DataFormatters/FormatManager.h"
 #include "lldb/Host/ConnectionFileDescriptor.h"
+#include "lldb/Host/FileSpec.h"
 #include "lldb/Host/FileSystem.h"
 #include "lldb/Host/HostThread.h"
 #include "lldb/Host/PosixApi.h"
 #include "lldb/Host/PseudoTerminal.h"
 #include "lldb/Host/StringConvert.h"
 #include "lldb/Host/Symbols.h"
 #include "lldb/Host/ThreadLauncher.h"
 #include "lldb/Host/XML.h"

 #include "lldb/Target/DynamicLoader.h"
 #include "lldb/Target/MemoryRegionInfo.h"
 #include "lldb/Target/SystemRuntime.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/TargetList.h"
 #include "lldb/Target/ThreadPlanCallFunction.h"
 #include "lldb/Utility/Args.h"
 #include "lldb/Utility/CleanUp.h"
-#include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/State.h"
 #include "lldb/Utility/StreamString.h"
 #include "lldb/Utility/Timer.h"
 
 // Project includes
 #include "GDBRemoteRegisterContext.h"
 #include "Plugins/Platform/MacOSX/PlatformRemoteiOS.h"
 #include "Plugins/Process/Utility/GDBRemoteSignals.h"

source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDebugMap.cpp

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

source/Plugins/SystemRuntime/MacOSX/SystemRuntimeMacOSX.h

 // C++ Includes
 #include <mutex>
 #include <string>
 #include <vector>
 
 // Other libraries and framework include
 // Project includes
 #include "lldb/Core/ModuleList.h"
+#include "lldb/Host/FileSpec.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/QueueItem.h"
 #include "lldb/Target/SystemRuntime.h"
 #include "lldb/Utility/ConstString.h"
-#include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/StructuredData.h"
 #include "lldb/Utility/UUID.h"
 
 #include "AppleGetItemInfoHandler.h"
 #include "AppleGetPendingItemsHandler.h"
 #include "AppleGetQueuesHandler.h"
 #include "AppleGetThreadItemInfoHandler.h"
 

source/Plugins/SystemRuntime/MacOSX/SystemRuntimeMacOSX.cpp

 //===-- SystemRuntimeMacOSX.cpp ---------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "Plugins/Process/Utility/HistoryThread.h"
 #include "lldb/Breakpoint/StoppointCallbackContext.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/Section.h"
+#include "lldb/Host/FileSpec.h"
 #include "lldb/Symbol/ClangASTContext.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/SymbolContext.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/ProcessStructReader.h"
 #include "lldb/Target/Queue.h"
 #include "lldb/Target/QueueList.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/DataExtractor.h"
-#include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/StreamString.h"
 
 #include "SystemRuntimeMacOSX.h"
 
 using namespace lldb;
 using namespace lldb_private;
 

source/Target/PathMappingList.cpp

 //===-- PathMappingList.cpp -------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // C Includes
 // C++ Includes
 #include <climits>
 #include <cstring>
 
 // Other libraries and framework includes
 // Project includes
-#include "lldb/lldb-private-enumerations.h"
+#include "lldb/Host/FileSpec.h"
 #include "lldb/Host/PosixApi.h"
 #include "lldb/Target/PathMappingList.h"
-#include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/Stream.h"
+#include "lldb/lldb-private-enumerations.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 namespace {
   // We must normalize our path pairs that we store because if we don't then
   // things won't always work. We found a case where if we did:
   // (lldb) settings set target.source-map . /tmp

source/Target/Platform.cpp

 // Project includes
 #include "lldb/Breakpoint/BreakpointIDList.h"
 #include "lldb/Breakpoint/BreakpointLocation.h"
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/StreamFile.h"
+#include "lldb/Host/FileSpec.h"
 #include "lldb/Host/FileSystem.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Host/HostInfo.h"
 #include "lldb/Host/OptionParser.h"
 #include "lldb/Interpreter/OptionValueProperties.h"
 #include "lldb/Interpreter/Property.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Target/ModuleCache.h"
 #include "lldb/Target/Platform.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/UnixSignals.h"
 #include "lldb/Utility/DataBufferHeap.h"
-#include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/StructuredData.h"
 
 #include "llvm/Support/FileSystem.h"
 
 // Define these constants from POSIX mman.h rather than include the file so
 // that they will be correct even when compiled on Linux.

 }
 
 struct RecurseCopyBaton {
   const FileSpec &dst;
   Platform *platform_ptr;
   Status error;
 };
 
-static FileSpec::EnumerateDirectoryResult
+static FileSystem::EnumerateDirectoryResult
 RecurseCopy_Callback(void *baton, llvm::sys::fs::file_type ft,
-                     const FileSpec &src) {
+                     llvm::StringRef path) {
+  FileSpec src(path, false);
   RecurseCopyBaton *rc_baton = (RecurseCopyBaton *)baton;
   namespace fs = llvm::sys::fs;
   switch (ft) {
   case fs::file_type::fifo_file:
   case fs::file_type::socket_file:
     // we have no way to copy pipes and sockets - ignore them and continue
-    return FileSpec::eEnumerateDirectoryResultNext;
+    return FileSystem::eEnumerateDirectoryResultNext;
     break;
 
   case fs::file_type::directory_file: {
     // make the new directory and get in there
     FileSpec dst_dir = rc_baton->dst;
     if (!dst_dir.GetFilename())
       dst_dir.GetFilename() = src.GetLastPathComponent();
     Status error = rc_baton->platform_ptr->MakeDirectory(
         dst_dir, lldb::eFilePermissionsDirectoryDefault);
     if (error.Fail()) {
       rc_baton->error.SetErrorStringWithFormat(
           "unable to setup directory %s on remote end", dst_dir.GetCString());
-      return FileSpec::eEnumerateDirectoryResultQuit; // got an error, bail out
+      return FileSystem::eEnumerateDirectoryResultQuit; // got an error, bail
+                                                        // out
     }
 
     // now recurse
     std::string src_dir_path(src.GetPath());
 
     // Make a filespec that only fills in the directory of a FileSpec so when
     // we enumerate we can quickly fill in the filename for dst copies
     FileSpec recurse_dst;
     recurse_dst.GetDirectory().SetCString(dst_dir.GetPath().c_str());
     RecurseCopyBaton rc_baton2 = {recurse_dst, rc_baton->platform_ptr,
                                   Status()};
-    FileSpec::EnumerateDirectory(src_dir_path, true, true, true,
+    FileSystem::Instance().EnumerateDirectory(src_dir_path, true, true, true,
                                               RecurseCopy_Callback, &rc_baton2);
     if (rc_baton2.error.Fail()) {
       rc_baton->error.SetErrorString(rc_baton2.error.AsCString());
-      return FileSpec::eEnumerateDirectoryResultQuit; // got an error, bail out
+      return FileSystem::eEnumerateDirectoryResultQuit; // got an error, bail
+                                                        // out
     }
-    return FileSpec::eEnumerateDirectoryResultNext;
+    return FileSystem::eEnumerateDirectoryResultNext;
   } break;
 
   case fs::file_type::symlink_file: {
     // copy the file and keep going
     FileSpec dst_file = rc_baton->dst;
     if (!dst_file.GetFilename())
       dst_file.GetFilename() = src.GetFilename();
 
     FileSpec src_resolved;
 
     rc_baton->error = FileSystem::Readlink(src, src_resolved);
 
     if (rc_baton->error.Fail())
-      return FileSpec::eEnumerateDirectoryResultQuit; // got an error, bail out
+      return FileSystem::eEnumerateDirectoryResultQuit; // got an error, bail
+                                                        // out
 
     rc_baton->error =
         rc_baton->platform_ptr->CreateSymlink(dst_file, src_resolved);
 
     if (rc_baton->error.Fail())
-      return FileSpec::eEnumerateDirectoryResultQuit; // got an error, bail out
+      return FileSystem::eEnumerateDirectoryResultQuit; // got an error, bail
+                                                        // out
 
-    return FileSpec::eEnumerateDirectoryResultNext;
+    return FileSystem::eEnumerateDirectoryResultNext;
   } break;
 
   case fs::file_type::regular_file: {
     // copy the file and keep going
     FileSpec dst_file = rc_baton->dst;
     if (!dst_file.GetFilename())
       dst_file.GetFilename() = src.GetFilename();
     Status err = rc_baton->platform_ptr->PutFile(src, dst_file);
     if (err.Fail()) {
       rc_baton->error.SetErrorString(err.AsCString());
-      return FileSpec::eEnumerateDirectoryResultQuit; // got an error, bail out
+      return FileSystem::eEnumerateDirectoryResultQuit; // got an error, bail
+                                                        // out
     }
-    return FileSpec::eEnumerateDirectoryResultNext;
+    return FileSystem::eEnumerateDirectoryResultNext;
   } break;
 
   default:
     rc_baton->error.SetErrorStringWithFormat(
         "invalid file detected during copy: %s", src.GetPath().c_str());
-    return FileSpec::eEnumerateDirectoryResultQuit; // got an error, bail out
+    return FileSystem::eEnumerateDirectoryResultQuit; // got an error, bail out
     break;
   }
   llvm_unreachable("Unhandled file_type!");
 }
 
 Status Platform::Install(const FileSpec &src, const FileSpec &dst) {
   Status error;
 
case fs::file_type::directory_file: {
       error = MakeDirectory(fixed_dst, permissions);
       if (error.Success()) {
         // Make a filespec that only fills in the directory of a FileSpec so
         // when we enumerate we can quickly fill in the filename for dst copies
         FileSpec recurse_dst;
         recurse_dst.GetDirectory().SetCString(fixed_dst.GetCString());
         std::string src_dir_path(src.GetPath());
         RecurseCopyBaton baton = {recurse_dst, this, Status()};
-        FileSpec::EnumerateDirectory(src_dir_path, true, true, true,
-                                     RecurseCopy_Callback, &baton);
+        FileSystem::Instance().EnumerateDirectory(
+            src_dir_path, true, true, true, RecurseCopy_Callback, &baton);
         return baton.error;
       }
     } break;
 
     case fs::file_type::regular_file:
       llvm::sys::fs::remove(fixed_dst.GetPath());
       error = PutFile(src, fixed_dst);
       break;

source/Target/ProcessLaunchInfo.cpp

if (m_shell) {
         // There should only be one argument that is the shell command itself
         // to be used as is
         if (argv[0] && !argv[1])
           shell_command.Printf("%s", argv[0]);
         else
           return false;
       } else {
         for (size_t i = 0; argv[i] != nullptr; ++i) {
-          const char *arg =
-              Args::GetShellSafeArgument(m_shell, argv[i], safe_arg);
+          const char *arg = Args::GetShellSafeArgument(m_shell.GetFilename(),
+                                                       argv[i], safe_arg);
           shell_command.Printf(" %s", arg);
         }
       }
       shell_arguments.AppendArgument(shell_command.GetString());
       m_executable = m_shell;
       m_arguments = shell_arguments;
       return true;
     } else {

source/Target/Target.cpp

 #include "lldb/Breakpoint/BreakpointResolverName.h"
 #include "lldb/Breakpoint/BreakpointResolverScripted.h"
 #include "lldb/Breakpoint/Watchpoint.h"
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/Event.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/PluginManager.h"
-#include "lldb/Core/Section.h"
 #include "lldb/Core/SearchFilter.h"
+#include "lldb/Core/Section.h"
 #include "lldb/Core/SourceManager.h"
 #include "lldb/Core/StreamFile.h"
 #include "lldb/Core/StructuredDataImpl.h"
 #include "lldb/Core/ValueObject.h"
 #include "lldb/Expression/REPL.h"
 #include "lldb/Expression/UserExpression.h"
+#include "lldb/Host/FileSpec.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Host/PosixApi.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Interpreter/CommandReturnObject.h"
 #include "lldb/Interpreter/OptionGroupWatchpoint.h"
 #include "lldb/Interpreter/OptionValues.h"
 #include "lldb/Interpreter/Property.h"
 #include "lldb/Symbol/ClangASTContext.h"
 #include "lldb/Symbol/Function.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/Symbol.h"
 #include "lldb/Target/Language.h"
 #include "lldb/Target/LanguageRuntime.h"
 #include "lldb/Target/ObjCLanguageRuntime.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/SectionLoadList.h"
 #include "lldb/Target/StackFrame.h"
 #include "lldb/Target/SystemRuntime.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Target/ThreadSpec.h"
-#include "lldb/Utility/FileSpec.h"
+#include "lldb/Utility/JSON.h"
 #include "lldb/Utility/LLDBAssert.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/State.h"
 #include "lldb/Utility/StreamString.h"
 #include "lldb/Utility/Timer.h"
 
 using namespace lldb;
 using namespace lldb_private;
bool Target::EnableBreakpointByID(break_id_t break_id) {
 
   if (bp_sp) {
     bp_sp->SetEnabled(true);
     return true;
   }
   return false;
 }
 
+static StructuredData::ObjectSP ParseJSONFromFile(const FileSpec &input_spec,
+                                                  Status &error) {
+  StructuredData::ObjectSP return_sp;
+  if (!input_spec.Exists()) {
+    error.SetErrorStringWithFormatv("input file {0} does not exist.",
+                                    input_spec);
+    return return_sp;
+  }
+
+  auto buffer_or_error = llvm::MemoryBuffer::getFile(input_spec.GetPath());
+  if (!buffer_or_error) {
+    error.SetErrorStringWithFormatv("could not open input file: {0} - {1}.",
+                                    input_spec.GetPath(),
+                                    buffer_or_error.getError().message());
+    return return_sp;
+  }
+
+  return StructuredData::ParseJSON(buffer_or_error.get()->getBuffer());
+}
+
 Status Target::SerializeBreakpointsToFile(const FileSpec &file,
                                           const BreakpointIDList &bp_ids,
                                           bool append) {
   Status error;
 
   if (!file) {
     error.SetErrorString("Invalid FileSpec.");
     return error;
   }
 
   std::string path(file.GetPath());
   StructuredData::ObjectSP input_data_sp;
 
   StructuredData::ArraySP break_store_sp;
   StructuredData::Array *break_store_ptr = nullptr;
 
   if (append) {
-    input_data_sp = StructuredData::ParseJSONFromFile(file, error);
+    input_data_sp = ParseJSONFromFile(file, error);
     if (error.Success()) {
       break_store_ptr = input_data_sp->GetAsArray();
       if (!break_store_ptr) {
         error.SetErrorStringWithFormat(
             "Tried to append to invalid input file %s", path.c_str());
         return error;
       }
     }

 
 Status Target::CreateBreakpointsFromFile(const FileSpec &file,
                                          std::vector<std::string> &names,
                                          BreakpointIDList &new_bps) {
   std::unique_lock<std::recursive_mutex> lock;
   GetBreakpointList().GetListMutex(lock);
 
   Status error;
-  StructuredData::ObjectSP input_data_sp =
-      StructuredData::ParseJSONFromFile(file, error);
+  StructuredData::ObjectSP input_data_sp = ParseJSONFromFile(file, error);
   if (!error.Success()) {
     return error;
   } else if (!input_data_sp || !input_data_sp->IsValid()) {
     error.SetErrorStringWithFormat("Invalid JSON from input file: %s.",
                                    file.GetPath().c_str());
     return error;
   }
 

source/Utility/Args.cpp

 //===-- Args.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/Args.h"
+#include "lldb/Host/FileSpec.h"
 #include "lldb/Utility/ConstString.h"
-#include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/Stream.h"
 #include "lldb/Utility/StringList.h"
 #include "llvm/ADT/StringSwitch.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 // A helper function for argument parsing.
if (trailing) {
         s.erase(rpos + 1);
     }
   }
   if (return_null_if_empty && s.empty())
     return nullptr;
   return s.c_str();
 }
 
-const char *Args::GetShellSafeArgument(const FileSpec &shell,
+const char *Args::GetShellSafeArgument(ConstString shell,
                                        const char *unsafe_arg,
                                        std::string &safe_arg) {
   struct ShellDescriptor {
     ConstString m_basename;
     const char *m_escapables;
   };
 
   static ShellDescriptor g_Shells[] = {{ConstString("bash"), " '\"<>()&"},
                                        {ConstString("tcsh"), " '\"<>()&$"},
                                        {ConstString("sh"), " '\"<>()&"}};
 
   // safe minimal set
   const char *escapables = " '\"";
 
-  if (auto basename = shell.GetFilename()) {
+  if (shell) {
     for (const auto &Shell : g_Shells) {
-      if (Shell.m_basename == basename) {
+      if (Shell.m_basename == shell) {
         escapables = Shell.m_escapables;
         break;
       }
     }
   }
 
   safe_arg.assign(unsafe_arg);
   size_t prev_pos = 0;

source/Utility/CMakeLists.txt

add_lldb_library(lldbUtility
   Connection.cpp
   ConstString.cpp
   CompletionRequest.cpp
   DataBufferHeap.cpp
   DataBufferLLVM.cpp
   DataEncoder.cpp
   DataExtractor.cpp
   Environment.cpp
-  FileSpec.cpp
   IOObject.cpp
   JSON.cpp
   LLDBAssert.cpp
   Log.cpp
   Logging.cpp
   NameMatches.cpp
   Range.cpp
   RegisterValue.cpp

source/Utility/StructuredData.cpp

 //===---------------------StructuredData.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/StructuredData.h"
 #include "lldb/Utility/DataBuffer.h"
-#include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/JSON.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/Stream.h" // for Stream
 #include "lldb/Utility/StreamString.h"
 #include "llvm/ADT/STLExtras.h" // for make_unique
 #include "llvm/Support/MemoryBuffer.h"
 #include <cerrno>
 #include <cstdlib>
 #include <inttypes.h>
 #include <limits> // for numeric_limits
 
 using namespace lldb_private;
 
 //----------------------------------------------------------------------
 // Functions that use a JSONParser to parse JSON into StructuredData
 //----------------------------------------------------------------------
 static StructuredData::ObjectSP ParseJSONValue(JSONParser &json_parser);
 static StructuredData::ObjectSP ParseJSONObject(JSONParser &json_parser);
 static StructuredData::ObjectSP ParseJSONArray(JSONParser &json_parser);
 
-StructuredData::ObjectSP
-StructuredData::ParseJSONFromFile(const FileSpec &input_spec, Status &error) {
-  StructuredData::ObjectSP return_sp;
-  if (!input_spec.Exists()) {
-    error.SetErrorStringWithFormatv("input file {0} does not exist.",
-                                    input_spec);
-    return return_sp;
-  }
-
-  auto buffer_or_error = llvm::MemoryBuffer::getFile(input_spec.GetPath());
-  if (!buffer_or_error) {
-    error.SetErrorStringWithFormatv("could not open input file: {0} - {1}.",
-                                    input_spec.GetPath(),
-                                    buffer_or_error.getError().message());
-    return return_sp;
-  }
-
-  JSONParser json_parser(buffer_or_error.get()->getBuffer());
-  return_sp = ParseJSONValue(json_parser);
-  return return_sp;
-}
-
 static StructuredData::ObjectSP ParseJSONObject(JSONParser &json_parser) {
   // The "JSONParser::Token::ObjectStart" token should have already been
   // consumed by the time this function is called
   auto dict_up = llvm::make_unique<StructuredData::Dictionary>();
 
   std::string value;
   std::string key;
   while (1) {

tools/lldb-server/lldb-platform.cpp

 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/FileUtilities.h"
 
 #include "Acceptor.h"
 #include "LLDBServerUtilities.h"
 #include "Plugins/Process/gdb-remote/GDBRemoteCommunicationServerPlatform.h"
 #include "Plugins/Process/gdb-remote/ProcessGDBRemoteLog.h"
 #include "lldb/Host/ConnectionFileDescriptor.h"
+#include "lldb/Host/FileSpec.h"
 #include "lldb/Host/HostGetOpt.h"
 #include "lldb/Host/OptionParser.h"
 #include "lldb/Host/common/TCPSocket.h"
-#include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/Status.h"
 
 using namespace lldb;
 using namespace lldb_private;
 using namespace lldb_private::lldb_server;
 using namespace lldb_private::process_gdb_remote;
 using namespace llvm;
 

unittests/Expression/ClangParserTest.cpp

 //===-- ClangParserTest.cpp --------------------------------------*- C++-*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "Plugins/ExpressionParser/Clang/ClangHost.h"
 #include "TestingSupport/TestUtilities.h"
+#include "lldb/Host/FileSpec.h"
 #include "lldb/Host/HostInfo.h"
-#include "lldb/Utility/FileSpec.h"
 #include "lldb/lldb-defines.h"
 #include "gtest/gtest.h"
 
 using namespace lldb_private;
 
 namespace {
 struct ClangHostTest : public testing::Test {
   static void SetUpTestCase() { HostInfo::Initialize(); }

unittests/Host/CMakeLists.txt

 set (FILES
+  FileSpecTest.cpp
   FileSystemTest.cpp
   HostInfoTest.cpp
   HostTest.cpp
   MainLoopTest.cpp
   NativeProcessProtocolTest.cpp
   SocketAddressTest.cpp
   SocketTest.cpp
   SymbolsTest.cpp

unittests/Host/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"
+#include "lldb/Host/FileSpec.h"
 
 using namespace lldb_private;
 
 TEST(FileSpecTest, FileAndDirectoryComponents) {
   FileSpec fs_posix("/foo/bar", false, FileSpec::Style::posix);
   EXPECT_STREQ("/foo/bar", fs_posix.GetCString());
   EXPECT_STREQ("/foo", fs_posix.GetDirectory().GetCString());
   EXPECT_STREQ("bar", fs_posix.GetFilename().GetCString());
TEST(FileSpecTest, FormatFileSpec) {
   F = FileSpec("foo", false, 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[] = {
       "/",
       "/a",
       "/a/",
       "/a/b",
       "/a/b/",
       "//",
       "//a/",
       "//a/b",
       "//a/b/",
       "~",
       "~/",
       "~/a",
       "~/a/",
       "~/a/b"
       "~/a/b/",
       "/foo/.",
       "/foo/..",
       "/foo/../",
       "/foo/../.",
   };
-  for (const auto &path: not_relative) {
+  for (const auto &path : not_relative) {
     FileSpec spec(path, false, 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) {
+      ".",    "./",    ".///",   "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);
     EXPECT_TRUE(spec.IsRelative());
   }
 }
 
 TEST(FileSpecTest, RemoveLastPathComponent) {
   FileSpec fs_posix("/foo/bar/baz", false, FileSpec::Style::posix);
   EXPECT_STREQ("/foo/bar/baz", fs_posix.GetCString());

unittests/Host/FileSystemTest.cpp

 //===-- FileSystemTest.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/Host/FileSystem.h"
+#include "llvm/Support/Errc.h"
 
 extern const char *TestMainArgv0;
 
 using namespace lldb_private;
+using namespace llvm;
+using llvm::sys::fs::UniqueID;
+
+// Copied verbatim from unittests/Support/VirtualFileSystemTest.cpp
+namespace {
+struct DummyFile : public vfs::File {
+  vfs::Status S;
+  explicit DummyFile(vfs::Status S) : S(S) {}
+  llvm::ErrorOr<vfs::Status> status() override { return S; }
+  llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>>
+  getBuffer(const Twine &Name, int64_t FileSize, bool RequiresNullTerminator,
+            bool IsVolatile) override {
+    llvm_unreachable("unimplemented");
+  }
+  std::error_code close() override { return std::error_code(); }
+};
+
+class DummyFileSystem : public vfs::FileSystem {
+  int FSID;   // used to produce UniqueIDs
+  int FileID; // used to produce UniqueIDs
+  std::map<std::string, vfs::Status> FilesAndDirs;
+
+  static int getNextFSID() {
+    static int Count = 0;
+    return Count++;
+  }
+
+public:
+  DummyFileSystem() : FSID(getNextFSID()), FileID(0) {}
+
+  ErrorOr<vfs::Status> status(const Twine &Path) override {
+    std::map<std::string, vfs::Status>::iterator I =
+        FilesAndDirs.find(Path.str());
+    if (I == FilesAndDirs.end())
+      return make_error_code(llvm::errc::no_such_file_or_directory);
+    return I->second;
+  }
+  ErrorOr<std::unique_ptr<vfs::File>>
+  openFileForRead(const Twine &Path) override {
+    auto S = status(Path);
+    if (S)
+      return std::unique_ptr<vfs::File>(new DummyFile{*S});
+    return S.getError();
+  }
+  llvm::ErrorOr<std::string> getCurrentWorkingDirectory() const override {
+    return std::string();
+  }
+  std::error_code setCurrentWorkingDirectory(const Twine &Path) override {
+    return std::error_code();
+  }
+  // Map any symlink to "/symlink".
+  std::error_code getRealPath(const Twine &Path,
+                              SmallVectorImpl<char> &Output) const override {
+    auto I = FilesAndDirs.find(Path.str());
+    if (I == FilesAndDirs.end())
+      return make_error_code(llvm::errc::no_such_file_or_directory);
+    if (I->second.isSymlink()) {
+      Output.clear();
+      Twine("/symlink").toVector(Output);
+      return std::error_code();
+    }
+    Output.clear();
+    Path.toVector(Output);
+    return std::error_code();
+  }
+
+  struct DirIterImpl : public llvm::vfs::detail::DirIterImpl {
+    std::map<std::string, vfs::Status> &FilesAndDirs;
+    std::map<std::string, vfs::Status>::iterator I;
+    std::string Path;
+    bool isInPath(StringRef S) {
+      if (Path.size() < S.size() && S.find(Path) == 0) {
+        auto LastSep = S.find_last_of('/');
+        if (LastSep == Path.size() || LastSep == Path.size() - 1)
+          return true;
+      }
+      return false;
+    }
+    DirIterImpl(std::map<std::string, vfs::Status> &FilesAndDirs,
+                const Twine &_Path)
+        : FilesAndDirs(FilesAndDirs), I(FilesAndDirs.begin()),
+          Path(_Path.str()) {
+      for (; I != FilesAndDirs.end(); ++I) {
+        if (isInPath(I->first)) {
+          CurrentEntry =
+              vfs::directory_entry(I->second.getName(), I->second.getType());
+          break;
+        }
+      }
+    }
+    std::error_code increment() override {
+      ++I;
+      for (; I != FilesAndDirs.end(); ++I) {
+        if (isInPath(I->first)) {
+          CurrentEntry =
+              vfs::directory_entry(I->second.getName(), I->second.getType());
+          break;
+        }
+      }
+      if (I == FilesAndDirs.end())
+        CurrentEntry = vfs::directory_entry();
+      return std::error_code();
+    }
+  };
+
+  vfs::directory_iterator dir_begin(const Twine &Dir,
+                                    std::error_code &EC) override {
+    return vfs::directory_iterator(
+        std::make_shared<DirIterImpl>(FilesAndDirs, Dir));
+  }
+
+  void addEntry(StringRef Path, const vfs::Status &Status) {
+    FilesAndDirs[Path] = Status;
+  }
+
+  void addRegularFile(StringRef Path, sys::fs::perms Perms = sys::fs::all_all) {
+    vfs::Status S(Path, UniqueID(FSID, FileID++),
+                  std::chrono::system_clock::now(), 0, 0, 1024,
+                  sys::fs::file_type::regular_file, Perms);
+    addEntry(Path, S);
+  }
+
+  void addDirectory(StringRef Path, sys::fs::perms Perms = sys::fs::all_all) {
+    vfs::Status S(Path, UniqueID(FSID, FileID++),
+                  std::chrono::system_clock::now(), 0, 0, 0,
+                  sys::fs::file_type::directory_file, Perms);
+    addEntry(Path, S);
+  }
+
+  void addSymlink(StringRef Path) {
+    vfs::Status S(Path, UniqueID(FSID, FileID++),
+                  std::chrono::system_clock::now(), 0, 0, 0,
+                  sys::fs::file_type::symlink_file, sys::fs::all_all);
+    addEntry(Path, S);
+  }
+};
+} // namespace
 
 TEST(FileSystemTest, FileAndDirectoryComponents) {
   using namespace std::chrono;
 
   const bool resolve = true;
 #ifdef _WIN32
   FileSpec fs1("C:\\FILE\\THAT\\DOES\\NOT\\EXIST.TXT", !resolve);
 #else
   FileSpec fs1("/file/that/does/not/exist.txt", !resolve);
 #endif
   FileSpec fs2(TestMainArgv0, resolve);
 
-  EXPECT_EQ(system_clock::time_point(), FileSystem::GetModificationTime(fs1));
+  FileSystem fs;
+
+  EXPECT_EQ(system_clock::time_point(), fs.GetModificationTime(fs1));
   EXPECT_LT(system_clock::time_point() + hours(24 * 365 * 20),
-            FileSystem::GetModificationTime(fs2));
+            fs.GetModificationTime(fs2));
+}
+
+FileSystem::EnumerateDirectoryResult
+VFSCallback(void *baton, llvm::sys::fs::file_type file_type,
+            llvm::StringRef path) {
+  auto visited = static_cast<std::vector<std::string> *>(baton);
+  visited->push_back(path.str());
+  return FileSystem::eEnumerateDirectoryResultNext;
+}
+
+TEST(FileSystemTest, VirtualFileSystem) {
+  IntrusiveRefCntPtr<DummyFileSystem> D(new DummyFileSystem());
+  ErrorOr<vfs::Status> Status((std::error_code()));
+  D->addRegularFile("/foo");
+  D->addDirectory("/bar");
+  D->addSymlink("/baz");
+
+  FileSystem fs;
+  fs.ChangeFileSystem(D);
+
+  EXPECT_TRUE(fs.Exists("/foo"));
+
+  std::vector<std::string> visited;
+
+  constexpr bool find_directories = true;
+  constexpr bool find_files = true;
+  constexpr bool find_other = true;
+
+  fs.EnumerateDirectory("/", find_directories, find_files, find_other,
+                        VFSCallback, &visited);
+
+  EXPECT_EQ(visited.size(), (size_t)3);
+  EXPECT_TRUE(std::find(visited.begin(), visited.end(), "/foo") !=
+              visited.end());
+  EXPECT_TRUE(std::find(visited.begin(), visited.end(), "/bar") !=
+              visited.end());
+  EXPECT_TRUE(std::find(visited.begin(), visited.end(), "/baz") !=
+              visited.end());
 }

unittests/Process/minidump/MinidumpParserTest.cpp

 #include "Plugins/Process/Utility/RegisterContextLinux_i386.h"
 #include "Plugins/Process/Utility/RegisterContextLinux_x86_64.h"
 #include "Plugins/Process/minidump/MinidumpParser.h"
 #include "Plugins/Process/minidump/MinidumpTypes.h"
 #include "Plugins/Process/minidump/RegisterContextMinidump_x86_32.h"
 #include "Plugins/Process/minidump/RegisterContextMinidump_x86_64.h"
 
 #include "TestingSupport/TestUtilities.h"
+#include "lldb/Host/FileSpec.h"
 #include "lldb/Target/MemoryRegionInfo.h"
 #include "lldb/Utility/ArchSpec.h"
 #include "lldb/Utility/DataBufferLLVM.h"
 #include "lldb/Utility/DataExtractor.h"
-#include "lldb/Utility/FileSpec.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Path.h"
 #include "gtest/gtest.h"
 
 // C includes

unittests/SymbolFile/DWARF/SymbolFileDWARFTests.cpp

 
 #include "Plugins/ObjectFile/PECOFF/ObjectFilePECOFF.h"
 #include "Plugins/SymbolFile/DWARF/SymbolFileDWARF.h"
 #include "Plugins/SymbolFile/PDB/SymbolFilePDB.h"
 #include "TestingSupport/TestUtilities.h"
 #include "lldb/Core/Address.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleSpec.h"
+#include "lldb/Host/FileSpec.h"
 #include "lldb/Host/HostInfo.h"
 #include "lldb/Symbol/ClangASTContext.h"
 #include "lldb/Symbol/CompileUnit.h"
 #include "lldb/Symbol/LineTable.h"
 #include "lldb/Symbol/SymbolVendor.h"
 #include "lldb/Utility/ArchSpec.h"
-#include "lldb/Utility/FileSpec.h"
 
 using namespace lldb_private;
 
 class SymbolFileDWARFTests : public testing::Test {
 public:
   void SetUp() override {
 // Initialize and TearDown the plugin every time, so we get a brand new
 // AST every time so that modifications to the AST from each test don't

unittests/SymbolFile/PDB/SymbolFilePDBTests.cpp

 
 #include "Plugins/ObjectFile/PECOFF/ObjectFilePECOFF.h"
 #include "Plugins/SymbolFile/DWARF/SymbolFileDWARF.h"
 #include "Plugins/SymbolFile/PDB/SymbolFilePDB.h"
 #include "TestingSupport/TestUtilities.h"
 #include "lldb/Core/Address.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleSpec.h"
+#include "lldb/Host/FileSpec.h"
 #include "lldb/Host/HostInfo.h"
 #include "lldb/Symbol/ClangASTContext.h"
 #include "lldb/Symbol/CompileUnit.h"
 #include "lldb/Symbol/LineTable.h"
 #include "lldb/Symbol/SymbolVendor.h"
 #include "lldb/Utility/ArchSpec.h"
-#include "lldb/Utility/FileSpec.h"
 
 #if defined(_MSC_VER)
 #include "lldb/Host/windows/windows.h"
 #include <objbase.h>
 #endif
 
 #include <algorithm>
 

unittests/Target/PathMappingListTest.cpp

 //===-- PathMappingListTest.cpp ---------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
-#include "llvm/ADT/ArrayRef.h"
 #include "lldb/Target/PathMappingList.h"
-#include "lldb/Utility/FileSpec.h"
+#include "lldb/Host/FileSpec.h"
+#include "llvm/ADT/ArrayRef.h"
 #include "gtest/gtest.h"
 #include <utility>
 
 using namespace lldb_private;
 
 namespace {
 struct Matches {
   FileSpec original;

unittests/Utility/CMakeLists.txt

 add_lldb_unittest(UtilityTests
   AnsiTerminalTest.cpp
   ArgsTest.cpp
   OptionsWithRawTest.cpp
   ArchSpecTest.cpp
   CleanUpTest.cpp
   ConstStringTest.cpp
   CompletionRequestTest.cpp
   EnvironmentTest.cpp
-  FileSpecTest.cpp
   FlagsTest.cpp
   JSONTest.cpp
   LogTest.cpp
   NameMatchesTest.cpp
   PredicateTest.cpp
   RegisterValueTest.cpp
   ScalarTest.cpp
   StateTest.cpp

unittests/Utility/StructuredDataTest.cpp

TEST(StructuredDataTest, StringDump) {
   };
   for (auto P : TestCases) {
     StreamString S;
     const bool pretty_print = false;
     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);
-  EXPECT_EQ(nullptr, object_sp);
-
-  std::string input = GetInputFilePath("StructuredData-basic.json");
-  object_sp = StructuredData::ParseJSONFromFile(FileSpec(input, false), status);
-  ASSERT_NE(nullptr, object_sp);
-
-  StreamString S;
-  object_sp->Dump(S, false);
-  EXPECT_EQ("[1,2,3]", S.GetString());
-}