Move FileSystem functions from Host to their own class

[zturner]

Summary

As part of an effort to make Host not be such a monolithic, catch-all class, this patch moves file system logic out of Host and into a smaller, more appropriate class, which is also in the Host layer. More specifically, this patch makes the following changes:

1. Creates an lldbHostPosix library which can is useful for containing code which can compile and link on any posix-compliant platform
2. Creates Host/FileSystem.h which defines a common file system interface
3. Implements FileSystem.h in Host/windows/FileSystem.cpp and Host/posix/FileSystem.cpp
4. Creates Host/FileCache.h and Host/common/FileCache.cpp, which defines a class useful for storing handles to open files needed by the debugger

Tested on Windows and Linux using CMake. There are probably outstanding issues with the Mac build, as I don't have that setup yet. In particular, Mac build will need to create the lldbHostPosix library, link against it, and add the new files to the Xcode project.

[zturner]

Updated the Xcode project and confirmed that all tests pass on MacOSX and Linux.

Will submit this tomorrow unless there's objections.

[zturner]

Closed by commit rL215775 (authored by @zturner).

lldb/trunk/include/lldb/Host/FileCache.h

+//===-- FileCache.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_FileCache_h
+#define liblldb_Host_FileCache_h
+
+#include <stdint.h>
+
+#include "lldb/lldb-forward.h"
+#include "lldb/lldb-types.h"
+
+#include "lldb/Core/Error.h"
+#include "lldb/Host/FileSpec.h"
+
+namespace lldb_private
+{
+class FileCache
+{
+  private:
+    FileCache() {}
+
+    typedef std::map<lldb::user_id_t, lldb::FileSP> FDToFileMap;
+
+  public:
+    static FileCache &GetInstance();
+
+    lldb::user_id_t OpenFile(const FileSpec &file_spec, uint32_t flags, uint32_t mode, Error &error);
+    bool CloseFile(lldb::user_id_t fd, Error &error);
+
+    uint64_t WriteFile(lldb::user_id_t fd, uint64_t offset, const void *src, uint64_t src_len, Error &error);
+    uint64_t ReadFile(lldb::user_id_t fd, uint64_t offset, void *dst, uint64_t dst_len, Error &error);
+
+  private:
+    static FileCache *m_instance;
+
+    FDToFileMap m_cache;
+};
+}
+
+#endif

lldb/trunk/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 <stdint.h>
+
+#include "lldb/lldb-types.h"
+
+#include "lldb/Core/Error.h"
+#include "lldb/Host/FileSpec.h"
+
+namespace lldb_private
+{
+class FileSystem
+{
+  public:
+    static FileSpec::PathSyntax GetNativePathSyntax();
+
+    static Error MakeDirectory(const char *path, uint32_t mode);
+    static Error DeleteDirectory(const char *path, bool recurse);
+
+    static Error GetFilePermissions(const char *path, uint32_t &file_permissions);
+    static Error SetFilePermissions(const char *path, uint32_t file_permissions);
+    static lldb::user_id_t GetFileSize(const FileSpec &file_spec);
+    static bool GetFileExists(const FileSpec &file_spec);
+
+    static Error Symlink(const char *src, const char *dst);
+    static Error Readlink(const char *path, char *buf, size_t buf_len);
+    static Error Unlink(const char *path);
+
+    static bool CalculateMD5(const FileSpec &file_spec, uint64_t &low, uint64_t &high);
+};
+}
+
+#endif

lldb/trunk/include/lldb/Host/Host.h

public:
     ///
     /// @return
     ///     \b true if the thread name was able to be set, \b false
     ///     otherwise.
     static bool
     SetShortThreadName (lldb::pid_t pid, lldb::tid_t tid, const char *name, size_t len);
 
     //------------------------------------------------------------------
-    /// Gets the host environment's native path syntax (Windows / Posix).
-    ///
-    /// @return
-    ///     \b One of {FileSpec::ePathSyntaxWindows, FileSpec::ePathSyntaxPosix}
-    //------------------------------------------------------------------
-    static FileSpec::PathSyntax
-    GetHostPathSyntax();
-
-    //------------------------------------------------------------------
     /// Gets the FileSpec of the user profile directory.  On Posix-platforms
     /// this is ~, and on windows this is generally something like
     /// C:\Users\Alice.
     ///
     /// @return
     ///     \b A file spec with the path to the user's home directory.
     //------------------------------------------------------------------
     static FileSpec
#endif
 
     static Error
     DynamicLibraryClose (void *dynamic_library_handle);
 
     static void *
     DynamicLibraryGetSymbol (void *dynamic_library_handle, 
                              const char *symbol_name, 
                              Error &error);
-    
-    static Error
-    MakeDirectory (const char* path, uint32_t mode);
-    
-    static Error
-    RemoveDirectory (const char* path, bool recurse);
-    
-    static Error
-    GetFilePermissions (const char* path, uint32_t &file_permissions);
-
-    static Error
-    SetFilePermissions (const char* path, uint32_t file_permissions);
-    
-    static Error
-    Symlink (const char *src, const char *dst);
-    
-    static Error
-    Readlink (const char *path, char *buf, size_t buf_len);
-
-    static Error
-    Unlink (const char *path);
-
-    static lldb::user_id_t
-    OpenFile (const FileSpec& file_spec,
-              uint32_t flags,
-              uint32_t mode,
-              Error &error);
-    
-    static bool
-    CloseFile (lldb::user_id_t fd,
-               Error &error);
-    
-    static uint64_t
-    WriteFile (lldb::user_id_t fd,
-               uint64_t offset,
-               const void* src,
-               uint64_t src_len,
-               Error &error);
-    
-    static uint64_t
-    ReadFile (lldb::user_id_t fd,
-              uint64_t offset,
-              void* dst,
-              uint64_t dst_len,
-              Error &error);
-
-    static lldb::user_id_t
-    GetFileSize (const FileSpec& file_spec);
-    
-    static bool
-    GetFileExists (const FileSpec& file_spec);
-    
-    static bool
-    CalculateMD5 (const FileSpec& file_spec,
-                  uint64_t &low,
-                  uint64_t &high);
-
 };
 
 } // namespace lldb_private
 
 #endif  // #if defined(__cplusplus)
 #endif  // liblldb_Host_h_

lldb/trunk/include/lldb/Target/FileAction.h

public:
     void Clear();
 
     bool Close(int fd);
 
     bool Duplicate(int fd, int dup_fd);
 
     bool Open(int fd, const char *path, bool read, bool write);
 
-    int GetFD() const { return m_fd; }
+    int
+    GetFD() const
+    {
+        return m_fd;
+    }
 
-    Action GetAction() const { return m_action; }
+    Action
+    GetAction() const
+    {
+        return m_action;
+    }
 
-    int GetActionArgument() const { return m_arg; }
+    int
+    GetActionArgument() const
+    {
+        return m_arg;
+    }
 
     const char *GetPath() const;
 
   protected:
     Action m_action;    // The action for this file
     int m_fd;           // An existing file descriptor
     int m_arg;          // oflag for eFileActionOpen*, dup_fd for eFileActionDuplicate
     std::string m_path; // A file path to use for opening after fork or posix_spawn
 };
 
 } // namespace lldb_private
 
 #endif

lldb/trunk/lldb.xcodeproj/project.pbxproj

/* Begin PBXBuildFile section */
     26F73062139D8FDB00FD51C7 /* History.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 26F73061139D8FDB00FD51C7 /* History.cpp */; };
     26FFC19914FC072100087D58 /* AuxVector.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 26FFC19314FC072100087D58 /* AuxVector.cpp */; };
     26FFC19A14FC072100087D58 /* AuxVector.h in Headers */ = {isa = PBXBuildFile; fileRef = 26FFC19414FC072100087D58 /* AuxVector.h */; };
     26FFC19B14FC072100087D58 /* DYLDRendezvous.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 26FFC19514FC072100087D58 /* DYLDRendezvous.cpp */; };
     26FFC19C14FC072100087D58 /* DYLDRendezvous.h in Headers */ = {isa = PBXBuildFile; fileRef = 26FFC19614FC072100087D58 /* DYLDRendezvous.h */; };
     26FFC19D14FC072100087D58 /* DynamicLoaderPOSIXDYLD.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 26FFC19714FC072100087D58 /* DynamicLoaderPOSIXDYLD.cpp */; };
     26FFC19E14FC072100087D58 /* DynamicLoaderPOSIXDYLD.h in Headers */ = {isa = PBXBuildFile; fileRef = 26FFC19814FC072100087D58 /* DynamicLoaderPOSIXDYLD.h */; };
     3FDFDDBD199C3A06009756A7 /* FileAction.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 3FDFDDBC199C3A06009756A7 /* FileAction.cpp */; };
+    3FDFDDBF199D345E009756A7 /* FileCache.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 3FDFDDBE199D345E009756A7 /* FileCache.cpp */; };
+    3FDFDDC6199D37ED009756A7 /* FileSystem.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 3FDFDDC5199D37ED009756A7 /* FileSystem.cpp */; };
     449ACC98197DEA0B008D175E /* FastDemangle.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 449ACC96197DE9EC008D175E /* FastDemangle.cpp */; };
     490A36C0180F0E6F00BA31F8 /* PlatformWindows.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 490A36BD180F0E6F00BA31F8 /* PlatformWindows.cpp */; };
     490A36C2180F0E9300BA31F8 /* PlatformWindows.h in Headers */ = {isa = PBXBuildFile; fileRef = 490A36BE180F0E6F00BA31F8 /* PlatformWindows.h */; };
     490A966B1628C3BF00F0002E /* SBDeclaration.h in Headers */ = {isa = PBXBuildFile; fileRef = 9452573816262CEF00325455 /* SBDeclaration.h */; settings = {ATTRIBUTES = (Public, ); }; };
     494260DA14579144003C1C78 /* VerifyDecl.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 494260D914579144003C1C78 /* VerifyDecl.cpp */; };
     4966DCC4148978A10028481B /* ClangExternalASTSourceCommon.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4966DCC3148978A10028481B /* ClangExternalASTSourceCommon.cpp */; };
     49A1CAC51430E8DE00306AC9 /* ExpressionSourceCode.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 49A1CAC31430E8BD00306AC9 /* ExpressionSourceCode.cpp */; };
     49A71FE7141FFA5C00D59478 /* IRInterpreter.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 496B01581406DE8900F830D5 /* IRInterpreter.cpp */; };
/* Begin PBXFileReference section */
     26FFC19314FC072100087D58 /* AuxVector.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = AuxVector.cpp; sourceTree = "<group>"; };
     26FFC19414FC072100087D58 /* AuxVector.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = AuxVector.h; sourceTree = "<group>"; };
     26FFC19514FC072100087D58 /* DYLDRendezvous.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = DYLDRendezvous.cpp; sourceTree = "<group>"; };
     26FFC19614FC072100087D58 /* DYLDRendezvous.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = DYLDRendezvous.h; sourceTree = "<group>"; };
     26FFC19714FC072100087D58 /* DynamicLoaderPOSIXDYLD.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = DynamicLoaderPOSIXDYLD.cpp; sourceTree = "<group>"; };
     26FFC19814FC072100087D58 /* DynamicLoaderPOSIXDYLD.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = DynamicLoaderPOSIXDYLD.h; sourceTree = "<group>"; };
     3FDFD6C3199C396E009756A7 /* FileAction.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = FileAction.h; path = include/lldb/Target/FileAction.h; sourceTree = "<group>"; };
     3FDFDDBC199C3A06009756A7 /* FileAction.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = FileAction.cpp; path = source/Target/FileAction.cpp; sourceTree = "<group>"; };
+    3FDFDDBE199D345E009756A7 /* FileCache.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = FileCache.cpp; path = source/Host/common/FileCache.cpp; sourceTree = "<group>"; };
+    3FDFDDC0199D34E2009756A7 /* FileCache.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; name = FileCache.h; path = include/lldb/Host/FileCache.h; sourceTree = "<group>"; };
+    3FDFDDC1199D34E2009756A7 /* FileSystem.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; name = FileSystem.h; path = include/lldb/Host/FileSystem.h; sourceTree = "<group>"; };
+    3FDFDDC5199D37ED009756A7 /* FileSystem.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = FileSystem.cpp; path = source/Host/posix/FileSystem.cpp; sourceTree = "<group>"; };
     449ACC96197DE9EC008D175E /* FastDemangle.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = FastDemangle.cpp; path = source/Core/FastDemangle.cpp; sourceTree = "<group>"; };
     4906FD4012F2255300A2A77C /* ASTDumper.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = ASTDumper.cpp; path = source/Expression/ASTDumper.cpp; sourceTree = "<group>"; };
     4906FD4412F2257600A2A77C /* ASTDumper.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = ASTDumper.h; path = include/lldb/Expression/ASTDumper.h; sourceTree = "<group>"; };
     490A36BD180F0E6F00BA31F8 /* PlatformWindows.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = PlatformWindows.cpp; sourceTree = "<group>"; };
     490A36BE180F0E6F00BA31F8 /* PlatformWindows.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = PlatformWindows.h; sourceTree = "<group>"; };
     4911934B1226383D00578B7F /* ASTStructExtractor.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = ASTStructExtractor.h; path = include/lldb/Expression/ASTStructExtractor.h; sourceTree = "<group>"; };
     491193501226386000578B7F /* ASTStructExtractor.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = ASTStructExtractor.cpp; path = source/Expression/ASTStructExtractor.cpp; sourceTree = "<group>"; };
     49307AAD11DEA4D90081F992 /* IRForTarget.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = IRForTarget.cpp; path = source/Expression/IRForTarget.cpp; sourceTree = "<group>"; };
26BC7DBE10F1B78200F91463 /* Expression */ = {
       sourceTree = "<group>";
     };
     26BC7DD010F1B7C100F91463 /* Host */ = {
       isa = PBXGroup;
       children = (
         69A01E1A1236C5D400C660B5 /* common */,
         233B009C19610D130090E598 /* linux */,
         26BC7EE510F1B88100F91463 /* MacOSX */,
+        3FDFDDC4199D37BE009756A7 /* posix */,
         26BC7DD210F1B7D500F91463 /* Condition.h */,
         266F5CBB12FC846200DFCE33 /* Config.h */,
         9456F2231616645A00656F91 /* DynamicLibrary.h */,
         26CFDCA01861638D000E63E5 /* Editline.h */,
         26BC7DD310F1B7D500F91463 /* Endian.h */,
         260C6EA013011578005E16B0 /* File.h */,
+        3FDFDDC0199D34E2009756A7 /* FileCache.h */,
+        3FDFDDBE199D345E009756A7 /* FileCache.cpp */,
         26FA4315130103F400E71120 /* FileSpec.h */,
+        3FDFDDC1199D34E2009756A7 /* FileSystem.h */,
         26BC7DD410F1B7D500F91463 /* Host.h */,
         236124A61986B50E004EFC37 /* IoObject.h */,
         26BC7DD510F1B7D500F91463 /* Mutex.h */,
         232CB60B191E00CC00EF39FC /* NativeBreakpoint.cpp */,
         232CB60C191E00CC00EF39FC /* NativeBreakpoint.h */,
         232CB60D191E00CC00EF39FC /* NativeBreakpointList.cpp */,
         232CB60E191E00CC00EF39FC /* NativeBreakpointList.h */,
         232CB60F191E00CC00EF39FC /* NativeProcessProtocol.cpp */,
26FFC19214FC072100087D58 /* POSIX-DYLD */ = {
         26FFC19514FC072100087D58 /* DYLDRendezvous.cpp */,
         26FFC19614FC072100087D58 /* DYLDRendezvous.h */,
         26FFC19714FC072100087D58 /* DynamicLoaderPOSIXDYLD.cpp */,
         26FFC19814FC072100087D58 /* DynamicLoaderPOSIXDYLD.h */,
       );
       path = "POSIX-DYLD";
       sourceTree = "<group>";
     };
+    3FDFDDC4199D37BE009756A7 /* posix */ = {
+      isa = PBXGroup;
+      children = (
+        3FDFDDC5199D37ED009756A7 /* FileSystem.cpp */,
+      );
+      name = posix;
+      sourceTree = "<group>";
+    };
     490A36BA180F0E6F00BA31F8 /* Windows */ = {
       isa = PBXGroup;
       children = (
         490A36BD180F0E6F00BA31F8 /* PlatformWindows.cpp */,
         490A36BE180F0E6F00BA31F8 /* PlatformWindows.h */,
       );
       path = Windows;
       sourceTree = "<group>";
2689FFC613353D7A00698AC0 /* Sources */ = {
         2689003413353E0400698AC0 /* ConnectionFileDescriptor.cpp in Sources */,
         2689003513353E0400698AC0 /* ConstString.cpp in Sources */,
         2689003613353E0400698AC0 /* DataBufferHeap.cpp in Sources */,
         2689003713353E0400698AC0 /* DataBufferMemoryMap.cpp in Sources */,
         2689003813353E0400698AC0 /* DataExtractor.cpp in Sources */,
         2689003913353E0400698AC0 /* Debugger.cpp in Sources */,
         2689003A13353E0400698AC0 /* Disassembler.cpp in Sources */,
         236124A51986B4E2004EFC37 /* Socket.cpp in Sources */,
+        3FDFDDBF199D345E009756A7 /* FileCache.cpp in Sources */,
         AF1729D7182C907200E0AB97 /* HistoryUnwind.cpp in Sources */,
         2689003B13353E0400698AC0 /* EmulateInstruction.cpp in Sources */,
         2689003C13353E0400698AC0 /* Error.cpp in Sources */,
         2689003D13353E0400698AC0 /* Event.cpp in Sources */,
         2689003E13353E0400698AC0 /* FileSpecList.cpp in Sources */,
         2689004013353E0400698AC0 /* Language.cpp in Sources */,
         2689004113353E0400698AC0 /* Listener.cpp in Sources */,
         2689004213353E0400698AC0 /* Log.cpp in Sources */,
2689FFC613353D7A00698AC0 /* Sources */ = {
         2689011013353E8200698AC0 /* SharingPtr.cpp in Sources */,
         2689011113353E8200698AC0 /* StringExtractor.cpp in Sources */,
         2689011213353E8200698AC0 /* StringExtractorGDBRemote.cpp in Sources */,
         2689011313353E8200698AC0 /* PseudoTerminal.cpp in Sources */,
         94D6A0AA16CEB55F00833B6E /* NSArray.cpp in Sources */,
         26BC17AB18C7F4CB00D2196D /* ProcessElfCore.cpp in Sources */,
         AF1F7B07189C904B0087DB9C /* AppleGetPendingItemsHandler.cpp in Sources */,
         26B1FCC21338115F002886E2 /* Host.mm in Sources */,
+        3FDFDDC6199D37ED009756A7 /* FileSystem.cpp in Sources */,
         26744EF11338317700EF765A /* GDBRemoteCommunicationClient.cpp in Sources */,
         26744EF31338317700EF765A /* GDBRemoteCommunicationServer.cpp in Sources */,
         264A97BF133918BC0017F0BE /* PlatformRemoteGDBServer.cpp in Sources */,
         2697A54D133A6305004E4240 /* PlatformDarwin.cpp in Sources */,
         26651A18133BF9E0005B64B7 /* Opcode.cpp in Sources */,
         266603CA1345B5A8004DA8B6 /* ConnectionSharedMemory.cpp in Sources */,
         2671A0D013482601003A87BB /* ConnectionMachPort.cpp in Sources */,
         4CABA9E0134A8BCD00539BDD /* ValueObjectMemory.cpp in Sources */,

lldb/trunk/source/CMakeLists.txt

 if ( CMAKE_SYSTEM_NAME MATCHES "Windows" )
   list(APPEND LLDB_USED_LIBS
     lldbHostWindows
     lldbPluginProcessWindows
     lldbPluginProcessElfCore
     lldbPluginJITLoaderGDB
     Ws2_32
     )
+else ()
+  list(APPEND LLDB_USED_LIBS
+    lldbHostPosix
+    )
 endif ()
 
 # Linux-only libraries
 if ( CMAKE_SYSTEM_NAME MATCHES "Linux" )
   list(APPEND LLDB_USED_LIBS
     lldbHostLinux
     lldbPluginProcessLinux
     lldbPluginProcessPOSIX

lldb/trunk/source/Host/CMakeLists.txt

 add_subdirectory(common)
 
+if (CMAKE_SYSTEM_NAME MATCHES "Windows")
+  add_subdirectory(windows)
+else()
+  add_subdirectory(posix)
+
   if (CMAKE_SYSTEM_NAME MATCHES "Darwin")
-  add_subdirectory(macosx)
+    add_subdirectory(macosx)
   elseif (CMAKE_SYSTEM_NAME MATCHES "Linux")
-  add_subdirectory(linux)
+    add_subdirectory(linux)
   elseif (CMAKE_SYSTEM_NAME MATCHES "FreeBSD")
-  add_subdirectory(freebsd)
-elseif (CMAKE_SYSTEM_NAME MATCHES "Windows")
-  add_subdirectory(windows)
+    add_subdirectory(freebsd)
+  endif()
 endif()

lldb/trunk/source/Host/common/CMakeLists.txt

 set(LLVM_NO_RTTI 1)
 
 add_lldb_library(lldbHostCommon
   Condition.cpp
   DynamicLibrary.cpp
   Editline.cpp
   File.cpp
+  FileCache.cpp
   FileSpec.cpp
   Host.cpp
   IOObject.cpp
   Mutex.cpp
   NativeBreakpoint.cpp
   NativeBreakpointList.cpp
   NativeProcessProtocol.cpp
   NativeThreadProtocol.cpp

lldb/trunk/source/Host/common/FileCache.cpp

+//===-- FileCache.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/FileCache.h"
+
+#include "lldb/Host/File.h"
+
+using namespace lldb;
+using namespace lldb_private;
+
+FileCache *FileCache::m_instance = nullptr;
+
+FileCache &
+FileCache::GetInstance()
+{
+    if (m_instance == nullptr)
+        m_instance = new FileCache();
+
+    return *m_instance;
+}
+
+lldb::user_id_t
+FileCache::OpenFile(const FileSpec &file_spec, uint32_t flags, uint32_t mode, Error &error)
+{
+    std::string path(file_spec.GetPath());
+    if (path.empty())
+    {
+        error.SetErrorString("empty path");
+        return UINT64_MAX;
+    }
+    FileSP file_sp(new File());
+    error = file_sp->Open(path.c_str(), flags, mode);
+    if (file_sp->IsValid() == false)
+        return UINT64_MAX;
+    lldb::user_id_t fd = file_sp->GetDescriptor();
+    m_cache[fd] = file_sp;
+    return fd;
+}
+
+bool
+FileCache::CloseFile(lldb::user_id_t fd, Error &error)
+{
+    if (fd == UINT64_MAX)
+    {
+        error.SetErrorString("invalid file descriptor");
+        return false;
+    }
+    FDToFileMap::iterator pos = m_cache.find(fd);
+    if (pos == m_cache.end())
+    {
+        error.SetErrorStringWithFormat("invalid host file descriptor %" PRIu64, fd);
+        return false;
+    }
+    FileSP file_sp = pos->second;
+    if (!file_sp)
+    {
+        error.SetErrorString("invalid host backing file");
+        return false;
+    }
+    error = file_sp->Close();
+    m_cache.erase(pos);
+    return error.Success();
+}
+
+uint64_t
+FileCache::WriteFile(lldb::user_id_t fd, uint64_t offset, const void *src, uint64_t src_len, Error &error)
+{
+    if (fd == UINT64_MAX)
+    {
+        error.SetErrorString("invalid file descriptor");
+        return UINT64_MAX;
+    }
+    FDToFileMap::iterator pos = m_cache.find(fd);
+    if (pos == m_cache.end())
+    {
+        error.SetErrorStringWithFormat("invalid host file descriptor %" PRIu64, fd);
+        return false;
+    }
+    FileSP file_sp = pos->second;
+    if (!file_sp)
+    {
+        error.SetErrorString("invalid host backing file");
+        return UINT64_MAX;
+    }
+    if (static_cast<uint64_t>(file_sp->SeekFromStart(offset, &error)) != offset || error.Fail())
+        return UINT64_MAX;
+    size_t bytes_written = src_len;
+    error = file_sp->Write(src, bytes_written);
+    if (error.Fail())
+        return UINT64_MAX;
+    return bytes_written;
+}
+
+uint64_t
+FileCache::ReadFile(lldb::user_id_t fd, uint64_t offset, void *dst, uint64_t dst_len, Error &error)
+{
+    if (fd == UINT64_MAX)
+    {
+        error.SetErrorString("invalid file descriptor");
+        return UINT64_MAX;
+    }
+    FDToFileMap::iterator pos = m_cache.find(fd);
+    if (pos == m_cache.end())
+    {
+        error.SetErrorStringWithFormat("invalid host file descriptor %" PRIu64, fd);
+        return false;
+    }
+    FileSP file_sp = pos->second;
+    if (!file_sp)
+    {
+        error.SetErrorString("invalid host backing file");
+        return UINT64_MAX;
+    }
+    if (static_cast<uint64_t>(file_sp->SeekFromStart(offset, &error)) != offset || error.Fail())
+        return UINT64_MAX;
+    size_t bytes_read = dst_len;
+    error = file_sp->Read(dst, bytes_read);
+    if (error.Fail())
+        return UINT64_MAX;
+    return bytes_read;
+}

lldb/trunk/source/Host/common/FileSpec.cpp

 #include <string.h>
 #include <fstream>
 
 #include "lldb/Host/Config.h" // Have to include this before we test the define...
 #ifdef LLDB_CONFIG_TILDE_RESOLVES_TO_USER
 #include <pwd.h>
 #endif
 
-#include "llvm/ADT/StringRef.h"
-#include "llvm/Support/FileSystem.h"
-#include "llvm/Support/Path.h"
-#include "llvm/Support/Program.h"
-
-#include "lldb/Core/StreamString.h"
-#include "lldb/Host/File.h"
-#include "lldb/Host/FileSpec.h"
-#include "lldb/Host/Host.h"
 #include "lldb/Core/DataBufferHeap.h"
 #include "lldb/Core/DataBufferMemoryMap.h"
 #include "lldb/Core/RegularExpression.h"
+#include "lldb/Core/StreamString.h"
 #include "lldb/Core/Stream.h"
+#include "lldb/Host/File.h"
+#include "lldb/Host/FileSpec.h"
+#include "lldb/Host/FileSystem.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Utility/CleanUp.h"
 
+#include "llvm/ADT/StringRef.h"
+#include "llvm/Support/FileSystem.h"
+#include "llvm/Support/Path.h"
+#include "llvm/Support/Program.h"
+
 using namespace lldb;
 using namespace lldb_private;
 
 static bool
 GetFileStats (const FileSpec *file_spec, struct stat *stats_ptr)
 {
     char resolved_path[PATH_MAX];
     if (file_spec->GetPath (resolved_path, sizeof(resolved_path)))

 #ifdef LLDB_CONFIG_TILDE_RESOLVES_TO_USER
     if (path[0] == '~')
         ResolveUsername(path);
 #endif // #ifdef LLDB_CONFIG_TILDE_RESOLVES_TO_USER
 
     llvm::sys::fs::make_absolute(path);
 }
 
-FileSpec::FileSpec() :
-    m_directory(),
-    m_filename(),
-    m_syntax(Host::GetHostPathSyntax())
+FileSpec::FileSpec()
+    : m_directory()
+    , m_filename()
+    , m_syntax(FileSystem::GetNativePathSyntax())
 {
 }
 
 //------------------------------------------------------------------
 // Default constructor that can take an optional full path to a
 // file on disk.
 //------------------------------------------------------------------
 FileSpec::FileSpec(const char *pathname, bool resolve_path, PathSyntax syntax) :
if (this != &rhs)
         m_is_resolved = rhs.m_is_resolved;
         m_syntax = rhs.m_syntax;
     }
     return *this;
 }
 
 void FileSpec::Normalize(llvm::SmallVectorImpl<char> &path, PathSyntax syntax)
 {
-    if (syntax == ePathSyntaxPosix || (syntax == ePathSyntaxHostNative && Host::GetHostPathSyntax() == ePathSyntaxPosix))
+    if (syntax == ePathSyntaxPosix ||
+        (syntax == ePathSyntaxHostNative && FileSystem::GetNativePathSyntax() == ePathSyntaxPosix))
         return;
 
     std::replace(path.begin(), path.end(), '\\', '/');
 }
 
 void FileSpec::DeNormalize(llvm::SmallVectorImpl<char> &path, PathSyntax syntax)
 {
-    if (syntax == ePathSyntaxPosix || (syntax == ePathSyntaxHostNative && Host::GetHostPathSyntax() == ePathSyntaxPosix))
+    if (syntax == ePathSyntaxPosix ||
+        (syntax == ePathSyntaxHostNative && FileSystem::GetNativePathSyntax() == ePathSyntaxPosix))
         return;
 
     std::replace(path.begin(), path.end(), '/', '\\');
 }
 
 //------------------------------------------------------------------
 // Update the contents of this object with a new path. The path will
 // be split up into a directory and filename and stored as uniqued
 // string values for quick comparison and efficient memory usage.
 //------------------------------------------------------------------
 void
 FileSpec::SetFile (const char *pathname, bool resolve, PathSyntax syntax)
 {
     m_filename.Clear();
     m_directory.Clear();
     m_is_resolved = false;
-    m_syntax = (syntax == ePathSyntaxHostNative) ? Host::GetHostPathSyntax() : syntax;
+    m_syntax = (syntax == ePathSyntaxHostNative) ? FileSystem::GetNativePathSyntax() : syntax;
 
     if (pathname == NULL || pathname[0] == '\0')
         return;
 
     llvm::SmallString<64> normalized(pathname);
     Normalize(normalized, syntax);
 
     if (resolve)
#endif
     return eFileTypeInvalid;
 }
 
 uint32_t
 FileSpec::GetPermissions () const
 {
     uint32_t file_permissions = 0;
     if (*this)
-        Host::GetFilePermissions(GetPath().c_str(), file_permissions);
+        FileSystem::GetFilePermissions(GetPath().c_str(), file_permissions);
     return file_permissions;
 }
 
 TimeValue
 FileSpec::GetModificationTime () const
 {
     TimeValue mod_time;
     struct stat file_stats;

lldb/trunk/source/Host/common/Host.cpp

 #include "lldb/Core/Error.h"
 #include "lldb/Core/Log.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/StreamString.h"
 #include "lldb/Core/ThreadSafeSTLMap.h"
 #include "lldb/Host/Config.h"
 #include "lldb/Host/Endian.h"
 #include "lldb/Host/FileSpec.h"
+#include "lldb/Host/FileSystem.h"
 #include "lldb/Host/Mutex.h"
 #include "lldb/Target/FileAction.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/ProcessLaunchInfo.h"
 #include "lldb/Target/TargetList.h"
 #include "lldb/Utility/CleanUp.h"
 
 #include "llvm/ADT/STLExtras.h"
if (namebuflen > 0)
         }
         return Host::SetThreadName (pid, tid, namebuf.get());
     }
     return false;
 }
 
 #endif
 
-FileSpec::PathSyntax
-Host::GetHostPathSyntax()
-{
-#if defined(_WIN32)
-    return FileSpec::ePathSyntaxWindows;
-#else
-    return FileSpec::ePathSyntaxPosix;
-#endif
-}
-
 FileSpec
 Host::GetUserProfileFileSpec ()
 {
     static FileSpec g_profile_filespec;
     if (!g_profile_filespec)
     {
         llvm::SmallString<64> path;
         llvm::sys::path::home_directory(path);

 {
     // Get the process specific LLDB temporary directory and delete it.
     FileSpec tmpdir_file_spec;
     if (Host::GetLLDBPath (ePathTypeLLDBTempSystemDir, tmpdir_file_spec))
     {
         // Remove the LLDB temporary directory if we have one. Set "recurse" to
         // true to all files that were created for the LLDB process can be cleaned up.
         const bool recurse = true;
-        Host::RemoveDirectory(tmpdir_file_spec.GetDirectory().GetCString(), recurse);
+        FileSystem::DeleteDirectory(tmpdir_file_spec.GetDirectory().GetCString(), recurse);
     }
 }
 
 bool
 Host::GetLLDBPath (PathType path_type, FileSpec &file_spec)
 {
     // To get paths related to LLDB we get the path to the executable that
     // contains this function. On MacOSX this will be "LLDB.framework/.../LLDB",
case ePathTypeLLDBTempSystemDir:
                     tmpdir_cstr = getenv("TMP");
                     if (tmpdir_cstr == NULL)
                         tmpdir_cstr = getenv("TEMP");
                 }
                 if (tmpdir_cstr)
                 {
                     StreamString pid_tmpdir;
                     pid_tmpdir.Printf("%s/lldb", tmpdir_cstr);
-                    if (Host::MakeDirectory(pid_tmpdir.GetString().c_str(), eFilePermissionsDirectoryDefault).Success())
+                    if (FileSystem::MakeDirectory(pid_tmpdir.GetString().c_str(), eFilePermissionsDirectoryDefault)
+                            .Success())
                     {
                         pid_tmpdir.Printf("/%" PRIu64, Host::GetCurrentProcessID());
-                        if (Host::MakeDirectory(pid_tmpdir.GetString().c_str(), eFilePermissionsDirectoryDefault).Success())
+                        if (FileSystem::MakeDirectory(pid_tmpdir.GetString().c_str(), eFilePermissionsDirectoryDefault)
+                                .Success())
                         {
                             // Make an atexit handler to clean up the process specify LLDB temp dir
                             // and all of its contents.
                             ::atexit (CleanupProcessSpecificLLDBTempDir);
                             g_lldb_tmp_dir.SetCString(pid_tmpdir.GetString().c_str());
                             if (log)
                                 log->Printf("Host::GetLLDBPath(ePathTypeLLDBTempSystemDir) => '%s'", g_lldb_tmp_dir.GetCString());
                             
if (num_file_actions > 0)
         // we return in the middle of this function.
         lldb_utility::CleanUp <posix_spawn_file_actions_t *, int> posix_spawn_file_actions_cleanup (&file_actions, posix_spawn_file_actions_destroy);
 
         for (size_t i=0; i<num_file_actions; ++i)
         {
             const FileAction *launch_file_action = launch_info.GetFileActionAtIndex(i);
             if (launch_file_action)
             {
-                if (!AddPosixSpawnFileAction (&file_actions,
-                                                                             launch_file_action,
-                                                                             log,
-                                                                             error))
+                if (!AddPosixSpawnFileAction(&file_actions, launch_file_action, log, error))
                     return error;
             }
         }
 
         error.SetError (::posix_spawnp (&pid,
                                         exe_path,
                                         &file_actions,
                                         &attr,
#else
                     current_dir);
         }
 #endif
     }
 
     return error;
 }
 
-bool Host::AddPosixSpawnFileAction(void *_file_actions, const FileAction *info, Log *log, Error &error)
+bool
+Host::AddPosixSpawnFileAction(void *_file_actions, const FileAction *info, Log *log, Error &error)
 {
     if (info == NULL)
         return false;
 
     posix_spawn_file_actions_t *file_actions = reinterpret_cast<posix_spawn_file_actions_t *>(_file_actions);
 
     switch (info->GetAction())
     {
         case FileAction::eFileActionNone:
             error.Clear();
             break;
 
         case FileAction::eFileActionClose:
             if (info->GetFD() == -1)
                 error.SetErrorString("invalid fd for posix_spawn_file_actions_addclose(...)");
             else
             {
                 error.SetError(::posix_spawn_file_actions_addclose(file_actions, info->GetFD()), eErrorTypePOSIX);
                 if (log && (error.Fail() || log))
                     error.PutToLog(log, "posix_spawn_file_actions_addclose (action=%p, fd=%i)",
                                    static_cast<void *>(file_actions), info->GetFD());
             }
             break;
 
         case FileAction::eFileActionDuplicate:
             if (info->GetFD() == -1)
                 error.SetErrorString("invalid fd for posix_spawn_file_actions_adddup2(...)");
             else if (info->GetActionArgument() == -1)
                 error.SetErrorString("invalid duplicate fd for posix_spawn_file_actions_adddup2(...)");
             else
             {
-            error.SetError(::posix_spawn_file_actions_adddup2(file_actions, info->GetFD(), info->GetActionArgument()),
-                           eErrorTypePOSIX);
+                error.SetError(
+                    ::posix_spawn_file_actions_adddup2(file_actions, info->GetFD(), info->GetActionArgument()),
                 if (log && (error.Fail() || log))
                     error.PutToLog(log, "posix_spawn_file_actions_adddup2 (action=%p, fd=%i, dup_fd=%i)",
                                    static_cast<void *>(file_actions), info->GetFD(), info->GetActionArgument());
             }
             break;
 
         case FileAction::eFileActionOpen:
             if (info->GetFD() == -1)
                 error.SetErrorString("invalid fd in posix_spawn_file_actions_addopen(...)");
             else
             {
                 int oflag = info->GetActionArgument();
 
                 mode_t mode = 0;
 
                 if (oflag & O_CREAT)
                     mode = 0640;
 
                 error.SetError(
                     ::posix_spawn_file_actions_addopen(file_actions, info->GetFD(), info->GetPath(), oflag, mode),
                     eErrorTypePOSIX);
                 if (error.Fail() || log)
-                error.PutToLog(log, "posix_spawn_file_actions_addopen (action=%p, fd=%i, path='%s', oflag=%i, mode=%i)",
+                    error.PutToLog(log,
+                                   "posix_spawn_file_actions_addopen (action=%p, fd=%i, path='%s', oflag=%i, mode=%i)",
                                    static_cast<void *>(file_actions), info->GetFD(), info->GetPath(), oflag, mode);
             }
             break;
     }
     return error.Success();
 }
 
 #endif // LaunchProcedssPosixSpawn: Apple, Linux, FreeBSD and other GLIBC systems
 
 
 #if defined(__linux__) || defined(__FreeBSD__) || defined(__GLIBC__) || defined(__NetBSD__)

 
 lldb::pid_t
 Host::LaunchApplication (const FileSpec &app_file_spec)
 {
     return LLDB_INVALID_PROCESS_ID;
 }
 
 #endif
-
-
-#if !defined(_WIN32)
-Error
-Host::MakeDirectory (const char* path, uint32_t file_permissions)
-{
-    Error error;
-    if (path && path[0])
-    {
-        if (::mkdir(path, file_permissions) != 0)
-        {
-            error.SetErrorToErrno();
-            switch (error.GetError())
-            {
-            case ENOENT:
-                {
-                    // Parent directory doesn't exist, so lets make it if we can
-                    FileSpec spec(path, false);
-                    if (spec.GetDirectory() && spec.GetFilename())
-                    {
-                        // Make the parent directory and try again
-                        Error error2 = Host::MakeDirectory(spec.GetDirectory().GetCString(), file_permissions);
-                        if (error2.Success())
-                        {
-                            // Try and make the directory again now that the parent directory was made successfully
-                            if (::mkdir(path, file_permissions) == 0)
-                                error.Clear();
-                            else
-                                error.SetErrorToErrno();
-                        }
-                    }
-                }
-                break;
-            case EEXIST:
-                {
-                    FileSpec path_spec(path, false);
-                    if (path_spec.IsDirectory())
-                        error.Clear(); // It is a directory and it already exists
-                }
-                break;
-            }
-        }
-    }
-    else
-    {
-        error.SetErrorString("empty path");
-    }
-    return error;
-}
-                                                                    
-Error
-Host::RemoveDirectory (const char* path, bool recurse)
-{
-    Error error;
-    if (path && path[0])
-    {
-        if (recurse)
-        {
-            StreamString command;
-            command.Printf("rm -rf \"%s\"", path);
-            int status = ::system(command.GetString().c_str());
-            if (status != 0)
-                error.SetError(status, eErrorTypeGeneric);
-        }
-        else
-        {
-            if (::rmdir(path) != 0)
-                error.SetErrorToErrno();
-        }
-    }
-    else
-    {
-        error.SetErrorString("empty path");
-    }
-    return error;
-}
-
-Error
-Host::GetFilePermissions (const char* path, uint32_t &file_permissions)
-{
-    Error error;
-    struct stat file_stats;
-    if (::stat (path, &file_stats) == 0)
-    {
-        // The bits in "st_mode" currently match the definitions
-        // for the file mode bits in unix.
-        file_permissions = file_stats.st_mode & (S_IRWXU | S_IRWXG | S_IRWXO);
-    }
-    else
-    {
-        error.SetErrorToErrno();
-    }
-    return error;
-}
-
-Error
-Host::SetFilePermissions (const char* path, uint32_t file_permissions)
-{
-    Error error;
-    if (::chmod(path, file_permissions) != 0)
-        error.SetErrorToErrno();
-    return error;
-}
-
-Error
-Host::Symlink (const char *src, const char *dst)
-{
-    Error error;
-    if (::symlink(dst, src) == -1)
-        error.SetErrorToErrno();
-    return error;
-}
-
-Error
-Host::Unlink (const char *path)
-{
-    Error error;
-    if (::unlink(path) == -1)
-        error.SetErrorToErrno();
-    return error;
-}
-
-Error
-Host::Readlink (const char *path, char *buf, size_t buf_len)
-{
-    Error error;
-    ssize_t count = ::readlink(path, buf, buf_len);
-    if (count < 0)
-        error.SetErrorToErrno();
-    else if (static_cast<size_t>(count) < (buf_len-1))
-        buf[count] = '\0'; // Success
-    else
-        error.SetErrorString("'buf' buffer is too small to contain link contents");
-    return error;
-}
-
-
-#endif
-
-typedef std::map<lldb::user_id_t, lldb::FileSP> FDToFileMap;
-FDToFileMap& GetFDToFileMap()
-{
-    static FDToFileMap g_fd2filemap;
-    return g_fd2filemap;
-}
-
-lldb::user_id_t
-Host::OpenFile (const FileSpec& file_spec,
-                uint32_t flags,
-                uint32_t mode,
-                Error &error)
-{
-    std::string path (file_spec.GetPath());
-    if (path.empty())
-    {
-        error.SetErrorString("empty path");
-        return UINT64_MAX;
-    }
-    FileSP file_sp(new File());
-    error = file_sp->Open(path.c_str(),flags,mode);
-    if (file_sp->IsValid() == false)
-        return UINT64_MAX;
-    lldb::user_id_t fd = file_sp->GetDescriptor();
-    GetFDToFileMap()[fd] = file_sp;
-    return fd;
-}
-
-bool
-Host::CloseFile (lldb::user_id_t fd, Error &error)
-{
-    if (fd == UINT64_MAX)
-    {
-        error.SetErrorString ("invalid file descriptor");
-        return false;
-    }
-    FDToFileMap& file_map = GetFDToFileMap();
-    FDToFileMap::iterator pos = file_map.find(fd);
-    if (pos == file_map.end())
-    {
-        error.SetErrorStringWithFormat ("invalid host file descriptor %" PRIu64, fd);
-        return false;
-    }
-    FileSP file_sp = pos->second;
-    if (!file_sp)
-    {
-        error.SetErrorString ("invalid host backing file");
-        return false;
-    }
-    error = file_sp->Close();
-    file_map.erase(pos);
-    return error.Success();
-}
-
-uint64_t
-Host::WriteFile (lldb::user_id_t fd, uint64_t offset, const void* src, uint64_t src_len, Error &error)
-{
-    if (fd == UINT64_MAX)
-    {
-        error.SetErrorString ("invalid file descriptor");
-        return UINT64_MAX;
-    }
-    FDToFileMap& file_map = GetFDToFileMap();
-    FDToFileMap::iterator pos = file_map.find(fd);
-    if (pos == file_map.end())
-    {
-        error.SetErrorStringWithFormat("invalid host file descriptor %" PRIu64 , fd);
-        return false;
-    }
-    FileSP file_sp = pos->second;
-    if (!file_sp)
-    {
-        error.SetErrorString ("invalid host backing file");
-        return UINT64_MAX;
-    }
-    if (static_cast<uint64_t>(file_sp->SeekFromStart(offset, &error)) != offset ||
-        error.Fail())
-        return UINT64_MAX;
-    size_t bytes_written = src_len;
-    error = file_sp->Write(src, bytes_written);
-    if (error.Fail())
-        return UINT64_MAX;
-    return bytes_written;
-}
-
-uint64_t
-Host::ReadFile (lldb::user_id_t fd, uint64_t offset, void* dst, uint64_t dst_len, Error &error)
-{
-    if (fd == UINT64_MAX)
-    {
-        error.SetErrorString ("invalid file descriptor");
-        return UINT64_MAX;
-    }
-    FDToFileMap& file_map = GetFDToFileMap();
-    FDToFileMap::iterator pos = file_map.find(fd);
-    if (pos == file_map.end())
-    {
-        error.SetErrorStringWithFormat ("invalid host file descriptor %" PRIu64, fd);
-        return false;
-    }
-    FileSP file_sp = pos->second;
-    if (!file_sp)
-    {
-        error.SetErrorString ("invalid host backing file");
-        return UINT64_MAX;
-    }
-    if (static_cast<uint64_t>(file_sp->SeekFromStart(offset, &error)) != offset ||
-        error.Fail())
-        return UINT64_MAX;
-    size_t bytes_read = dst_len;
-    error = file_sp->Read(dst ,bytes_read);
-    if (error.Fail())
-        return UINT64_MAX;
-    return bytes_read;
-}
-
-lldb::user_id_t
-Host::GetFileSize (const FileSpec& file_spec)
-{
-    return file_spec.GetByteSize();
-}
-
-bool
-Host::GetFileExists (const FileSpec& file_spec)
-{
-    return file_spec.Exists();
-}
-
-bool
-Host::CalculateMD5 (const FileSpec& file_spec,
-                    uint64_t &low,
-                    uint64_t &high)
-{
-#if defined (__APPLE__)
-    StreamString md5_cmd_line;
-    md5_cmd_line.Printf("md5 -q '%s'", file_spec.GetPath().c_str());
-    std::string hash_string;
-    Error err = Host::RunShellCommand(md5_cmd_line.GetData(), NULL, NULL, NULL, &hash_string, 60);
-    if (err.Fail())
-        return false;
-    // a correctly formed MD5 is 16-bytes, that is 32 hex digits
-    // if the output is any other length it is probably wrong
-    if (hash_string.size() != 32)
-        return false;
-    std::string part1(hash_string,0,16);
-    std::string part2(hash_string,16);
-    const char* part1_cstr = part1.c_str();
-    const char* part2_cstr = part2.c_str();
-    high = ::strtoull(part1_cstr, NULL, 16);
-    low = ::strtoull(part2_cstr, NULL, 16);
-    return true;
-#else
-    // your own MD5 implementation here
-    return false;
-#endif
-}

lldb/trunk/source/Host/common/Socket.cpp

 //===-- Socket.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/Socket.h"
 
 #include "lldb/Core/Log.h"
 #include "lldb/Core/RegularExpression.h"
 #include "lldb/Host/Config.h"
+#include "lldb/Host/FileSystem.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Host/SocketAddress.h"
 #include "lldb/Host/TimeValue.h"
 #include "lldb/Interpreter/Args.h"
 
 #ifndef LLDB_DISABLE_POSIX
 #include <arpa/inet.h>
 #include <netdb.h>
#ifndef LLDB_DISABLE_POSIX
 
     saddr_un.sun_family = AF_UNIX;
     ::strncpy(saddr_un.sun_path, name.data(), sizeof(saddr_un.sun_path) - 1);
     saddr_un.sun_path[sizeof(saddr_un.sun_path) - 1] = '\0';
 #if defined(__APPLE__) || defined(__FreeBSD__) || defined(__NetBSD__)
     saddr_un.sun_len = SUN_LEN (&saddr_un);
 #endif
 
-    Host::Unlink (name.data());
+    FileSystem::Unlink(name.data());
     bool success = false;
     if (::bind (listen_fd, (struct sockaddr *)&saddr_un, SUN_LEN (&saddr_un)) == 0) 
     {
         if (::listen (listen_fd, 5) == 0) 
         {
             socket_fd = ::accept (listen_fd, NULL, 0);
             if (socket_fd > 0)
             {

lldb/trunk/source/Host/posix/CMakeLists.txt

+set(LLVM_NO_RTTI 1)
+
+add_lldb_library(lldbHostPosix
+  FileSystem.cpp
+  )

lldb/trunk/source/Host/posix/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"
+
+// C includes
+#include <sys/stat.h>
+#include <sys/types.h>
+
+// lldb Includes
+#include "lldb/Core/Error.h"
+#include "lldb/Core/StreamString.h"
+#include "lldb/Host/Host.h"
+
+using namespace lldb;
+using namespace lldb_private;
+
+FileSpec::PathSyntax
+FileSystem::GetNativePathSyntax()
+{
+    return FileSpec::ePathSyntaxPosix;
+}
+
+Error
+FileSystem::MakeDirectory(const char *path, uint32_t file_permissions)
+{
+    Error error;
+    if (path && path[0])
+    {
+        if (::mkdir(path, file_permissions) != 0)
+        {
+            error.SetErrorToErrno();
+            switch (error.GetError())
+            {
+                case ENOENT:
+                {
+                    // Parent directory doesn't exist, so lets make it if we can
+                    FileSpec spec(path, false);
+                    if (spec.GetDirectory() && spec.GetFilename())
+                    {
+                        // Make the parent directory and try again
+                        Error error2 = MakeDirectory(spec.GetDirectory().GetCString(), file_permissions);
+                        if (error2.Success())
+                        {
+                            // Try and make the directory again now that the parent directory was made successfully
+                            if (::mkdir(path, file_permissions) == 0)
+                                error.Clear();
+                            else
+                                error.SetErrorToErrno();
+                        }
+                    }
+                }
+                break;
+
+                case EEXIST:
+                {
+                    FileSpec path_spec(path, false);
+                    if (path_spec.IsDirectory())
+                        error.Clear(); // It is a directory and it already exists
+                }
+                break;
+            }
+        }
+    }
+    else
+    {
+        error.SetErrorString("empty path");
+    }
+    return error;
+}
+
+Error
+FileSystem::DeleteDirectory(const char *path, bool recurse)
+{
+    Error error;
+    if (path && path[0])
+    {
+        if (recurse)
+        {
+            StreamString command;
+            command.Printf("rm -rf \"%s\"", path);
+            int status = ::system(command.GetString().c_str());
+            if (status != 0)
+                error.SetError(status, eErrorTypeGeneric);
+        }
+        else
+        {
+            if (::rmdir(path) != 0)
+                error.SetErrorToErrno();
+        }
+    }
+    else
+    {
+        error.SetErrorString("empty path");
+    }
+    return error;
+}
+
+Error
+FileSystem::GetFilePermissions(const char *path, uint32_t &file_permissions)
+{
+    Error error;
+    struct stat file_stats;
+    if (::stat(path, &file_stats) == 0)
+    {
+        // The bits in "st_mode" currently match the definitions
+        // for the file mode bits in unix.
+        file_permissions = file_stats.st_mode & (S_IRWXU | S_IRWXG | S_IRWXO);
+    }
+    else
+    {
+        error.SetErrorToErrno();
+    }
+    return error;
+}
+
+Error
+FileSystem::SetFilePermissions(const char *path, uint32_t file_permissions)
+{
+    Error error;
+    if (::chmod(path, file_permissions) != 0)
+        error.SetErrorToErrno();
+    return error;
+}
+
+lldb::user_id_t
+FileSystem::GetFileSize(const FileSpec &file_spec)
+{
+    return file_spec.GetByteSize();
+}
+
+bool
+FileSystem::GetFileExists(const FileSpec &file_spec)
+{
+    return file_spec.Exists();
+}
+
+Error
+FileSystem::Symlink(const char *src, const char *dst)
+{
+    Error error;
+    if (::symlink(dst, src) == -1)
+        error.SetErrorToErrno();
+    return error;
+}
+
+Error
+FileSystem::Unlink(const char *path)
+{
+    Error error;
+    if (::unlink(path) == -1)
+        error.SetErrorToErrno();
+    return error;
+}
+
+Error
+FileSystem::Readlink(const char *path, char *buf, size_t buf_len)
+{
+    Error error;
+    ssize_t count = ::readlink(path, buf, buf_len);
+    if (count < 0)
+        error.SetErrorToErrno();
+    else if (static_cast<size_t>(count) < (buf_len - 1))
+        buf[count] = '\0'; // Success
+    else
+        error.SetErrorString("'buf' buffer is too small to contain link contents");
+    return error;
+}
+
+bool
+FileSystem::CalculateMD5(const FileSpec &file_spec, uint64_t &low, uint64_t &high)
+{
+#if defined(__APPLE__)
+    StreamString md5_cmd_line;
+    md5_cmd_line.Printf("md5 -q '%s'", file_spec.GetPath().c_str());
+    std::string hash_string;
+    Error err = Host::RunShellCommand(md5_cmd_line.GetData(), NULL, NULL, NULL, &hash_string, 60);
+    if (err.Fail())
+        return false;
+    // a correctly formed MD5 is 16-bytes, that is 32 hex digits
+    // if the output is any other length it is probably wrong
+    if (hash_string.size() != 32)
+        return false;
+    std::string part1(hash_string, 0, 16);
+    std::string part2(hash_string, 16);
+    const char *part1_cstr = part1.c_str();
+    const char *part2_cstr = part2.c_str();
+    high = ::strtoull(part1_cstr, NULL, 16);
+    low = ::strtoull(part2_cstr, NULL, 16);
+    return true;
+#else
+    // your own MD5 implementation here
+    return false;
+#endif
+}

lldb/trunk/source/Host/windows/CMakeLists.txt

 set(LLVM_NO_RTTI 1)
 
 add_lldb_library(lldbHostWindows
+  FileSystem.cpp
   Host.cpp
   ProcessRunLock.cpp
   Mutex.cpp
   Condition.cpp
   Windows.cpp
   EditLineWin.cpp
   )

lldb/trunk/source/Host/windows/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/windows/windows.h"
+
+#include <shellapi.h>
+
+#include "lldb/Host/FileSystem.h"
+
+using namespace lldb_private;
+
+FileSpec::PathSyntax
+FileSystem::GetNativePathSyntax()
+{
+    return FileSpec::ePathSyntaxWindows;
+}
+
+Error
+FileSystem::MakeDirectory(const char *path, uint32_t file_permissions)
+{
+    // On Win32, the mode parameter is ignored, as Windows files and directories support a
+    // different permission model than POSIX.
+    Error error;
+    if (!::CreateDirectory(path, NULL))
+        error.SetError(::GetLastError(), lldb::eErrorTypeWin32);
+    return error;
+}
+
+Error
+FileSystem::DeleteDirectory(const char *path, bool recurse)
+{
+    Error error;
+    if (!recurse)
+    {
+        BOOL result = ::RemoveDirectory(path);
+        if (!result)
+            error.SetError(::GetLastError(), lldb::eErrorTypeWin32);
+    }
+    else
+    {
+        // SHFileOperation() accepts a list of paths, and so must be double-null-terminated to
+        // indicate the end of the list.
+        std::string path_buffer(path);
+        path_buffer.push_back(0);
+
+        SHFILEOPSTRUCT shfos = {0};
+        shfos.wFunc = FO_DELETE;
+        shfos.pFrom = path_buffer.c_str();
+        shfos.fFlags = FOF_NO_UI;
+
+        int result = ::SHFileOperation(&shfos);
+        // TODO(zturner): Correctly handle the intricacies of SHFileOperation return values.
+        if (result != 0)
+            error.SetErrorStringWithFormat("SHFileOperation failed");
+    }
+    return error;
+}
+
+Error
+FileSystem::GetFilePermissions(const char *path, uint32_t &file_permissions)
+{
+    Error error;
+    error.SetErrorStringWithFormat("%s is not supported on this host", __PRETTY_FUNCTION__);
+    return error;
+}
+
+Error
+FileSystem::SetFilePermissions(const char *path, uint32_t file_permissions)
+{
+    Error error;
+    error.SetErrorStringWithFormat("%s is not supported on this host", __PRETTY_FUNCTION__);
+    return error;
+}
+
+lldb::user_id_t
+FileSystem::GetFileSize(const FileSpec &file_spec)
+{
+    return file_spec.GetByteSize();
+}
+
+bool
+FileSystem::GetFileExists(const FileSpec &file_spec)
+{
+    return file_spec.Exists();
+}
+
+Error
+FileSystem::Symlink(const char *linkname, const char *target)
+{
+    Error error;
+    DWORD attrib = ::GetFileAttributes(target);
+    if (attrib == INVALID_FILE_ATTRIBUTES)
+    {
+        error.SetError(::GetLastError(), lldb::eErrorTypeWin32);
+        return error;
+    }
+    bool is_directory = !!(attrib & FILE_ATTRIBUTE_DIRECTORY);
+    DWORD flag = is_directory ? SYMBOLIC_LINK_FLAG_DIRECTORY : 0;
+    BOOL result = ::CreateSymbolicLink(linkname, target, flag);
+    if (!result)
+        error.SetError(::GetLastError(), lldb::eErrorTypeWin32);
+    return error;
+}
+
+Error
+FileSystem::Unlink(const char *path)
+{
+    Error error;
+    BOOL result = ::DeleteFile(path);
+    if (!result)
+        error.SetError(::GetLastError(), lldb::eErrorTypeWin32);
+    return error;
+}
+
+Error
+FileSystem::Readlink(const char *path, char *buf, size_t buf_len)
+{
+    Error error;
+    HANDLE h = ::CreateFile(path, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING,
+                            FILE_FLAG_OPEN_REPARSE_POINT, NULL);
+    if (h == INVALID_HANDLE_VALUE)
+    {
+        error.SetError(::GetLastError(), lldb::eErrorTypeWin32);
+        return error;
+    }
+
+    // Subtract 1 from the path length since this function does not add a null terminator.
+    DWORD result = ::GetFinalPathNameByHandle(h, buf, buf_len - 1, FILE_NAME_NORMALIZED | VOLUME_NAME_DOS);
+    if (result == 0)
+        error.SetError(::GetLastError(), lldb::eErrorTypeWin32);
+
+    ::CloseHandle(h);
+    return error;
+}
+
+bool
+FileSystem::CalculateMD5(const FileSpec &file_spec, uint64_t &low, uint64_t &high)
+{
+    return false;
+}

lldb/trunk/source/Host/windows/Host.cpp

 #include "lldb/Target/Process.h"
 
 #include "lldb/Host/Host.h"
 #include "lldb/Core/DataBufferHeap.h"
 #include "lldb/Core/DataExtractor.h"
 #include "lldb/Core/StreamFile.h"
 
 // Windows includes
-#include <shellapi.h>
 #include <TlHelp32.h>
 
 using namespace lldb;
 using namespace lldb_private;
 
 namespace
 {
     bool GetTripleForProcess(const FileSpec &executable, llvm::Triple &triple)
#pragma warning(pop)
     major = (uint32_t) info.dwMajorVersion;
     minor = (uint32_t) info.dwMinorVersion;
     update = (uint32_t) info.wServicePackMajor;
 
     return true;
 }
 
 Error
-Host::MakeDirectory (const char* path, uint32_t mode)
-{
-    // On Win32, the mode parameter is ignored, as Windows files and directories support a
-    // different permission model than POSIX.
-    Error error;
-    if (!::CreateDirectory(path, NULL))
-        error.SetError(::GetLastError(), lldb::eErrorTypeWin32);
-    return error;
-}
-
-Error
-Host::GetFilePermissions (const char* path, uint32_t &file_permissions)
-{
-    Error error;
-    file_permissions = 0;
-    DWORD attrib = ::GetFileAttributes(path);
-    if (attrib == INVALID_FILE_ATTRIBUTES)
-        error.SetError(::GetLastError(), lldb::eErrorTypeWin32);
-    return error;
-}
-
-Error
-Host::SetFilePermissions (const char* path, uint32_t file_permissions)
-{
-    Error error;
-    error.SetErrorStringWithFormat("%s is not supported on this host", __PRETTY_FUNCTION__);
-    return error;
-}
-
-Error
-Host::Symlink (const char *linkname, const char *target)
-{
-    Error error;
-    DWORD attrib = ::GetFileAttributes(target);
-    if (attrib == INVALID_FILE_ATTRIBUTES)
-    {
-        error.SetError(::GetLastError(), lldb::eErrorTypeWin32);
-        return error;
-    }
-    bool is_directory = !!(attrib & FILE_ATTRIBUTE_DIRECTORY);
-    DWORD flag = is_directory ? SYMBOLIC_LINK_FLAG_DIRECTORY : 0;
-    BOOL result = ::CreateSymbolicLink(linkname, target, flag);
-    if (!result)
-        error.SetError(::GetLastError(), lldb::eErrorTypeWin32);
-    return error;
-}
-
-Error
-Host::Readlink (const char *path, char *buf, size_t buf_len)
-{
-    Error error;
-    HANDLE h = ::CreateFile(path, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, FILE_FLAG_OPEN_REPARSE_POINT, NULL);
-    if (h == INVALID_HANDLE_VALUE)
-    {
-        error.SetError(::GetLastError(), lldb::eErrorTypeWin32);
-        return error;
-    }
-
-    // Subtract 1 from the path length since this function does not add a null terminator.
-    DWORD result = ::GetFinalPathNameByHandle(h, buf, buf_len-1, FILE_NAME_NORMALIZED | VOLUME_NAME_DOS);
-    if (result == 0)
-        error.SetError(::GetLastError(), lldb::eErrorTypeWin32);
-
-    ::CloseHandle(h);
-    return error;
-}
-
-Error
-Host::Unlink (const char *path)
-{
-    Error error;
-    BOOL result = ::DeleteFile(path);
-    if (!result)
-        error.SetError(::GetLastError(), lldb::eErrorTypeWin32);
-    return error;
-}
-
-Error
-Host::RemoveDirectory (const char* path, bool recurse)
-{
-    Error error;
-    if (!recurse)
-    {
-        BOOL result = ::RemoveDirectory(path);
-        if (!result)
-            error.SetError(::GetLastError(), lldb::eErrorTypeWin32);
-    }
-    else
-    {
-        // SHFileOperation() accepts a list of paths, and so must be double-null-terminated to
-        // indicate the end of the list.
-        std::string path_buffer(path);
-        path_buffer.push_back(0);
-
-        SHFILEOPSTRUCT shfos = {0};
-        shfos.wFunc = FO_DELETE;
-        shfos.pFrom = path_buffer.c_str();
-        shfos.fFlags = FOF_NO_UI;
-
-        int result = ::SHFileOperation(&shfos);
-        // TODO(zturner): Correctly handle the intricacies of SHFileOperation return values.
-        if (result != 0)
-            error.SetErrorStringWithFormat("SHFileOperation failed");
-    }
-    return error;
-}
-
-
-Error
 Host::LaunchProcess (ProcessLaunchInfo &launch_info)
 {
     Error error;
     assert(!"Not implemented yet!!!");
     return error;
 }
 
 lldb::DataBufferSP
(
     Host::MonitorChildProcessCallback callback,
     void *callback_baton,
     lldb::pid_t pid,
     bool monitor_signals
 )
 {
     return LLDB_INVALID_HOST_THREAD;
 }
 No newline at end of file

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

 #include "lldb/Breakpoint/BreakpointLocation.h"
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/Error.h"
 #include "lldb/Core/Log.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/Timer.h"
 #include "lldb/Host/Host.h"
+#include "lldb/Host/FileSystem.h"
 #include "lldb/Host/Symbols.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/SymbolFile.h"
 #include "lldb/Symbol/SymbolVendor.h"
 #include "lldb/Target/Target.h"
 #include "llvm/ADT/STLExtras.h"
 
 using namespace lldb;
PlatformDarwin::ResolveSymbolFile (Target &target,
     return error;
     
 }
 
 static lldb_private::Error
 MakeCacheFolderForFile (const FileSpec& module_cache_spec)
 {
     FileSpec module_cache_folder = module_cache_spec.CopyByRemovingLastPathComponent();
-    return Host::MakeDirectory(module_cache_folder.GetPath().c_str(), eFilePermissionsDirectoryDefault);
+    return FileSystem::MakeDirectory(module_cache_folder.GetPath().c_str(), eFilePermissionsDirectoryDefault);
 }
 
 static lldb_private::Error
 BringInRemoteFile (Platform* platform,
                    const lldb_private::ModuleSpec &module_spec,
                    const FileSpec& module_cache_spec)
 {
     MakeCacheFolderForFile(module_cache_spec);
if (!IsHost())
             if (module_cache_spec.Exists())
             {
                 // get the local and remote MD5 and compare
                 if (m_remote_platform_sp)
                 {
                     // when going over the *slow* GDB remote transfer mechanism we first check
                     // the hashes of the files - and only do the actual transfer if they differ
                     uint64_t high_local,high_remote,low_local,low_remote;
-                    Host::CalculateMD5 (module_cache_spec, low_local, high_local);
+                    FileSystem::CalculateMD5(module_cache_spec, low_local, high_local);
                     m_remote_platform_sp->CalculateMD5(module_spec.GetFileSpec(), low_remote, high_remote);
                     if (low_local != low_remote || high_local != high_remote)
                     {
                         // bring in the remote file
                         Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PLATFORM));
                         if (log)
                             log->Printf("[%s] module %s/%s needs to be replaced from remote copy",
                                          (IsHost() ? "host" : "remote"),

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

 #include "lldb/Core/Error.h"
 #include "lldb/Core/DataBufferHeap.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleList.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/StreamString.h"
 #include "lldb/Host/FileSpec.h"
+#include "lldb/Host/FileSystem.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Target.h"
 
 using namespace lldb;
 using namespace lldb_private;
     
if (IsRemote() && m_remote_platform_sp)
             if (module_cache_spec.Exists())
             {
                 local_file = module_cache_spec;
                 return Error();
             }
             // bring in the remote module file
             FileSpec module_cache_folder = module_cache_spec.CopyByRemovingLastPathComponent();
             // try to make the local directory first
-            Error err = Host::MakeDirectory(module_cache_folder.GetPath().c_str(), eFilePermissionsDirectoryDefault);
+            Error err =
+                FileSystem::MakeDirectory(module_cache_folder.GetPath().c_str(), eFilePermissionsDirectoryDefault);
             if (err.Fail())
                 return err;
             err = GetFile(platform_file, module_cache_spec);
             if (err.Fail())
                 return err;
             if (module_cache_spec.Exists())
             {
                 local_file = module_cache_spec;

lldb/trunk/source/Plugins/Platform/POSIX/PlatformPOSIX.cpp

 // C++ Includes
 // Other libraries and framework includes
 // Project includes
 
 #include "lldb/Core/DataBufferHeap.h"
 #include "lldb/Core/Log.h"
 #include "lldb/Core/StreamString.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/Target/ProcessLaunchInfo.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 
 //------------------------------------------------------------------

 
 lldb::user_id_t
 PlatformPOSIX::OpenFile (const FileSpec& file_spec,
                          uint32_t flags,
                          uint32_t mode,
                          Error &error)
 {
     if (IsHost())
-        return Host::OpenFile(file_spec, flags, mode, error);
+        return FileCache::GetInstance().OpenFile(file_spec, flags, mode, error);
     else if (m_remote_platform_sp)
         return m_remote_platform_sp->OpenFile(file_spec, flags, mode, error);
     else
         return Platform::OpenFile(file_spec, flags, mode, error);
 }
 
 bool
 PlatformPOSIX::CloseFile (lldb::user_id_t fd, Error &error)
 {
     if (IsHost())
-        return Host::CloseFile(fd, error);
+        return FileCache::GetInstance().CloseFile(fd, error);
     else if (m_remote_platform_sp)
         return m_remote_platform_sp->CloseFile(fd, error);
     else
         return Platform::CloseFile(fd, error);
 }
 
 uint64_t
 PlatformPOSIX::ReadFile (lldb::user_id_t fd,
                          uint64_t offset,
                          void *dst,
                          uint64_t dst_len,
                          Error &error)
 {
     if (IsHost())
-        return Host::ReadFile(fd, offset, dst, dst_len, error);
+        return FileCache::GetInstance().ReadFile(fd, offset, dst, dst_len, error);
     else if (m_remote_platform_sp)
         return m_remote_platform_sp->ReadFile(fd, offset, dst, dst_len, error);
     else
         return Platform::ReadFile(fd, offset, dst, dst_len, error);
 }
 
 uint64_t
 PlatformPOSIX::WriteFile (lldb::user_id_t fd,
                           uint64_t offset,
                           const void* src,
                           uint64_t src_len,
                           Error &error)
 {
     if (IsHost())
-        return Host::WriteFile(fd, offset, src, src_len, error);
+        return FileCache::GetInstance().WriteFile(fd, offset, src, src_len, error);
     else if (m_remote_platform_sp)
         return m_remote_platform_sp->WriteFile(fd, offset, src, src_len, error);
     else
         return Platform::WriteFile(fd, offset, src, src_len, error);
 }
 
 static uint32_t
 chown_file(Platform *platform,
//            return Error("unable to perform chown");
     }
     return Platform::PutFile(source,destination,uid,gid);
 }
 
 lldb::user_id_t
 PlatformPOSIX::GetFileSize (const FileSpec& file_spec)
 {
     if (IsHost())
-        return Host::GetFileSize(file_spec);
+        return FileSystem::GetFileSize(file_spec);
     else if (m_remote_platform_sp)
         return m_remote_platform_sp->GetFileSize(file_spec);
     else
         return Platform::GetFileSize(file_spec);
 }
 
 Error
 PlatformPOSIX::CreateSymlink(const char *src, const char *dst)
 {
     if (IsHost())
-        return Host::Symlink(src, dst);
+        return FileSystem::Symlink(src, dst);
     else if (m_remote_platform_sp)
         return m_remote_platform_sp->CreateSymlink(src, dst);
     else
         return Platform::CreateSymlink(src, dst);
 }
 
 bool
 PlatformPOSIX::GetFileExists (const FileSpec& file_spec)
 {
     if (IsHost())
         return file_spec.Exists();
     else if (m_remote_platform_sp)
         return m_remote_platform_sp->GetFileExists(file_spec);
     else
         return Platform::GetFileExists(file_spec);
 }
 
 Error
 PlatformPOSIX::Unlink (const char *path)
 {
     if (IsHost())
-        return Host::Unlink (path);
+        return FileSystem::Unlink(path);
     else if (m_remote_platform_sp)
         return m_remote_platform_sp->Unlink(path);
     else
         return Platform::Unlink(path);
 }
 
 lldb_private::Error
 PlatformPOSIX::GetFile (const lldb_private::FileSpec& source /* remote file path */,
else if (m_remote_platform_sp)
             return Error("unable to open source file");
 
         uint32_t permissions = 0;
         error = GetFilePermissions(source.GetPath().c_str(), permissions);
         
         if (permissions == 0)
             permissions = lldb::eFilePermissionsFileDefault;
 
-        user_id_t fd_dst = Host::OpenFile(destination,
-                                          File::eOpenOptionCanCreate | File::eOpenOptionWrite | File::eOpenOptionTruncate,
-                                          permissions,
-                                          error);
+        user_id_t fd_dst = FileCache::GetInstance().OpenFile(
+            destination, File::eOpenOptionCanCreate | File::eOpenOptionWrite | File::eOpenOptionTruncate, permissions,
 
         if (fd_dst == UINT64_MAX)
         {
             if (error.Success())
                 error.SetErrorString("unable to open destination file");
         }
 
         if (error.Success())
         {
             lldb::DataBufferSP buffer_sp(new DataBufferHeap(1024, 0));
             uint64_t offset = 0;
             error.Clear();
             while (error.Success())
             {
                 const uint64_t n_read = ReadFile (fd_src,
                                                   offset,
                                                   buffer_sp->GetBytes(),
                                                   buffer_sp->GetByteSize(),
                                                   error);
                 if (error.Fail())
                     break;
                 if (n_read == 0)
                     break;
-                if (Host::WriteFile(fd_dst,
-                                    offset,
-                                    buffer_sp->GetBytes(),
-                                    n_read,
-                                    error) != n_read)
+                if (FileCache::GetInstance().WriteFile(fd_dst, offset, buffer_sp->GetBytes(), n_read, error) != n_read)
                 {
                     if (!error.Fail())
                         error.SetErrorString("unable to write to destination file");
-                        break;
                 }
                 offset += n_read;
             }
         }
         // Ignore the close error of src.
         if (fd_src != UINT64_MAX)
             CloseFile(fd_src, error);
         // And close the dst file descriptot.
-        if (fd_dst != UINT64_MAX && !Host::CloseFile(fd_dst, error))
+        if (fd_dst != UINT64_MAX && !FileCache::GetInstance().CloseFile(fd_dst, error))
         {
             if (!error.Fail())
                 error.SetErrorString("unable to close destination file");
 
         }
         return error;
     }
     return Platform::GetFile(source,destination);

lldb/trunk/source/Plugins/Process/Linux/NativeProcessLinux.cpp

namespace
     const UnixSignals&
     GetUnixSignals ()
     {
         static process_linux::LinuxSignals signals;
         return signals;
     }
 
     const char *
-    GetFilePath (const lldb_private::FileAction *file_action, const char *default_path)
+    GetFilePath(const lldb_private::FileAction *file_action, const char *default_path)
     {
         const char *pts_name = "/dev/pts/";
         const char *path = NULL;
 
         if (file_action)
         {
-            if (file_action->GetAction () == FileAction::eFileActionOpen)
+            if (file_action->GetAction() == FileAction::eFileActionOpen)
             {
                 path = file_action->GetPath ();
                 // By default the stdio paths passed in will be pseudo-terminal
                 // (/dev/pts). If so, convert to using a different default path
                 // instead to redirect I/O to the debugger console. This should
                 //  also handle user overrides to /dev/null or a different file.
                 if (!path || ::strncmp (path, pts_name, ::strlen (pts_name)) == 0)
                     path = default_path;

lldb/trunk/source/Plugins/Process/POSIX/ProcessPOSIX.h

public:
     SendMessage(const ProcessMessage &message);
 
     ProcessMonitor &
     GetMonitor() { assert(m_monitor); return *m_monitor; }
 
     lldb_private::UnixSignals &
     GetUnixSignals();
 
-    const char *
-    GetFilePath(const lldb_private::FileAction *file_action,
-                const char *default_path);
+    const char *GetFilePath(const lldb_private::FileAction *file_action, const char *default_path);
 
     /// Stops all threads in the process.
     /// The \p stop_tid parameter indicates the thread which initiated the stop.
     virtual void
     StopAllThreads(lldb::tid_t stop_tid);
 
     /// Adds the thread to the list of threads for which we have received the initial stopping signal.
     /// The \p stop_tid parameter indicates the thread which the stop happened for.

lldb/trunk/source/Plugins/Process/POSIX/ProcessPOSIX.cpp

 Error
 ProcessPOSIX::WillLaunch(Module* module)
 {
     Error error;
     return error;
 }
 
 const char *
-ProcessPOSIX::GetFilePath(
-    const lldb_private::FileAction *file_action,
-    const char *default_path)
+ProcessPOSIX::GetFilePath(const lldb_private::FileAction *file_action, const char *default_path)
 {
     const char *pts_name = "/dev/pts/";
     const char *path = NULL;
 
     if (file_action)
     {
-        if (file_action->GetAction () == FileAction::eFileActionOpen)
+        if (file_action->GetAction() == FileAction::eFileActionOpen)
         {
             path = file_action->GetPath();
             // By default the stdio paths passed in will be pseudo-terminal
             // (/dev/pts). If so, convert to using a different default path
             // instead to redirect I/O to the debugger console. This should
             //  also handle user overrides to /dev/null or a different file.
             if (!path || ::strncmp(path, pts_name, ::strlen(pts_name)) == 0)
                 path = default_path;

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

 
 // C++ Includes
 // Other libraries and framework includes
 #include "lldb/Core/ConnectionFileDescriptor.h"
 #include "lldb/Core/Log.h"
 #include "lldb/Core/StreamFile.h"
 #include "lldb/Core/StreamString.h"
 #include "lldb/Host/FileSpec.h"
+#include "lldb/Host/FileSystem.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Host/Socket.h"
 #include "lldb/Host/TimeValue.h"
 #include "lldb/Target/Process.h"
 
 // Project includes
 #include "ProcessGDBRemoteLog.h"
 
#endif
                     port_cstr[0] = '\0';
                     size_t num_bytes = sizeof(port_cstr);
                     error = name_pipe_file.Read(port_cstr, num_bytes);
                     assert (error.Success());
                     assert (num_bytes > 0 && port_cstr[num_bytes-1] == '\0');
                     out_port = Args::StringToUInt32(port_cstr, 0);
                     name_pipe_file.Close();
                 }
-                Host::Unlink(named_pipe_path);
+                FileSystem::Unlink(named_pipe_path);
             }
             else if (listen)
             {
                 
             }
             else
             {
                 // Make sure we actually connect with the debugserver...

lldb/trunk/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServer.cpp

 #include "lldb/Core/ConnectionFileDescriptor.h"
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/Log.h"
 #include "lldb/Core/State.h"
 #include "lldb/Core/StreamString.h"
 #include "lldb/Host/Debug.h"
 #include "lldb/Host/Endian.h"
 #include "lldb/Host/File.h"
+#include "lldb/Host/FileSystem.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Host/TimeValue.h"
 #include "lldb/Target/FileAction.h"
 #include "lldb/Target/Platform.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/NativeRegisterContext.h"
 #include "Host/common/NativeProcessProtocol.h"
 #include "Host/common/NativeThreadProtocol.h"

 GDBRemoteCommunicationServer::Handle_qPlatform_mkdir (StringExtractorGDBRemote &packet)
 {
     packet.SetFilePos(::strlen("qPlatform_mkdir:"));
     mode_t mode = packet.GetHexMaxU32(false, UINT32_MAX);
     if (packet.GetChar() == ',')
     {
         std::string path;
         packet.GetHexByteString(path);
-        Error error = Host::MakeDirectory(path.c_str(),mode);
+        Error error = FileSystem::MakeDirectory(path.c_str(), mode);
         if (error.Success())
             return SendPacketNoLock ("OK", 2);
         else
             return SendErrorResponse(error.GetError());
     }
     return SendErrorResponse(20);
 }
 
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServer::Handle_qPlatform_chmod (StringExtractorGDBRemote &packet)
 {
     packet.SetFilePos(::strlen("qPlatform_chmod:"));
     
     mode_t mode = packet.GetHexMaxU32(false, UINT32_MAX);
     if (packet.GetChar() == ',')
     {
         std::string path;
         packet.GetHexByteString(path);
-        Error error = Host::SetFilePermissions (path.c_str(), mode);
+        Error error = FileSystem::SetFilePermissions(path.c_str(), mode);
         if (error.Success())
             return SendPacketNoLock ("OK", 2);
         else
             return SendErrorResponse(error.GetError());
     }
     return SendErrorResponse(19);
 }
 

 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServer::Handle_vFile_Size (StringExtractorGDBRemote &packet)
 {
     packet.SetFilePos(::strlen("vFile:size:"));
     std::string path;
     packet.GetHexByteString(path);
     if (!path.empty())
     {
-        lldb::user_id_t retcode = Host::GetFileSize(FileSpec(path.c_str(), false));
+        lldb::user_id_t retcode = FileSystem::GetFileSize(FileSpec(path.c_str(), false));
         StreamString response;
         response.PutChar('F');
         response.PutHex64(retcode);
         if (retcode == UINT64_MAX)
         {
             response.PutChar(',');
             response.PutHex64(retcode); // TODO: replace with Host::GetSyswideErrorCode()
         }

 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServer::Handle_vFile_Exists (StringExtractorGDBRemote &packet)
 {
     packet.SetFilePos(::strlen("vFile:exists:"));
     std::string path;
     packet.GetHexByteString(path);
     if (!path.empty())
     {
-        bool retcode = Host::GetFileExists(FileSpec(path.c_str(), false));
+        bool retcode = FileSystem::GetFileExists(FileSpec(path.c_str(), false));
         StreamString response;
         response.PutChar('F');
         response.PutChar(',');
         if (retcode)
             response.PutChar('1');
         else
             response.PutChar('0');
         return SendPacketNoLock(response.GetData(), response.GetSize());
     }
     return SendErrorResponse(24);
 }
 
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServer::Handle_vFile_symlink (StringExtractorGDBRemote &packet)
 {
     packet.SetFilePos(::strlen("vFile:symlink:"));
     std::string dst, src;
     packet.GetHexByteStringTerminatedBy(dst, ',');
     packet.GetChar(); // Skip ',' char
     packet.GetHexByteString(src);
-    Error error = Host::Symlink(src.c_str(), dst.c_str());
+    Error error = FileSystem::Symlink(src.c_str(), dst.c_str());
     StreamString response;
     response.Printf("F%u,%u", error.GetError(), error.GetError());
     return SendPacketNoLock(response.GetData(), response.GetSize());
 }
 
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServer::Handle_vFile_unlink (StringExtractorGDBRemote &packet)
 {
     packet.SetFilePos(::strlen("vFile:unlink:"));
     std::string path;
     packet.GetHexByteString(path);
-    Error error = Host::Unlink(path.c_str());
+    Error error = FileSystem::Unlink(path.c_str());
     StreamString response;
     response.Printf("F%u,%u", error.GetError(), error.GetError());
     return SendPacketNoLock(response.GetData(), response.GetSize());
 }
 
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServer::Handle_qPlatform_shell (StringExtractorGDBRemote &packet)
 {

 {
     packet.SetFilePos(::strlen("vFile:MD5:"));
     std::string path;
     packet.GetHexByteString(path);
     if (!path.empty())
     {
         uint64_t a,b;
         StreamGDBRemote response;
-        if (Host::CalculateMD5(FileSpec(path.c_str(),false),a,b) == false)
+        if (FileSystem::CalculateMD5(FileSpec(path.c_str(), false), a, b) == false)
         {
             response.PutCString("F,");
             response.PutCString("x");
         }
         else
         {
             response.PutCString("F,");
             response.PutHex64(a);

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

ProcessGDBRemote::DoLaunch (Module *exe_module, ProcessLaunchInfo &launch_info)
     const char *stdout_path = NULL;
     const char *stderr_path = NULL;
     const char *working_dir = launch_info.GetWorkingDirectory();
 
     const FileAction *file_action;
     file_action = launch_info.GetFileActionForFD (STDIN_FILENO);
     if (file_action)
     {
-        if (file_action->GetAction () == FileAction::eFileActionOpen)
+        if (file_action->GetAction() == FileAction::eFileActionOpen)
             stdin_path = file_action->GetPath();
     }
     file_action = launch_info.GetFileActionForFD (STDOUT_FILENO);
     if (file_action)
     {
-        if (file_action->GetAction () == FileAction::eFileActionOpen)
+        if (file_action->GetAction() == FileAction::eFileActionOpen)
             stdout_path = file_action->GetPath();
     }
     file_action = launch_info.GetFileActionForFD (STDERR_FILENO);
     if (file_action)
     {
-        if (file_action->GetAction () == FileAction::eFileActionOpen)
+        if (file_action->GetAction() == FileAction::eFileActionOpen)
             stderr_path = file_action->GetPath();
     }
 
     //  ::LogSetBitMask (GDBR_LOG_DEFAULT);
     //  ::LogSetOptions (LLDB_LOG_OPTION_THREADSAFE | LLDB_LOG_OPTION_PREPEND_TIMESTAMP | LLDB_LOG_OPTION_PREPEND_PROC_AND_THREAD);
     //  ::LogSetLogFile ("/dev/stdout");
     Log *log (ProcessGDBRemoteLog::GetLogIfAllCategoriesSet (GDBR_LOG_PROCESS));
 

lldb/trunk/source/Target/FileAction.cpp

 #include "lldb/Target/FileAction.h"
 
 using namespace lldb_private;
 
 //----------------------------------------------------------------------------
 // FileAction member functions
 //----------------------------------------------------------------------------
 
-FileAction::FileAction() : m_action(eFileActionNone), m_fd(-1), m_arg(-1), m_path() {}
+FileAction::FileAction()
+    : m_action(eFileActionNone)
+    , m_fd(-1)
+    , m_arg(-1)
+    , m_path()
+{
+}
 
-void FileAction::Clear()
+void
+FileAction::Clear()
 {
     m_action = eFileActionNone;
     m_fd = -1;
     m_arg = -1;
     m_path.clear();
 }
 
-const char *FileAction::GetPath() const
+const char *
+FileAction::GetPath() const
 {
     if (m_path.empty())
         return NULL;
     return m_path.c_str();
 }
 
-bool FileAction::Open(int fd, const char *path, bool read, bool write)
+bool
+FileAction::Open(int fd, const char *path, bool read, bool write)
 {
     if ((read || write) && fd >= 0 && path && path[0])
     {
         m_action = eFileActionOpen;
         m_fd = fd;
         if (read && write)
             m_arg = O_NOCTTY | O_CREAT | O_RDWR;
         else if (read)
             m_arg = O_NOCTTY | O_RDONLY;
         else
             m_arg = O_NOCTTY | O_CREAT | O_WRONLY;
         m_path.assign(path);
         return true;
     }
     else
     {
         Clear();
     }
     return false;
 }
 
-bool FileAction::Close(int fd)
+bool
+FileAction::Close(int fd)
 {
     Clear();
     if (fd >= 0)
     {
         m_action = eFileActionClose;
         m_fd = fd;
     }
     return m_fd >= 0;
 }
 
-bool FileAction::Duplicate(int fd, int dup_fd)
+bool
+FileAction::Duplicate(int fd, int dup_fd)
 {
     Clear();
     if (fd >= 0 && dup_fd >= 0)
     {
         m_action = eFileActionDuplicate;
         m_fd = fd;
         m_arg = dup_fd;
     }
     return m_fd >= 0;
 }

lldb/trunk/source/Target/Platform.cpp

 // Other libraries and framework includes
 // Project includes
 #include "lldb/Breakpoint/BreakpointIDList.h"
 #include "lldb/Core/Error.h"
 #include "lldb/Core/Log.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/Utils.h"
 
 using namespace lldb;
 using namespace lldb_private;
     
switch (file_type)
         case FileSpec::eFileTypeSymbolicLink:
             {
                 // copy the file and keep going
                 FileSpec dst_file = rc_baton->dst;
                 if (!dst_file.GetFilename())
                     dst_file.GetFilename() = src.GetFilename();
                 
                 char buf[PATH_MAX];
-                
-                rc_baton->error = Host::Readlink (src.GetPath().c_str(), buf, sizeof(buf));
+                rc_baton->error = FileSystem::Readlink(src.GetPath().c_str(), buf, sizeof(buf));
 
                 if (rc_baton->error.Fail())
                     return FileSpec::eEnumerateDirectoryResultQuit; // got an error, bail out
                 
                 rc_baton->error = rc_baton->platform_ptr->CreateSymlink(dst_file.GetPath().c_str(), buf);
 
                 if (rc_baton->error.Fail())
                     return FileSpec::eEnumerateDirectoryResultQuit; // got an error, bail out
else
                 error = PutFile(src, fixed_dst);
                 break;
 
             case FileSpec::eFileTypeSymbolicLink:
                 {
                     if (GetFileExists (fixed_dst))
                         Unlink (fixed_dst.GetPath().c_str());
                     char buf[PATH_MAX];
-                    error = Host::Readlink(src.GetPath().c_str(), buf, sizeof(buf));
+                    error = FileSystem::Readlink(src.GetPath().c_str(), buf, sizeof(buf));
                     if (error.Success())
                         error = CreateSymlink(dst.GetPath().c_str(), buf);
                 }
                 break;
             case FileSpec::eFileTypePipe:
                 error.SetErrorString("platform install doesn't handle pipes");
                 break;
             case FileSpec::eFileTypeSocket:
else
         return SetRemoteWorkingDirectory(path);
     }
 }
 
 Error
 Platform::MakeDirectory (const char *path, uint32_t permissions)
 {
     if (IsHost())
-        return Host::MakeDirectory (path, permissions);
+        return FileSystem::MakeDirectory(path, permissions);
     else
     {
         Error error;
         error.SetErrorStringWithFormat("remote platform %s doesn't support %s", GetPluginName().GetCString(), __PRETTY_FUNCTION__);
         return error;
     }
 }
 
 Error
 Platform::GetFilePermissions (const char *path, uint32_t &file_permissions)
 {
     if (IsHost())
-        return Host::GetFilePermissions(path, file_permissions);
+        return FileSystem::GetFilePermissions(path, file_permissions);
     else
     {
         Error error;
         error.SetErrorStringWithFormat("remote platform %s doesn't support %s", GetPluginName().GetCString(), __PRETTY_FUNCTION__);
         return error;
     }
 }
 
 Error
 Platform::SetFilePermissions (const char *path, uint32_t file_permissions)
 {
     if (IsHost())
-        return Host::SetFilePermissions(path, file_permissions);
+        return FileSystem::SetFilePermissions(path, file_permissions);
     else
     {
         Error error;
         error.SetErrorStringWithFormat("remote platform %s doesn't support %s", GetPluginName().GetCString(), __PRETTY_FUNCTION__);
         return error;
     }
 }
 

 
 
 bool
 Platform::CalculateMD5 (const FileSpec& file_spec,
                         uint64_t &low,
                         uint64_t &high)
 {
     if (IsHost())
-        return Host::CalculateMD5(file_spec, low, high);
+        return FileSystem::CalculateMD5(file_spec, low, high);
     else
         return false;
 }
 
 Error
 Platform::LaunchNativeProcess (
     ProcessLaunchInfo &launch_info,
     lldb_private::NativeProcessProtocol::NativeDelegate &native_delegate,

lldb/trunk/source/Target/Process.cpp

ProcessLaunchCommandOptions::SetOptionValue (uint32_t option_idx, const char *option_arg)
     
     switch (short_option)
     {
         case 's':   // Stop at program entry point
             launch_info.GetFlags().Set (eLaunchFlagStopAtEntry); 
             break;
             
         case 'i':   // STDIN for read only
-            {   
-                FileAction action;
-                if (action.Open (STDIN_FILENO, option_arg, true, false))
-                    launch_info.AppendFileAction (action);
-            }
+        {
             break;
+        }
             
         case 'o':   // Open STDOUT for write only
-            {   
-                FileAction action;
-                if (action.Open (STDOUT_FILENO, option_arg, false, true))
-                    launch_info.AppendFileAction (action);
-            }
+        {
             break;
+        }
 
         case 'e':   // STDERR for write only
-            {   
-                FileAction action;
-                if (action.Open (STDERR_FILENO, option_arg, false, true))
-                    launch_info.AppendFileAction (action);
-            }
+        {
             break;
-            
+        }
 
         case 'p':   // Process plug-in name
             launch_info.SetProcessPluginName (option_arg);    
             break;
             
         case 'n':   // Disable STDIO
-            {
-                FileAction action;
-                if (action.Open (STDIN_FILENO, "/dev/null", true, false))
-                    launch_info.AppendFileAction (action);
-                if (action.Open (STDOUT_FILENO, "/dev/null", false, true))
-                    launch_info.AppendFileAction (action);
-                if (action.Open (STDERR_FILENO, "/dev/null", false, true))
-                    launch_info.AppendFileAction (action);
-            }
             break;
+        }
             
         case 'w': 
             launch_info.SetWorkingDirectory (option_arg);    
             break;
             
         case 't':   // Open process in new terminal window
             launch_info.GetFlags().Set (eLaunchFlagLaunchInTTY); 
             break;
switch (short_option)
             
         case 'v':
             launch_info.GetEnvironmentEntries().AppendArgument(option_arg);
             break;
 
         default:
             error.SetErrorStringWithFormat("unrecognized short option character '%c'", short_option);
             break;
-            
     }
     return error;
 }
 
 OptionDefinition
 ProcessLaunchCommandOptions::g_option_table[] =
 {
 { LLDB_OPT_SET_ALL, false, "stop-at-entry", 's', OptionParser::eNoArgument,       NULL, NULL, 0, eArgTypeNone,          "Stop at the entry point of the program when launching a process."},

lldb/trunk/source/Target/ProcessLaunchInfo.cpp

ProcessLaunchInfo::ProcessLaunchInfo () :
     m_resume_count (0),
     m_monitor_callback (NULL),
     m_monitor_callback_baton (NULL),
     m_monitor_signals (false),
     m_hijack_listener_sp ()
 {
 }
 
-ProcessLaunchInfo::ProcessLaunchInfo (const char *stdin_path,
-                                      const char *stdout_path,
-                                      const char *stderr_path,
-                                      const char *working_directory,
-                                      uint32_t launch_flags) :
-    ProcessInfo(),
-    m_working_dir (),
-    m_plugin_name (),
-    m_shell (),
-    m_flags (launch_flags),
-    m_file_actions (),
-    m_pty (),
-    m_resume_count (0),
-    m_monitor_callback (NULL),
-    m_monitor_callback_baton (NULL),
-    m_monitor_signals (false),
-    m_hijack_listener_sp ()
+ProcessLaunchInfo::ProcessLaunchInfo(const char *stdin_path, const char *stdout_path, const char *stderr_path,
+                                     const char *working_directory, uint32_t launch_flags)
+    : ProcessInfo()
+    , m_working_dir()
+    , m_plugin_name()
+    , m_shell()
+    , m_flags(launch_flags)
+    , m_file_actions()
+    , m_pty()
+    , m_resume_count(0)
+    , m_monitor_callback(NULL)
+    , m_monitor_callback_baton(NULL)
+    , m_monitor_signals(false)
+    , m_hijack_listener_sp()
 {
     if (stdin_path)
     {
         FileAction file_action;
         const bool read = true;
         const bool write = false;
         if (file_action.Open(STDIN_FILENO, stdin_path, read, write))
             AppendFileAction (file_action);
ProcessLaunchInfo::AppendSuppressFileAction (int fd, bool read, bool write)
     {
         AppendFileAction (file_action);
         return true;
     }
     return false;
 }
 
 const FileAction *
-ProcessLaunchInfo::GetFileActionAtIndex (size_t idx) const
+ProcessLaunchInfo::GetFileActionAtIndex(size_t idx) const
 {
     if (idx < m_file_actions.size())
         return &m_file_actions[idx];
     return NULL;
 }
 
 const FileAction *
-ProcessLaunchInfo::GetFileActionForFD (int fd) const
+ProcessLaunchInfo::GetFileActionForFD(int fd) const
 {
     for (size_t idx=0, count=m_file_actions.size(); idx < count; ++idx)
     {
         if (m_file_actions[idx].GetFD () == fd)
             return &m_file_actions[idx];
     }
     return NULL;
 }