Creates a HostInfo class from code that was previously in Host.

[zturner]

Summary

This change implements the beginning of the HostInfo class - a class whose purpose is to answer queries about the host operating system.

This compiles successfully and passes all tests on Linux, MacOSX, and Windows. I do not have access to a FreeBSD build machine, so would appreciate help there.

[zturner]

Closed by commit rL215992 (authored by @zturner).

lldb/trunk/include/lldb/Core/ArchSpec.h

public:
     const ConstString&
     GetDistributionId () const;
 
     //------------------------------------------------------------------
     /// Set the distribution id of the architecture.
     ///
     /// This will be something like "ubuntu", "fedora", etc. on Linux.
     /// This should be the same value returned by
-    /// Host::GetDistributionId ().
+    /// HostInfo::GetDistributionId ().
     ///------------------------------------------------------------------
     void
     SetDistributionId (const char* distribution_id);
 
     //------------------------------------------------------------------
     /// Tests if this ArchSpec is valid.
     ///
     /// @return True if the current architecture is valid, false

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

public:
     /// @see static void Host::StopMonitoringChildProcess (uint32_t)
     //------------------------------------------------------------------
     static lldb::thread_t
     StartMonitoringChildProcess (MonitorChildProcessCallback callback,
                                  void *callback_baton,
                                  lldb::pid_t pid,
                                  bool monitor_signals);
 
-    //------------------------------------------------------------------
-    /// Get the host page size.
-    ///
-    /// @return
-    ///     The size in bytes of a VM page on the host system.
-    //------------------------------------------------------------------
-    static size_t
-    GetPageSize();
-
-    //------------------------------------------------------------------
-    /// Returns the endianness of the host system.
-    ///
-    /// @return
-    ///     Returns the endianness of the host system as a lldb::ByteOrder
-    ///     enumeration.
-    //------------------------------------------------------------------
-    static lldb::ByteOrder
-    GetByteOrder ();
-
-    //------------------------------------------------------------------
-    /// Returns the number of CPUs on this current host.
-    ///
-    /// @return
-    ///     Number of CPUs on this current host, or zero if the number
-    ///     of CPUs can't be determined on this host.
-    //------------------------------------------------------------------
-    static uint32_t
-    GetNumberCPUS ();
-
-    static bool
-    GetOSVersion (uint32_t &major, 
-                  uint32_t &minor, 
-                  uint32_t &update);
-
-    static bool
-    GetOSBuildString (std::string &s);
-    
-    static bool
-    GetOSKernelDescription (std::string &s);
-
-    static bool
-    GetHostname (std::string &s);
-
     static const char *
     GetUserName (uint32_t uid, std::string &user_name);
     
     static const char *
     GetGroupName (uint32_t gid, std::string &group_name);
     
     static uint32_t
     GetUserID ();
enum SystemDefaultArchitecture
         eSystemDefaultArchitecture32,   // If this host supports 32 bit programs, return the default 32 bit arch
         eSystemDefaultArchitecture64    // If this host supports 64 bit programs, return the default 64 bit arch
     };
 
     static const ArchSpec &
     GetArchitecture (SystemDefaultArchitecture arch_kind = eSystemDefaultArchitecture);
 
     //------------------------------------------------------------------
-    /// Gets the host vendor string.
-    ///
-    /// @return
-    ///     A const string object containing the host vendor name.
-    //------------------------------------------------------------------
-    static const ConstString &
-    GetVendorString ();
-
-    //------------------------------------------------------------------
-    /// Gets the host Operating System (OS) string.
-    ///
-    /// @return
-    ///     A const string object containing the host OS name.
-    //------------------------------------------------------------------
-    static const ConstString &
-    GetOSString ();
-
-    //------------------------------------------------------------------
-    /// Gets the host target triple as a const string.
-    ///
-    /// @return
-    ///     A const string object containing the host target triple.
-    //------------------------------------------------------------------
-    static const ConstString &
-    GetTargetTriple ();
-
-    //------------------------------------------------------------------
-    /// Gets the name of the distribution (i.e. distributor id).
-    ///
-    /// On Linux, this will return the equivalent of lsb_release -i.
-    /// Android will return 'android'.  Other systems may return
-    /// nothing.
-    ///
-    /// @return
-    ///     A ConstString reference containing the OS distribution id.
-    ///     The return string will be all lower case, with whitespace
-    ///     replaced with underscores.  The return string will be
-    ///     empty (result.AsCString() will return NULL) if the distribution
-    ///     cannot be obtained.
-    //------------------------------------------------------------------
-    static const ConstString &
-    GetDistributionId ();
-
-    //------------------------------------------------------------------
     /// Get the process ID for the calling process.
     ///
     /// @return
     ///     The process ID for the current process.
     //------------------------------------------------------------------
     static lldb::pid_t
     GetCurrentProcessID ();
 

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

+//===-- HostInfoBase.h ------------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef lldb_Host_HostInfo_h_
+#define lldb_Host_HostInfo_h_
+
+//----------------------------------------------------------------------
+/// @class HostInfo HostInfo.h "lldb/Host/HostInfo.h"
+/// @brief A class that provides host computer information.
+///
+/// HostInfo is a class that answers information about the host operating
+/// system.  Note that HostInfo is NOT intended to be used to manipulate or
+/// control the operating system.
+///
+/// HostInfo is implemented in an OS-specific class (for example
+/// HostInfoWindows) in a separate file, and then typedefed to HostInfo here.
+/// Users of the class reference it as HostInfo::method().
+///
+/// Not all hosts provide the same functionality.  It is important that methods
+/// only be implemented at the lowest level at which they make sense.  It should
+/// be up to the clients of the class to ensure that they not attempt to call a
+/// method which doesn't make sense for a particular platform.  For example,
+/// when implementing a method that only makes sense on a posix-compliant
+/// system, implement it on HostInfoPosix, and not on HostInfoBase with a
+/// default implementation.  This way, users of HostInfo are required to think
+/// about the implications of calling a particular method and if used in a
+/// context where the method doesn't make sense, will generate a compiler error.
+///
+//----------------------------------------------------------------------
+
+#if defined(_WIN32)
+#include "lldb/Host/windows/HostInfoWindows.h"
+#define HOST_INFO_TYPE HostInfoWindows
+#elif defined(__linux__)
+#include "lldb/Host/linux/HostInfoLinux.h"
+#define HOST_INFO_TYPE HostInfoLinux
+#elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
+#include "lldb/Host/freebsd/HostInfoFreeBSD.h"
+#define HOST_INFO_TYPE HostInfoFreeBSD
+#elif defined(__APPLE__)
+#include "lldb/Host/macosx/HostInfoMacOSX.h"
+#define HOST_INFO_TYPE HostInfoMacOSX
+#else
+#include "lldb/Host/posix/HostInfoPosix.h"
+#define HOST_INFO_TYPE HostInfoPosix
+#endif
+
+namespace lldb_private
+{
+typedef HOST_INFO_TYPE HostInfo;
+}
+
+#undef HOST_INFO_TYPE
+
+#endif

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

+//===-- HostInfoBase.h ------------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef lldb_Host_HostInfoBase_h_
+#define lldb_Host_HostInfoBase_h_
+
+#include "llvm/ADT/StringRef.h"
+
+#include <stdint.h>
+
+#include <string>
+
+namespace lldb_private
+{
+
+class HostInfoBase
+{
+  private:
+    // Static class, unconstructable.
+    HostInfoBase() {}
+    ~HostInfoBase() {}
+
+  public:
+    //------------------------------------------------------------------
+    /// Returns the number of CPUs on this current host.
+    ///
+    /// @return
+    ///     Number of CPUs on this current host, or zero if the number
+    ///     of CPUs can't be determined on this host.
+    //------------------------------------------------------------------
+    static uint32_t GetNumberCPUS();
+
+    //------------------------------------------------------------------
+    /// Gets the host vendor string.
+    ///
+    /// @return
+    ///     A const string object containing the host vendor name.
+    //------------------------------------------------------------------
+    static llvm::StringRef GetVendorString();
+
+    //------------------------------------------------------------------
+    /// Gets the host Operating System (OS) string.
+    ///
+    /// @return
+    ///     A const string object containing the host OS name.
+    //------------------------------------------------------------------
+    static llvm::StringRef GetOSString();
+
+    //------------------------------------------------------------------
+    /// Gets the host target triple as a const string.
+    ///
+    /// @return
+    ///     A const string object containing the host target triple.
+    //------------------------------------------------------------------
+    static llvm::StringRef GetTargetTriple();
+
+  protected:
+    static uint32_t m_number_cpus;
+    static std::string m_vendor_string;
+    static std::string m_os_string;
+    static std::string m_host_triple;
+};
+}
+
+#endif

lldb/trunk/include/lldb/Host/freebsd/HostInfoFreeBSD.h

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

lldb/trunk/include/lldb/Host/linux/HostInfoLinux.h

+//===-- HostInfoLinux.h -----------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef lldb_Host_linux_HostInfoLinux_h_
+#define lldb_Host_linux_HostInfoLinux_h_
+
+#include "lldb/Host/posix/HostInfoPosix.h"
+#include "llvm/ADT/StringRef.h"
+
+#include <string>
+
+namespace lldb_private
+{
+
+class HostInfoLinux : public HostInfoPosix
+{
+  private:
+    // Static class, unconstructable.
+    HostInfoLinux();
+    ~HostInfoLinux();
+
+  public:
+    static bool GetOSVersion(uint32_t &major, uint32_t &minor, uint32_t &update);
+    static llvm::StringRef GetDistributionId();
+
+  protected:
+    static std::string m_distribution_id;
+    static uint32_t m_os_major;
+    static uint32_t m_os_minor;
+    static uint32_t m_os_update;
+};
+}
+
+#endif

lldb/trunk/include/lldb/Host/macosx/HostInfoMacOSX.h

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

lldb/trunk/include/lldb/Host/posix/HostInfoPosix.h

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

lldb/trunk/include/lldb/Host/windows/HostInfoWindows.h

+//===-- HostInfoWindows.h ---------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef lldb_Host_windows_HostInfoWindows_h_
+#define lldb_Host_windows_HostInfoWindows_h_
+
+#include "lldb/Host/HostInfoBase.h"
+
+namespace lldb_private
+{
+
+class HostInfoWindows : public HostInfoBase
+{
+  private:
+    // Static class, unconstructable.
+    HostInfoWindows();
+    ~HostInfoWindows();
+
+  public:
+    static size_t GetPageSize();
+
+    static bool GetOSVersion(uint32_t &major, uint32_t &minor, uint32_t &update);
+    static bool GetOSBuildString(std::string &s);
+    static bool GetOSKernelDescription(std::string &s);
+    static bool GetHostname(std::string &s);
+};
+}
+
+#endif

lldb/trunk/include/lldb/Target/Platform.h

public:
         virtual void
         GetStatus (Stream &strm);
 
         //------------------------------------------------------------------
         // Subclasses must be able to fetch the current OS version
         //
         // Remote classes must be connected for this to succeed. Local 
         // subclasses don't need to override this function as it will just
-        // call the Host::GetOSVersion().
+        // call the HostInfo::GetOSVersion().
         //------------------------------------------------------------------
         virtual bool
         GetRemoteOSVersion ()
         {
             return false;
         }
 
         virtual bool
//                Error &error) = 0;
                              NativeProcessProtocolSP &process_sp);
 
     protected:
         bool m_is_host;
         // Set to true when we are able to actually set the OS version while 
         // being connected. For remote platforms, we might set the version ahead
         // of time before we actually connect and this version might change when
         // we actually connect to a remote platform. For the host platform this
-        // will be set to the once we call Host::GetOSVersion().
+        // will be set to the once we call HostInfo::GetOSVersion().
         bool m_os_version_set_while_connected;
         bool m_system_arch_set_while_connected;
         ConstString m_sdk_sysroot; // the root location of where the SDK files are all located
         ConstString m_sdk_build;
         ConstString m_working_dir; // The working directory which is used when installing modules that have no install path set
         std::string m_remote_url;
         std::string m_name;
         uint32_t m_major_os_version;

lldb/trunk/lldb.xcodeproj/project.pbxproj

/* Begin PBXBuildFile section */
     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 */; };
+    3FDFE52C19A2917A009756A7 /* HostInfoMacOSX.mm in Sources */ = {isa = PBXBuildFile; fileRef = 3FDFE52B19A2917A009756A7 /* HostInfoMacOSX.mm */; };
+    3FDFE53119A292F0009756A7 /* HostInfoPosix.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 3FDFE53019A292F0009756A7 /* HostInfoPosix.cpp */; };
+    3FDFE53319A29304009756A7 /* HostInfoPosix.h in Headers */ = {isa = PBXBuildFile; fileRef = 3FDFE53219A29304009756A7 /* HostInfoPosix.h */; };
+    3FDFE53519A29327009756A7 /* HostInfoBase.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 3FDFE53419A29327009756A7 /* HostInfoBase.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 */
     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>"; };
+    3FDFE52B19A2917A009756A7 /* HostInfoMacOSX.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; name = HostInfoMacOSX.mm; path = source/Host/macosx/HostInfoMacOSX.mm; sourceTree = "<group>"; };
+    3FDFE52D19A291AF009756A7 /* HostInfoMacOSX.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; name = HostInfoMacOSX.h; path = include/lldb/Host/macosx/HostInfoMacOSX.h; sourceTree = "<group>"; };
+    3FDFE53019A292F0009756A7 /* HostInfoPosix.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = HostInfoPosix.cpp; path = source/Host/posix/HostInfoPosix.cpp; sourceTree = "<group>"; };
+    3FDFE53219A29304009756A7 /* HostInfoPosix.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = HostInfoPosix.h; path = include/lldb/Host/posix/HostInfoPosix.h; sourceTree = "<group>"; };
+    3FDFE53419A29327009756A7 /* HostInfoBase.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = HostInfoBase.cpp; sourceTree = "<group>"; };
+    3FDFE53619A2933E009756A7 /* HostInfoLinux.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = HostInfoLinux.cpp; sourceTree = "<group>"; };
+    3FDFE53719A2936B009756A7 /* HostInfo.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; name = HostInfo.h; path = include/lldb/Host/HostInfo.h; sourceTree = "<group>"; };
+    3FDFE53819A2936B009756A7 /* HostInfoBase.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; name = HostInfoBase.h; path = include/lldb/Host/HostInfoBase.h; sourceTree = "<group>"; };
+    3FDFE53B19A293B3009756A7 /* HostInfoFreeBSD.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; name = HostInfoFreeBSD.cpp; path = source/Host/freebsd/HostInfoFreeBSD.cpp; sourceTree = "<group>"; };
+    3FDFE53C19A293CA009756A7 /* Config.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; name = Config.h; path = include/lldb/Host/freebsd/Config.h; sourceTree = "<group>"; };
+    3FDFE53D19A293CA009756A7 /* HostInfoFreeBSD.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; name = HostInfoFreeBSD.h; path = include/lldb/Host/freebsd/HostInfoFreeBSD.h; sourceTree = "<group>"; };
+    3FDFE53F19A29448009756A7 /* Condition.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; name = Condition.cpp; path = source/Host/windows/Condition.cpp; sourceTree = "<group>"; };
+    3FDFE54019A29448009756A7 /* EditLineWin.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; name = EditLineWin.cpp; path = source/Host/windows/EditLineWin.cpp; sourceTree = "<group>"; };
+    3FDFE54119A29448009756A7 /* FileSystem.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; name = FileSystem.cpp; path = source/Host/windows/FileSystem.cpp; sourceTree = "<group>"; };
+    3FDFE54219A29448009756A7 /* Host.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; name = Host.cpp; path = source/Host/windows/Host.cpp; sourceTree = "<group>"; };
+    3FDFE54319A29448009756A7 /* HostInfoWindows.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; name = HostInfoWindows.cpp; path = source/Host/windows/HostInfoWindows.cpp; sourceTree = "<group>"; };
+    3FDFE54419A29448009756A7 /* Mutex.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; name = Mutex.cpp; path = source/Host/windows/Mutex.cpp; sourceTree = "<group>"; };
+    3FDFE54519A29448009756A7 /* ProcessRunLock.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; name = ProcessRunLock.cpp; path = source/Host/windows/ProcessRunLock.cpp; sourceTree = "<group>"; };
+    3FDFE54619A29448009756A7 /* Windows.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; name = Windows.cpp; path = source/Host/windows/Windows.cpp; sourceTree = "<group>"; };
+    3FDFE54719A2946B009756A7 /* AutoHandle.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; name = AutoHandle.h; path = include/lldb/Host/windows/AutoHandle.h; sourceTree = "<group>"; };
+    3FDFE54819A2946B009756A7 /* editlinewin.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; name = editlinewin.h; path = include/lldb/Host/windows/editlinewin.h; sourceTree = "<group>"; };
+    3FDFE54919A2946B009756A7 /* HostInfoWindows.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; name = HostInfoWindows.h; path = include/lldb/Host/windows/HostInfoWindows.h; sourceTree = "<group>"; };
+    3FDFE54A19A2946B009756A7 /* win32.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; name = win32.h; path = include/lldb/Host/windows/win32.h; sourceTree = "<group>"; };
+    3FDFE54B19A2946B009756A7 /* windows.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; name = windows.h; path = include/lldb/Host/windows/windows.h; 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>"; };
233B008B196106E90090E598 /* Linux */ = {
       );
       path = Linux;
       sourceTree = "<group>";
     };
     233B009C19610D130090E598 /* linux */ = {
       isa = PBXGroup;
       children = (
         233B009D19610D6B0090E598 /* Host.cpp */,
+        3FDFE53619A2933E009756A7 /* HostInfoLinux.cpp */,
       );
       name = linux;
       path = source/Host/linux;
       sourceTree = "<group>";
     };
     23AB0526199FF5D3003B8084 /* FreeBSD */ = {
       isa = PBXGroup;
       children = (
26BC7DBE10F1B78200F91463 /* Expression */ = {
       );
       name = Expression;
       sourceTree = "<group>";
     };
     26BC7DD010F1B7C100F91463 /* Host */ = {
       isa = PBXGroup;
       children = (
         69A01E1A1236C5D400C660B5 /* common */,
+        3FDFE53919A29399009756A7 /* freebsd */,
         233B009C19610D130090E598 /* linux */,
         26BC7EE510F1B88100F91463 /* MacOSX */,
         3FDFDDC4199D37BE009756A7 /* posix */,
+        3FDFE53E19A2940E009756A7 /* windows */,
         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 */,
+        3FDFE53719A2936B009756A7 /* HostInfo.h */,
+        3FDFE53819A2936B009756A7 /* HostInfoBase.h */,
         236124A61986B50E004EFC37 /* IoObject.h */,
         26BC7DD510F1B7D500F91463 /* Mutex.h */,
         232CB60B191E00CC00EF39FC /* NativeBreakpoint.cpp */,
         232CB60C191E00CC00EF39FC /* NativeBreakpoint.h */,
         232CB60D191E00CC00EF39FC /* NativeBreakpointList.cpp */,
         232CB60E191E00CC00EF39FC /* NativeBreakpointList.h */,
         232CB60F191E00CC00EF39FC /* NativeProcessProtocol.cpp */,
         232CB610191E00CC00EF39FC /* NativeProcessProtocol.h */,
26BC7DEF10F1B80200F91463 /* Target */ = {
         23F403481926CC250046DC9B /* NativeRegisterContextRegisterInfo.cpp */,
       );
       name = Target;
       sourceTree = "<group>";
     };
     26BC7EE510F1B88100F91463 /* MacOSX */ = {
       isa = PBXGroup;
       children = (
+        3FDFE52D19A291AF009756A7 /* HostInfoMacOSX.h */,
+        3FDFE52B19A2917A009756A7 /* HostInfoMacOSX.mm */,
         26BC7EED10F1B8AD00F91463 /* CFCBundle.cpp */,
         26BC7EEE10F1B8AD00F91463 /* CFCBundle.h */,
         26BC7EEF10F1B8AD00F91463 /* CFCData.cpp */,
         26BC7EF010F1B8AD00F91463 /* CFCData.h */,
         26BC7EF110F1B8AD00F91463 /* CFCMutableArray.cpp */,
         26BC7EF210F1B8AD00F91463 /* CFCMutableArray.h */,
         26BC7EF310F1B8AD00F91463 /* CFCMutableDictionary.cpp */,
         26BC7EF410F1B8AD00F91463 /* CFCMutableDictionary.h */,
26FFC19214FC072100087D58 /* POSIX-DYLD */ = {
         26FFC19814FC072100087D58 /* DynamicLoaderPOSIXDYLD.h */,
       );
       path = "POSIX-DYLD";
       sourceTree = "<group>";
     };
     3FDFDDC4199D37BE009756A7 /* posix */ = {
       isa = PBXGroup;
       children = (
+        3FDFE53219A29304009756A7 /* HostInfoPosix.h */,
+        3FDFE53019A292F0009756A7 /* HostInfoPosix.cpp */,
         3FDFDDC5199D37ED009756A7 /* FileSystem.cpp */,
       );
       name = posix;
       sourceTree = "<group>";
     };
+    3FDFE53919A29399009756A7 /* freebsd */ = {
+      isa = PBXGroup;
+      children = (
+        3FDFE53C19A293CA009756A7 /* Config.h */,
+        3FDFE53D19A293CA009756A7 /* HostInfoFreeBSD.h */,
+        3FDFE53B19A293B3009756A7 /* HostInfoFreeBSD.cpp */,
+      );
+      name = freebsd;
+      sourceTree = "<group>";
+    };
+    3FDFE53E19A2940E009756A7 /* windows */ = {
+      isa = PBXGroup;
+      children = (
+        3FDFE54719A2946B009756A7 /* AutoHandle.h */,
+        3FDFE53F19A29448009756A7 /* Condition.cpp */,
+        3FDFE54819A2946B009756A7 /* editlinewin.h */,
+        3FDFE54019A29448009756A7 /* EditLineWin.cpp */,
+        3FDFE54119A29448009756A7 /* FileSystem.cpp */,
+        3FDFE54219A29448009756A7 /* Host.cpp */,
+        3FDFE54919A2946B009756A7 /* HostInfoWindows.h */,
+        3FDFE54319A29448009756A7 /* HostInfoWindows.cpp */,
+        3FDFE54419A29448009756A7 /* Mutex.cpp */,
+        3FDFE54519A29448009756A7 /* ProcessRunLock.cpp */,
+        3FDFE54A19A2946B009756A7 /* win32.h */,
+        3FDFE54B19A2946B009756A7 /* windows.h */,
+        3FDFE54619A29448009756A7 /* Windows.cpp */,
+      );
+      name = windows;
+      sourceTree = "<group>";
+    };
     490A36BA180F0E6F00BA31F8 /* Windows */ = {
       isa = PBXGroup;
       children = (
         490A36BD180F0E6F00BA31F8 /* PlatformWindows.cpp */,
         490A36BE180F0E6F00BA31F8 /* PlatformWindows.h */,
       );
       path = Windows;
       sourceTree = "<group>";
4CEE62F71145F1C70064CF93 /* GDB Remote */ = {
       );
       name = "GDB Remote";
       path = "gdb-remote";
       sourceTree = "<group>";
     };
     69A01E1A1236C5D400C660B5 /* common */ = {
       isa = PBXGroup;
       children = (
-        AF37E10917C861F20061E18E /* ProcessRunLock.cpp */,
         9456F2211616644B00656F91 /* DynamicLibrary.cpp */,
         26CFDCA2186163A4000E63E5 /* Editline.cpp */,
         260C6EA213011581005E16B0 /* File.cpp */,
         26FA43171301048600E71120 /* FileSpec.cpp */,
         69A01E1B1236C5D400C660B5 /* Condition.cpp */,
         69A01E1C1236C5D400C660B5 /* Host.cpp */,
+        3FDFE53419A29327009756A7 /* HostInfoBase.cpp */,
         236124A21986B4E2004EFC37 /* IoObject.cpp */,
         69A01E1E1236C5D400C660B5 /* Mutex.cpp */,
         A36FF33B17D8E94600244D40 /* OptionParser.cpp */,
         260A39A719647A4E004B4130 /* Pipe.cpp */,
+        AF37E10917C861F20061E18E /* ProcessRunLock.cpp */,
         236124A31986B4E2004EFC37 /* Socket.cpp */,
         69A01E1F1236C5D400C660B5 /* Symbols.cpp */,
         268DA873130095ED00C9483A /* Terminal.cpp */,
         69A01E201236C5D400C660B5 /* TimeValue.cpp */,
       );
       name = common;
       path = source/Host/common;
       sourceTree = "<group>";
2689FFC813353D7A00698AC0 /* Headers */ = {
         26D1804516CEE12500EDFB5B /* KQueue.h in Headers */,
         260CC63715D04377002BF2E0 /* OptionValueSInt64.h in Headers */,
         AF061F8C182C980000B6A19C /* HistoryUnwind.h in Headers */,
         260CC63815D04377002BF2E0 /* OptionValueString.h in Headers */,
         260CC63915D04377002BF2E0 /* OptionValueUInt64.h in Headers */,
         AF0F6E511739A76D009180FE /* RegisterContextKDP_arm64.h in Headers */,
         260CC63A15D04377002BF2E0 /* OptionValueUUID.h in Headers */,
         260A248E15D06C50009981B0 /* OptionValues.h in Headers */,
+        3FDFE53319A29304009756A7 /* HostInfoPosix.h in Headers */,
         AF061F88182C97ED00B6A19C /* RegisterContextHistory.h in Headers */,
         26DAED6015D327A200E15819 /* OptionValuePathMappings.h in Headers */,
         26ACEC2815E077AE00E94760 /* Property.h in Headers */,
         26491E3B15E1DB8600CBFFC2 /* OptionValueRegex.h in Headers */,
         2697A39515E404BA003E682C /* OptionValueArch.h in Headers */,
         26474CBF18D0CB2D0073DEBA /* RegisterContextMach_i386.h in Headers */,
         26474CC118D0CB2D0073DEBA /* RegisterContextMach_x86_64.h in Headers */,
         2698699D15E6CBD0002415FF /* OperatingSystemPython.h in Headers */,
2689FFC613353D7A00698AC0 /* Sources */ = {
         2689007F13353E2200698AC0 /* CommandCompletions.cpp in Sources */,
         26CEB5F218762056008F575A /* CommandObjectGUI.cpp in Sources */,
         2689008013353E2200698AC0 /* CommandInterpreter.cpp in Sources */,
         AF9B8F33182DB52900DA866F /* SystemRuntimeMacOSX.cpp in Sources */,
         2689008113353E2200698AC0 /* CommandObject.cpp in Sources */,
         2689008313353E2200698AC0 /* CommandObjectMultiword.cpp in Sources */,
         2689008413353E2200698AC0 /* CommandObjectRegexCommand.cpp in Sources */,
         2689008513353E2200698AC0 /* CommandReturnObject.cpp in Sources */,
+        3FDFE53519A29327009756A7 /* HostInfoBase.cpp in Sources */,
         26474CBE18D0CB2D0073DEBA /* RegisterContextMach_i386.cpp in Sources */,
         2689008613353E2200698AC0 /* Options.cpp in Sources */,
         2689008713353E2200698AC0 /* ScriptInterpreter.cpp in Sources */,
         2689008813353E2200698AC0 /* ScriptInterpreterNone.cpp in Sources */,
         2689008913353E2200698AC0 /* ScriptInterpreterPython.cpp in Sources */,
         260A63191861009E00FECF8E /* IOHandler.cpp in Sources */,
         2689008D13353E4200698AC0 /* DynamicLoaderMacOSXDYLD.cpp in Sources */,
         2689008E13353E4200698AC0 /* DynamicLoaderStatic.cpp in Sources */,
2689FFC613353D7A00698AC0 /* Sources */ = {
         268900C113353E5F00698AC0 /* DWARFDebugPubnames.cpp in Sources */,
         268900C213353E5F00698AC0 /* DWARFDebugPubnamesSet.cpp in Sources */,
         268900C313353E5F00698AC0 /* DWARFDebugRanges.cpp in Sources */,
         94380B8219940B0A00BFE4A8 /* StringLexer.cpp in Sources */,
         268900C413353E5F00698AC0 /* DWARFDefines.cpp in Sources */,
         94D0B10C16D5535900EA9C70 /* LibCxx.cpp in Sources */,
         268900C513353E5F00698AC0 /* DWARFDIECollection.cpp in Sources */,
         268900C613353E5F00698AC0 /* DWARFFormValue.cpp in Sources */,
+        3FDFE53119A292F0009756A7 /* HostInfoPosix.cpp in Sources */,
         233B007D1960C9F90090E598 /* ProcessInfo.cpp in Sources */,
+        3FDFE52C19A2917A009756A7 /* HostInfoMacOSX.mm in Sources */,
         268900C713353E5F00698AC0 /* DWARFLocationDescription.cpp in Sources */,
         26BC17B118C7F4CB00D2196D /* ThreadElfCore.cpp in Sources */,
         268900C813353E5F00698AC0 /* DWARFLocationList.cpp in Sources */,
         268900C913353E5F00698AC0 /* NameToDIE.cpp in Sources */,
         268900CA13353E5F00698AC0 /* SymbolFileDWARF.cpp in Sources */,
         268900CB13353E5F00698AC0 /* LogChannelDWARF.cpp in Sources */,
         268900CC13353E5F00698AC0 /* SymbolFileDWARFDebugMap.cpp in Sources */,
         268900CD13353E5F00698AC0 /* UniqueDWARFASTType.cpp in Sources */,

lldb/trunk/source/Core/DataBufferMemoryMap.cpp

 #endif
 
 #include "llvm/Support/MathExtras.h"
 
 #include "lldb/Core/DataBufferMemoryMap.h"
 #include "lldb/Core/Error.h"
 #include "lldb/Host/File.h"
 #include "lldb/Host/FileSpec.h"
-#include "lldb/Host/Host.h"
+#include "lldb/Host/HostInfo.h"
 #include "lldb/Core/Log.h"
 #include "lldb/lldb-private-log.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 //----------------------------------------------------------------------
 // Default Constructor
#else
                     Error error;
 
                     if (m_mmap_addr == (void*)-1)
                     {
                         error.SetErrorToErrno ();
                         if (error.GetError() == EINVAL)
                         {
                             // We may still have a shot at memory mapping if we align things correctly
-                            size_t page_offset = offset % Host::GetPageSize();
+                            size_t page_offset = offset % HostInfo::GetPageSize();
                             if (page_offset != 0)
                             {
                                 m_mmap_addr = (uint8_t *)::mmap(NULL, length + page_offset, prot, flags, fd, offset - page_offset);
                                 if (m_mmap_addr == (void*)-1)
                                 {
                                     // Failed to map file
                                     m_mmap_addr = NULL;
                                 }

lldb/trunk/source/Expression/ClangUserExpression.cpp

 #include "lldb/Expression/ClangExpressionDeclMap.h"
 #include "lldb/Expression/ClangExpressionParser.h"
 #include "lldb/Expression/ClangFunction.h"
 #include "lldb/Expression/ClangUserExpression.h"
 #include "lldb/Expression/ExpressionSourceCode.h"
 #include "lldb/Expression/IRExecutionUnit.h"
 #include "lldb/Expression/IRInterpreter.h"
 #include "lldb/Expression/Materializer.h"
-#include "lldb/Host/Host.h"
+#include "lldb/Host/HostInfo.h"
 #include "lldb/Symbol/Block.h"
 #include "lldb/Symbol/ClangASTContext.h"
 #include "lldb/Symbol/Function.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/SymbolVendor.h"
 #include "lldb/Symbol/Type.h"
 #include "lldb/Symbol/ClangExternalASTSourceCommon.h"
 #include "lldb/Symbol/VariableList.h"
if (m_jit_start_addr != LLDB_INVALID_ADDRESS || m_can_interpret)
                                                       shared_ptr_to_me);
             lldb::ThreadPlanSP call_plan_sp(user_expression_plan);
 
             if (!call_plan_sp || !call_plan_sp->ValidatePlan (&error_stream))
                 return lldb::eExpressionSetupError;
 
             lldb::addr_t function_stack_pointer = user_expression_plan->GetFunctionStackPointer();
 
-            function_stack_bottom = function_stack_pointer - Host::GetPageSize();
+            function_stack_bottom = function_stack_pointer - HostInfo::GetPageSize();
             function_stack_top = function_stack_pointer;
 
             if (log)
                 log->Printf("-- [ClangUserExpression::Execute] Execution of expression begins --");
 
             if (exe_ctx.GetProcessPtr())
                 exe_ctx.GetProcessPtr()->SetRunningUserExpression(true);
 

lldb/trunk/source/Host/CMakeLists.txt

 macro(add_host_subdirectory group)
   list(APPEND HOST_SOURCES ${ARGN})
   source_group(${group} FILES ${ARGN})
 endmacro()
 
 add_host_subdirectory(common
   common/Condition.cpp
   common/DynamicLibrary.cpp
   common/Editline.cpp
   common/File.cpp
   common/FileCache.cpp
   common/FileSpec.cpp
   common/Host.cpp
+  common/HostInfoBase.cpp
   common/IOObject.cpp
   common/Mutex.cpp
   common/NativeBreakpoint.cpp
   common/NativeBreakpointList.cpp
   common/NativeProcessProtocol.cpp
   common/NativeThreadProtocol.cpp
   common/OptionParser.cpp
   common/Pipe.cpp
   common/ProcessRunLock.cpp
   common/Socket.cpp
   common/SocketAddress.cpp
   common/SoftwareBreakpoint.cpp
   common/Symbols.cpp
   common/Terminal.cpp
   common/TimeValue.cpp
   )
 
 if (CMAKE_SYSTEM_NAME MATCHES "Windows")
   add_host_subdirectory(windows
     windows/FileSystem.cpp
     windows/Host.cpp
+    windows/HostInfoWindows.cpp
     windows/ProcessRunLock.cpp
     windows/Mutex.cpp
     windows/Condition.cpp
     windows/Windows.cpp
     windows/EditLineWin.cpp
     )
 else()
   add_host_subdirectory(posix
     posix/FileSystem.cpp
+    posix/HostInfoPosix.cpp
     )
 
   if (CMAKE_SYSTEM_NAME MATCHES "Darwin")
     include_directories(SYSTEM ${LIBXML2_INCLUDE_DIR})
     add_host_subdirectory(macosx
       macosx/Host.mm
       macosx/Symbols.cpp
       macosx/cfcpp/CFCBundle.cpp
       macosx/cfcpp/CFCData.cpp
       macosx/cfcpp/CFCMutableArray.cpp
       macosx/cfcpp/CFCMutableDictionary.cpp
       macosx/cfcpp/CFCMutableSet.cpp
       macosx/cfcpp/CFCString.cpp
       )
 
   elseif (CMAKE_SYSTEM_NAME MATCHES "Linux")
     add_host_subdirectory(linux
       linux/Host.cpp
+      linux/HostInfoLinux.cpp
       )
   elseif (CMAKE_SYSTEM_NAME MATCHES "FreeBSD")
     add_host_subdirectory(freebsd
       freebsd/Host.cpp
+      freebsd/HostInfoFreeBSD.cpp
       )
   endif()
 endif()
 
 add_lldb_library(lldbHost ${HOST_SOURCES})

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

 #if defined (__FreeBSD__)
 #include <pthread_np.h>
 #endif
 
 // C++ includes
 #include <limits>
 
 #include "lldb/Host/Host.h"
+#include "lldb/Host/HostInfo.h"
 #include "lldb/Core/ArchSpec.h"
 #include "lldb/Core/ConstString.h"
 #include "lldb/Core/Debugger.h"
 #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"
if (g_supports_32 == false && g_supports_64 == false)
 
         g_host_arch_32.Clear();
         g_host_arch_64.Clear();
 
         // If the OS is Linux, "unknown" in the vendor slot isn't what we want
         // for the default triple.  It's probably an artifact of config.guess.
         if (triple.getOS() == llvm::Triple::Linux && triple.getVendor() == llvm::Triple::UnknownVendor)
             triple.setVendorName ("");
-
-        const char* distribution_id = GetDistributionId ().AsCString();
-
+#if defined(__linux__)
+        const char *distribution_id = HostInfo::GetDistributionId().data();
+#else
+        const char *distribution_id = "";
+#endif
         switch (triple.getArch())
         {
         default:
             g_host_arch_32.SetTriple(triple);
             g_host_arch_32.SetDistributionId (distribution_id);
             g_supports_32 = true;
             break;
 
#endif
             g_host_arch_64.SetDistributionId (distribution_id);
             g_supports_64 = true;
             break;
         }
 
         g_supports_32 = g_host_arch_32.IsValid();
         g_supports_64 = g_host_arch_64.IsValid();
     }
-    
 #endif // #else for #if defined (__APPLE__)
     
     if (arch_kind == eSystemDefaultArchitecture32)
         return g_host_arch_32;
     else if (arch_kind == eSystemDefaultArchitecture64)
         return g_host_arch_64;
 
     if (g_supports_64)
         return g_host_arch_64;
         
     return g_host_arch_32;
 }
 
-const ConstString &
-Host::GetVendorString()
-{
-    static ConstString g_vendor;
-    if (!g_vendor)
-    {
-        const ArchSpec &host_arch = GetArchitecture (eSystemDefaultArchitecture);
-        const llvm::StringRef &str_ref = host_arch.GetTriple().getVendorName();
-        g_vendor.SetCStringWithLength(str_ref.data(), str_ref.size());
-    }
-    return g_vendor;
-}
-
-const ConstString &
-Host::GetOSString()
-{
-    static ConstString g_os_string;
-    if (!g_os_string)
-    {
-        const ArchSpec &host_arch = GetArchitecture (eSystemDefaultArchitecture);
-        const llvm::StringRef &str_ref = host_arch.GetTriple().getOSName();
-        g_os_string.SetCStringWithLength(str_ref.data(), str_ref.size());
-    }
-    return g_os_string;
-}
-
-const ConstString &
-Host::GetTargetTriple()
-{
-    static ConstString g_host_triple;
-    if (!(g_host_triple))
-    {
-        const ArchSpec &host_arch = GetArchitecture (eSystemDefaultArchitecture);
-        g_host_triple.SetCString(host_arch.GetTriple().getTriple().c_str());
-    }
-    return g_host_triple;
-}
-
-// See linux/Host.cpp for Linux-based implementations of this.
-// Add your platform-specific implementation to the appropriate host file.
-#if !defined(__linux__)
-
-const ConstString &
-    Host::GetDistributionId ()
-{
-    static ConstString s_distribution_id;
-    return s_distribution_id;
-}
-
-#endif // #if !defined(__linux__)
-
 lldb::pid_t
 Host::GetCurrentProcessID()
 {
     return ::getpid();
 }
 
 #ifndef _WIN32
 
case ePathTypeLLDBTempSystemDir:
             file_spec.GetDirectory() = g_lldb_tmp_dir;
             return (bool)file_spec.GetDirectory();
         }
     }
 
     return false;
 }
 
-
-bool
-Host::GetHostname (std::string &s)
-{
-    char hostname[PATH_MAX];
-    hostname[sizeof(hostname) - 1] = '\0';
-    if (::gethostname (hostname, sizeof(hostname) - 1) == 0)
-    {
-        struct hostent* h = ::gethostbyname (hostname);
-        if (h)
-            s.assign (h->h_name);
-        else
-            s.assign (hostname);
-        return true;
-    }
-    return false;
-}
-
 #ifndef _WIN32
 
 const char *
 Host::GetUserName (uint32_t uid, std::string &user_name)
 {
     struct passwd user_info;
     struct passwd *user_info_ptr = &user_info;
     char user_buffer[PATH_MAX];

 uint32_t
 Host::GetEffectiveGroupID ()
 {
     return getegid();
 }
 
 #endif
 
-#if !defined (__APPLE__) && !defined (__FreeBSD__) && !defined (__FreeBSD_kernel__) // see macosx/Host.mm
-bool
-Host::GetOSBuildString (std::string &s)
-{
-    s.clear();
-    return false;
-}
-
-bool
-Host::GetOSKernelDescription (std::string &s)
-{
-    s.clear();
-    return false;
-}
-#endif
-
 #if !defined (__APPLE__) && !defined (__FreeBSD__) && !defined (__FreeBSD_kernel__) \
     && !defined(__linux__) && !defined(_WIN32)
 uint32_t
 Host::FindProcesses (const ProcessInstanceInfoMatch &match_info, ProcessInstanceInfoList &process_infos)
 {
     process_infos.Clear();
     return process_infos.GetSize();
 }

 #ifdef POSIX_SPAWN_CLOEXEC_DEFAULT
 #if defined (__APPLE__) && (defined (__x86_64__) || defined (__i386__))
     static LazyBool g_use_close_on_exec_flag = eLazyBoolCalculate;
     if (g_use_close_on_exec_flag == eLazyBoolCalculate)
     {
         g_use_close_on_exec_flag = eLazyBoolNo;
         
         uint32_t major, minor, update;
-        if (Host::GetOSVersion(major, minor, update))
+        if (HostInfo::GetOSVersion(major, minor, update))
         {
             // Kernel panic if we use the POSIX_SPAWN_CLOEXEC_DEFAULT on 10.7 or earlier
             if (major > 10 || (major == 10 && minor > 7))
             {
                 // Only enable for 10.8 and later OS versions
                 g_use_close_on_exec_flag = eLazyBoolYes;
             }
         }
Host::LaunchProcess (ProcessLaunchInfo &launch_info)
     }
     return error;
 }
 
 #endif // defined(__linux__) || defined(__FreeBSD__) || defined(__NetBSD__)
 
 #ifndef _WIN32
 
-size_t
-Host::GetPageSize()
-{
-    return ::getpagesize();
-}
-
-uint32_t
-Host::GetNumberCPUS ()
-{
-    static uint32_t g_num_cores = UINT32_MAX;
-    if (g_num_cores == UINT32_MAX)
-    {
-#if defined(__APPLE__) or defined (__linux__) or defined (__FreeBSD__) or defined (__FreeBSD_kernel__)
-
-        g_num_cores = ::sysconf(_SC_NPROCESSORS_ONLN);
-
-#else
-        
-        // Assume POSIX support if a host specific case has not been supplied above
-        g_num_cores = 0;
-        int num_cores = 0;
-        size_t num_cores_len = sizeof(num_cores);
-#ifdef HW_AVAILCPU
-        int mib[] = { CTL_HW, HW_AVAILCPU };
-#else
-        int mib[] = { CTL_HW, HW_NCPU };
-#endif
-        
-        /* get the number of CPUs from the system */
-        if (sysctl(mib, llvm::array_lengthof(mib), &num_cores, &num_cores_len, NULL, 0) == 0 && (num_cores > 0))
-        {
-            g_num_cores = num_cores;
-        }
-        else
-        {
-            mib[1] = HW_NCPU;
-            num_cores_len = sizeof(num_cores);
-            if (sysctl(mib, llvm::array_lengthof(mib), &num_cores, &num_cores_len, NULL, 0) == 0 && (num_cores > 0))
-            {
-                if (num_cores > 0)
-                    g_num_cores = num_cores;
-            }
-        }
-#endif
-    }
-    return g_num_cores;
-}
-
 void
 Host::Kill(lldb::pid_t pid, int signo)
 {
     ::kill(pid, signo);
 }
 
 #endif
 

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

+//===-- HostInfoBase.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/Config.h"
+
+#include "lldb/Core/ArchSpec.h"
+#include "lldb/Host/HostInfoBase.h"
+#include "lldb/Host/Host.h"
+
+#include <thread>
+
+using namespace lldb;
+using namespace lldb_private;
+
+uint32_t HostInfoBase::m_number_cpus = 0;
+std::string HostInfoBase::m_vendor_string;
+std::string HostInfoBase::m_os_string;
+std::string HostInfoBase::m_host_triple;
+
+uint32_t
+HostInfoBase::GetNumberCPUS()
+{
+    static bool is_initialized = false;
+    if (!is_initialized)
+    {
+        m_number_cpus = std::thread::hardware_concurrency();
+        is_initialized = true;
+    }
+
+    return m_number_cpus;
+}
+
+llvm::StringRef
+HostInfoBase::GetVendorString()
+{
+    static bool is_initialized = false;
+    if (!is_initialized)
+    {
+        const ArchSpec &host_arch = Host::GetArchitecture();
+        const llvm::StringRef &str_ref = host_arch.GetTriple().getVendorName();
+        m_vendor_string.assign(str_ref.begin(), str_ref.end());
+        is_initialized = true;
+    }
+    return m_vendor_string;
+}
+
+llvm::StringRef
+HostInfoBase::GetOSString()
+{
+    static bool is_initialized = false;
+    if (!is_initialized)
+    {
+        const ArchSpec &host_arch = Host::GetArchitecture();
+        const llvm::StringRef &str_ref = host_arch.GetTriple().getOSName();
+        m_os_string.assign(str_ref.begin(), str_ref.end());
+        is_initialized = true;
+    }
+    return m_os_string;
+}
+
+llvm::StringRef
+HostInfoBase::GetTargetTriple()
+{
+    static bool is_initialized = false;
+    if (!is_initialized)
+    {
+        const ArchSpec &host_arch = Host::GetArchitecture();
+        m_host_triple = host_arch.GetTriple().getTriple();
+        is_initialized = true;
+    }
+    return m_host_triple;
+}

lldb/trunk/source/Host/freebsd/Host.cpp

 //===-- source/Host/freebsd/Host.cpp ------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // C Includes
 #include <stdio.h>
 #include <dlfcn.h>
 #include <execinfo.h>
 #include <sys/types.h>
 #include <sys/user.h>
-#include <sys/utsname.h>
 #include <sys/sysctl.h>
 #include <sys/proc.h>
 
 #include <sys/ptrace.h>
 #include <sys/exec.h>
 #include <machine/elf.h>
 
 // C++ Includes
for (; var != NULL && *var != NULL; ++var)
         v = strchr(*var, (int)'-');
         if (v == NULL)
             continue;
         env.AppendString(v);
     }
     return env.GetSize();
 }
 
-bool
-Host::GetOSVersion(uint32_t &major,
-                   uint32_t &minor,
-                   uint32_t &update)
-{
-    struct utsname un;
-
-    ::memset(&un, 0, sizeof(utsname));
-    if (uname(&un) < 0)
-        return false;
-
-    int status = sscanf(un.release, "%u.%u", &major, &minor);
-    return status == 2;
-}
-
-bool
-Host::GetOSBuildString (std::string &s)
-{
-    int mib[2] = { CTL_KERN, KERN_OSREV };
-    char osrev_str[12];
-    uint32_t osrev = 0;
-    size_t osrev_len = sizeof(osrev);
-
-    if (::sysctl (mib, 2, &osrev, &osrev_len, NULL, 0) == 0)
-    {
-        ::snprintf(osrev_str, sizeof(osrev_str), "%-8.8u", osrev);
-        s.assign (osrev_str);
-        return true;
-    }
-
-    s.clear();
-    return false;
-}
-
-bool
-Host::GetOSKernelDescription (std::string &s)
-{
-    struct utsname un;
-
-    ::memset(&un, 0, sizeof(utsname));
-    s.clear();
-
-    if (uname(&un) < 0)
-    return false;
-
-    s.assign (un.version);
-
-    return true;
-}
-
 static bool
 GetFreeBSDProcessArgs (const ProcessInstanceInfoMatch *match_info_ptr,
                       ProcessInstanceInfo &process_info)
 {
     if (process_info.ProcessIDIsValid())
     {
         int mib[4] = { CTL_KERN, KERN_PROC, KERN_PROC_ARGS, (int)process_info.GetProcessID() };
 

lldb/trunk/source/Host/freebsd/HostInfoFreeBSD.cpp

+//===-- HostInfoFreeBSD.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/freebsd/HostInfoFreeBSD.h"
+
+#include <stdio.h>
+#include <string.h>
+#include <sys/sysctl.h>
+#include <sys/utsname.h>
+
+bool
+HostInfoFreeBSD::GetOSVersion(uint32_t &major, uint32_t &minor, uint32_t &update)
+{
+    struct utsname un;
+
+    ::memset(&un, 0, sizeof(utsname));
+    if (uname(&un) < 0)
+        return false;
+
+    int status = sscanf(un.release, "%u.%u", &major, &minor);
+    return status == 2;
+}
+
+bool
+HostInfoFreeBSD::GetOSBuildString(std::string &s)
+{
+    int mib[2] = {CTL_KERN, KERN_OSREV};
+    char osrev_str[12];
+    uint32_t osrev = 0;
+    size_t osrev_len = sizeof(osrev);
+
+    if (::sysctl(mib, 2, &osrev, &osrev_len, NULL, 0) == 0)
+    {
+        ::snprintf(osrev_str, sizeof(osrev_str), "%-8.8u", osrev);
+        s.assign(osrev_str);
+        return true;
+    }
+
+    s.clear();
+    return false;
+}
+
+bool
+HostInfoFreeBSD::GetOSKernelDescription(std::string &s)
+{
+    struct utsname un;
+
+    ::memset(&un, 0, sizeof(utsname));
+    s.clear();
+
+    if (uname(&un) < 0)
+        return false;
+
+    s.assign(un.version);
+
+    return true;
+}

lldb/trunk/source/Host/linux/Host.cpp

GetLinuxProcessUserAndGroup (lldb::pid_t pid, ProcessInstanceInfo &process_info, lldb::pid_t &tracerpid)
     }
 
     process_info.SetUserID (rUid);
     process_info.SetEffectiveUserID (eUid);
     process_info.SetGroupID (rGid);
     process_info.SetEffectiveGroupID (eGid);
 }
 
-bool
-Host::GetOSVersion(uint32_t &major,
-                   uint32_t &minor,
-                   uint32_t &update)
-{
-    struct utsname un;
-    int status;
-
-    if (uname(&un))
-        return false;
-
-    status = sscanf(un.release, "%u.%u.%u", &major, &minor, &update);
-    if (status == 3)
-        return true;
-
-    // Some kernels omit the update version, so try looking for just "X.Y" and
-    // set update to 0.
-    update = 0;
-    status = sscanf(un.release, "%u.%u", &major, &minor);
-    return status == 2;
-}
-
 lldb::DataBufferSP
 Host::GetAuxvData(lldb_private::Process *process)
 {
     return ProcFileReader::ReadIntoDataBuffer (process->GetID(), "auxv");
 }
 
 lldb::DataBufferSP
 Host::GetAuxvData (lldb::pid_t pid)

 {
     char **host_env = environ;
     char *env_entry;
     size_t i;
     for (i=0; (env_entry = host_env[i]) != NULL; ++i)
         env.AppendString(env_entry);
     return i;
 }
-
-const ConstString &
-Host::GetDistributionId ()
-{
-    // Try to run 'lbs_release -i', and use that response
-    // for the distribution id.
-
-    static bool s_evaluated;
-    static ConstString s_distribution_id;
-
-    if (!s_evaluated)
-    {
-        s_evaluated = true;
-
-        Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_HOST));
-        if (log)
-            log->Printf ("attempting to determine Linux distribution...");
-
-        // check if the lsb_release command exists at one of the
-        // following paths
-        const char *const exe_paths[] = {
-            "/bin/lsb_release",
-            "/usr/bin/lsb_release"
-        };
-
-        for (size_t exe_index = 0;
-             exe_index < sizeof (exe_paths) / sizeof (exe_paths[0]);
-             ++exe_index)
-        {
-            const char *const get_distribution_info_exe = exe_paths[exe_index];
-            if (access (get_distribution_info_exe, F_OK))
-            {
-                // this exe doesn't exist, move on to next exe
-                if (log)
-                    log->Printf ("executable doesn't exist: %s",
-                            get_distribution_info_exe);
-                continue;
-            }
-
-            // execute the distribution-retrieval command, read output
-            std::string get_distribution_id_command (get_distribution_info_exe);
-            get_distribution_id_command += " -i";
-
-            FILE *file = popen (get_distribution_id_command.c_str (), "r");
-            if (!file)
-            {
-                if (log)
-                    log->Printf (
-                        "failed to run command: \"%s\", cannot retrieve "
-                        "platform information",
-                        get_distribution_id_command.c_str ());
-                return s_distribution_id;
-            }
-
-            // retrieve the distribution id string.
-            char distribution_id[256] = { '\0' };
-            if (fgets (distribution_id, sizeof (distribution_id) - 1, file)
-                    != NULL)
-            {
-                if (log)
-                    log->Printf ("distribution id command returned \"%s\"",
-                            distribution_id);
-
-                const char *const distributor_id_key = "Distributor ID:\t";
-                if (strstr (distribution_id, distributor_id_key))
-                {
-                    // strip newlines
-                    std::string id_string (distribution_id +
-                            strlen (distributor_id_key));
-                    id_string.erase(
-                        std::remove (
-                            id_string.begin (),
-                            id_string.end (),
-                            '\n'),
-                        id_string.end ());
-
-                    // lower case it and convert whitespace to underscores
-                    std::transform (
-                        id_string.begin(),
-                        id_string.end (),
-                        id_string.begin (),
-                        [] (char ch)
-                        { return tolower ( isspace (ch) ? '_' : ch ); });
-
-                    s_distribution_id.SetCString (id_string.c_str ());
-                    if (log)
-                        log->Printf ("distribution id set to \"%s\"",
-                                s_distribution_id.GetCString ());
-                }
-                else
-                {
-                    if (log)
-                        log->Printf ("failed to find \"%s\" field in \"%s\"",
-                                distributor_id_key, distribution_id);
-                }
-            }
-            else
-            {
-                if (log)
-                    log->Printf (
-                        "failed to retrieve distribution id, \"%s\" returned no"
-                        " lines", get_distribution_id_command.c_str ());
-            }
-
-            // clean up the file
-            pclose(file);
-        }
-    }
-
-    return s_distribution_id;
-}

lldb/trunk/source/Host/linux/HostInfoLinux.cpp

+//===-- HostInfoLinux.cpp ---------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "lldb/Core/Log.h"
+#include "lldb/Host/linux/HostInfoLinux.h"
+
+#include <stdio.h>
+#include <string.h>
+#include <sys/utsname.h>
+
+#include <algorithm>
+
+using namespace lldb_private;
+
+std::string HostInfoLinux::m_distribution_id;
+uint32_t HostInfoLinux::m_os_major = 0;
+uint32_t HostInfoLinux::m_os_minor = 0;
+uint32_t HostInfoLinux::m_os_update = 0;
+
+bool
+HostInfoLinux::GetOSVersion(uint32_t &major, uint32_t &minor, uint32_t &update)
+{
+    static bool is_initialized = false;
+    static bool success = false;
+
+    if (!is_initialized)
+    {
+        is_initialized = true;
+        struct utsname un;
+
+        if (uname(&un))
+            goto finished;
+
+        int status = sscanf(un.release, "%u.%u.%u", &major, &minor, &update);
+        if (status == 3)
+        {
+            success = true;
+            goto finished;
+        }
+
+        // Some kernels omit the update version, so try looking for just "X.Y" and
+        // set update to 0.
+        update = 0;
+        status = sscanf(un.release, "%u.%u", &major, &minor);
+        success = !!(status == 2);
+    }
+
+finished:
+    major = m_os_major;
+    minor = m_os_minor;
+    update = m_os_update;
+    return success;
+}
+
+llvm::StringRef
+HostInfoLinux::GetDistributionId()
+{
+    static bool is_initialized = false;
+    // Try to run 'lbs_release -i', and use that response
+    // for the distribution id.
+
+    if (!is_initialized)
+    {
+        is_initialized = true;
+
+        Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_HOST));
+        if (log)
+            log->Printf("attempting to determine Linux distribution...");
+
+        // check if the lsb_release command exists at one of the
+        // following paths
+        const char *const exe_paths[] = {"/bin/lsb_release", "/usr/bin/lsb_release"};
+
+        for (size_t exe_index = 0; exe_index < sizeof(exe_paths) / sizeof(exe_paths[0]); ++exe_index)
+        {
+            const char *const get_distribution_info_exe = exe_paths[exe_index];
+            if (access(get_distribution_info_exe, F_OK))
+            {
+                // this exe doesn't exist, move on to next exe
+                if (log)
+                    log->Printf("executable doesn't exist: %s", get_distribution_info_exe);
+                continue;
+            }
+
+            // execute the distribution-retrieval command, read output
+            std::string get_distribution_id_command(get_distribution_info_exe);
+            get_distribution_id_command += " -i";
+
+            FILE *file = popen(get_distribution_id_command.c_str(), "r");
+            if (!file)
+            {
+                if (log)
+                    log->Printf("failed to run command: \"%s\", cannot retrieve "
+                                "platform information",
+                                get_distribution_id_command.c_str());
+                break;
+            }
+
+            // retrieve the distribution id string.
+            char distribution_id[256] = {'\0'};
+            if (fgets(distribution_id, sizeof(distribution_id) - 1, file) != NULL)
+            {
+                if (log)
+                    log->Printf("distribution id command returned \"%s\"", distribution_id);
+
+                const char *const distributor_id_key = "Distributor ID:\t";
+                if (strstr(distribution_id, distributor_id_key))
+                {
+                    // strip newlines
+                    std::string id_string(distribution_id + strlen(distributor_id_key));
+                    id_string.erase(std::remove(id_string.begin(), id_string.end(), '\n'), id_string.end());
+
+                    // lower case it and convert whitespace to underscores
+                    std::transform(id_string.begin(), id_string.end(), id_string.begin(), [](char ch)
+                                   {
+                        return tolower(isspace(ch) ? '_' : ch);
+                    });
+
+                    m_distribution_id = id_string;
+                    if (log)
+                        log->Printf("distribution id set to \"%s\"", m_distribution_id.c_str());
+                }
+                else
+                {
+                    if (log)
+                        log->Printf("failed to find \"%s\" field in \"%s\"", distributor_id_key, distribution_id);
+                }
+            }
+            else
+            {
+                if (log)
+                    log->Printf("failed to retrieve distribution id, \"%s\" returned no"
+                                " lines",
+                                get_distribution_id_command.c_str());
+            }
+
+            // clean up the file
+            pclose(file);
+        }
+    }
+
+    return m_distribution_id.c_str();
+}

lldb/trunk/source/Host/macosx/Host.mm

Host::GetEnvironment (StringList &env)
     char *env_entry;
     size_t i;
     for (i=0; (env_entry = host_env[i]) != NULL; ++i)
         env.AppendString(env_entry);
     return i;
         
 }
 
-
-bool
-Host::GetOSBuildString (std::string &s)
-{
-    int mib[2] = { CTL_KERN, KERN_OSVERSION };
-    char cstr[PATH_MAX];
-    size_t cstr_len = sizeof(cstr);
-    if (::sysctl (mib, 2, cstr, &cstr_len, NULL, 0) == 0)
-    {
-        s.assign (cstr, cstr_len);
-        return true;
-    }
-    
-    s.clear();
-    return false;
-}
-
-bool
-Host::GetOSKernelDescription (std::string &s)
-{
-    int mib[2] = { CTL_KERN, KERN_VERSION };
-    char cstr[PATH_MAX];
-    size_t cstr_len = sizeof(cstr);
-    if (::sysctl (mib, 2, cstr, &cstr_len, NULL, 0) == 0)
-    {
-        s.assign (cstr, cstr_len);
-        return true;
-    }
-    s.clear();
-    return false;
-}
-
-bool
-Host::GetOSVersion 
-(
-    uint32_t &major, 
-    uint32_t &minor, 
-    uint32_t &update
-)
-{
-    static uint32_t g_major = 0;
-    static uint32_t g_minor = 0;
-    static uint32_t g_update = 0;
-
-    if (g_major == 0)
-    {
-        @autoreleasepool {
-            NSDictionary *version_info = [NSDictionary dictionaryWithContentsOfFile:
-                                          @"/System/Library/CoreServices/SystemVersion.plist"];
-            NSString *version_value = [version_info objectForKey:@"ProductVersion"];
-            const char *version_str = [version_value UTF8String];
-            if (version_str)
-                Args::StringToVersion(version_str, g_major, g_minor, g_update);
-        }
-    }
-    
-    if (g_major != 0)
-    {
-        major = g_major;
-        minor = g_minor;
-        update = g_update;
-        return true;
-    }
-    return false;
-}
-
 static bool
 GetMacOSXProcessCPUType (ProcessInstanceInfo &process_info)
 {
     if (process_info.ProcessIDIsValid())
     {
         // Make a new mib to stay thread safe
         int mib[CTL_MAXNAME]={0,};
         size_t mib_len = CTL_MAXNAME;

lldb/trunk/source/Host/macosx/HostInfoMacOSX.mm

+//===-- HostInfoMacOSX.mm ---------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "lldb/Host/macosx/HostInfoMacOSX.h"
+#include "lldb/Interpreter/Args.h"
+
+// C++ Includes
+#include <string>
+
+// C inclues
+#include <sys/sysctl.h>
+#include <sys/types.h>
+
+// Objective C/C++ includes
+#include <CoreFoundation/CoreFoundation.h>
+#include <Foundation/Foundation.h>
+#include <objc/objc-auto.h>
+
+using namespace lldb_private;
+
+bool
+HostInfoMacOSX::GetOSBuildString(std::string &s)
+{
+    int mib[2] = {CTL_KERN, KERN_OSVERSION};
+    char cstr[PATH_MAX];
+    size_t cstr_len = sizeof(cstr);
+    if (::sysctl(mib, 2, cstr, &cstr_len, NULL, 0) == 0)
+    {
+        s.assign(cstr, cstr_len);
+        return true;
+    }
+
+    s.clear();
+    return false;
+}
+
+bool
+HostInfoMacOSX::GetOSKernelDescription(std::string &s)
+{
+    int mib[2] = {CTL_KERN, KERN_VERSION};
+    char cstr[PATH_MAX];
+    size_t cstr_len = sizeof(cstr);
+    if (::sysctl(mib, 2, cstr, &cstr_len, NULL, 0) == 0)
+    {
+        s.assign(cstr, cstr_len);
+        return true;
+    }
+    s.clear();
+    return false;
+}
+
+bool
+HostInfoMacOSX::GetOSVersion(uint32_t &major, uint32_t &minor, uint32_t &update)
+{
+    static uint32_t g_major = 0;
+    static uint32_t g_minor = 0;
+    static uint32_t g_update = 0;
+
+    if (g_major == 0)
+    {
+        @autoreleasepool
+        {
+            NSDictionary *version_info = [NSDictionary dictionaryWithContentsOfFile:@"/System/Library/CoreServices/SystemVersion.plist"];
+            NSString *version_value = [version_info objectForKey:@"ProductVersion"];
+            const char *version_str = [version_value UTF8String];
+            if (version_str)
+                Args::StringToVersion(version_str, g_major, g_minor, g_update);
+        }
+    }
+
+    if (g_major != 0)
+    {
+        major = g_major;
+        minor = g_minor;
+        update = g_update;
+        return true;
+    }
+    return false;
+}

lldb/trunk/source/Host/posix/HostInfoPosix.cpp

+//===-- HostInfoPosix.cpp ---------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "lldb/Host/posix/HostInfoPosix.h"
+
+#include <netdb.h>
+#include <limits.h>
+#include <unistd.h>
+
+using namespace lldb_private;
+
+size_t
+HostInfoPosix::GetPageSize()
+{
+    return ::getpagesize();
+}
+
+bool
+HostInfoPosix::GetHostname(std::string &s)
+{
+    char hostname[PATH_MAX];
+    hostname[sizeof(hostname) - 1] = '\0';
+    if (::gethostname(hostname, sizeof(hostname) - 1) == 0)
+    {
+        struct hostent *h = ::gethostbyname(hostname);
+        if (h)
+            s.assign(h->h_name);
+        else
+            s.assign(hostname);
+        return true;
+    }
+    return false;
+}

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

void GetProcessExecutableAndTriple(const AutoHandle &handle, ProcessInstanceInfo &process)
             GetTripleForProcess(executableFile, triple);
         }
         process.SetArchitecture(ArchSpec(triple));
 
         // TODO(zturner): Add the ability to get the process user name.
     }
 }
 
-bool
-Host::GetOSVersion(uint32_t &major,
-                   uint32_t &minor,
-                   uint32_t &update)
-{
-    OSVERSIONINFOEX info;
-
-    ZeroMemory(&info, sizeof(OSVERSIONINFOEX));
-    info.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEX);
-#pragma warning(push)
-#pragma warning(disable: 4996)
-    // Starting with Microsoft SDK for Windows 8.1, this function is deprecated in favor of the
-    // new Windows Version Helper APIs.  Since we don't specify a minimum SDK version, it's easier
-    // to simply disable the warning rather than try to support both APIs.
-    if (GetVersionEx((LPOSVERSIONINFO) &info) == 0) {
-        return false;
-    }
-#pragma warning(pop)
-
-    major = (uint32_t) info.dwMajorVersion;
-    minor = (uint32_t) info.dwMinorVersion;
-    update = (uint32_t) info.wServicePackMajor;
-
-    return true;
-}
-
 Error
 Host::LaunchProcess (ProcessLaunchInfo &launch_info)
 {
     Error error;
     assert(!"Not implemented yet!!!");
     return error;
 }
 

 }
 
 void
 Host::Kill(lldb::pid_t pid, int signo)
 {
     TerminateProcess((HANDLE) pid, 1);
 }
 
-uint32_t
-Host::GetNumberCPUS()
-{
-    static uint32_t g_num_cores = UINT32_MAX;
-    if (g_num_cores == UINT32_MAX)
-    {
-        SYSTEM_INFO system_info;
-        ::GetSystemInfo(&system_info);
-        g_num_cores = system_info.dwNumberOfProcessors;
-    }
-    return g_num_cores;
-}
-
-size_t
-Host::GetPageSize()
-{
-    static long g_pagesize = 0;
-    if (!g_pagesize)
-    {
-        SYSTEM_INFO systemInfo;
-        GetNativeSystemInfo(&systemInfo);
-        g_pagesize = systemInfo.dwPageSize;
-    }
-    return g_pagesize;
-}
 
 const char *
 Host::GetSignalAsCString(int signo)
 {
     return NULL;
 }
 
 FileSpec
(
     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/Host/windows/HostInfoWindows.cpp

+//===-- HostInfoWindows.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 "lldb/Host/windows/HostInfoWindows.h"
+#include "llvm/ADT/SmallString.h"
+#include "llvm/Support/raw_ostream.h"
+
+using namespace lldb_private;
+
+size_t
+HostInfoWindows::GetPageSize()
+{
+    SYSTEM_INFO systemInfo;
+    GetNativeSystemInfo(&systemInfo);
+    return systemInfo.dwPageSize;
+}
+
+bool
+HostInfoWindows::GetOSVersion(uint32_t &major, uint32_t &minor, uint32_t &update)
+{
+    OSVERSIONINFOEX info;
+
+    ZeroMemory(&info, sizeof(OSVERSIONINFOEX));
+    info.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEX);
+#pragma warning(push)
+#pragma warning(disable : 4996)
+    // Starting with Microsoft SDK for Windows 8.1, this function is deprecated in favor of the
+    // new Windows Version Helper APIs.  Since we don't specify a minimum SDK version, it's easier
+    // to simply disable the warning rather than try to support both APIs.
+    if (GetVersionEx((LPOSVERSIONINFO)&info) == 0)
+    {
+        return false;
+    }
+#pragma warning(pop)
+
+    major = info.dwMajorVersion;
+    minor = info.dwMinorVersion;
+    update = info.wServicePackMajor;
+
+    return true;
+}
+
+bool
+HostInfoWindows::GetOSBuildString(std::string &s)
+{
+    s.clear();
+    uint32_t major, minor, update;
+    if (!GetOSVersion(major, minor, update))
+        return false;
+
+    llvm::raw_string_ostream stream(s);
+    stream << "Windows NT " << major << "." << minor << "." << update;
+    return true;
+}
+
+bool
+HostInfoWindows::GetOSKernelDescription(std::string &s)
+{
+    return GetOSBuildString(s);
+}
+
+bool
+HostInfoWindows::GetHostname(std::string &s)
+{
+    char buffer[MAX_COMPUTERNAME_LENGTH + 1];
+    DWORD dwSize = MAX_COMPUTERNAME_LENGTH + 1;
+    if (!::GetComputerName(buffer, &dwSize))
+        return false;
+
+    s.assign(buffer, buffer + dwSize);
+    return true;
+}

lldb/trunk/source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp

 #include "lldb/Core/Section.h"
 #include "lldb/Core/Stream.h"
 #include "lldb/Core/Timer.h"
 #include "lldb/Symbol/DWARFCallFrameInfo.h"
 #include "lldb/Symbol/SymbolContext.h"
 #include "lldb/Target/SectionLoadList.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Host/Host.h"
+#include "lldb/Host/HostInfo.h"
 
 #include "llvm/ADT/PointerUnion.h"
+#include "llvm/ADT/StringRef.h"
 #include "llvm/Support/MathExtras.h"
 
 #define CASE_AND_STREAM(s, def, width)                  \
     case def: s->Printf("%-*s", width, #def); break;
 
 using namespace lldb;
 using namespace lldb_private;
 using namespace elf;
if (arch_spec.GetTriple ().getOS () == llvm::Triple::OSType::UnknownOS)
         arch_spec.SetArchitecture (eArchTypeELF, header.e_machine, LLDB_INVALID_CPUTYPE);
         switch (arch_spec.GetAddressByteSize())
         {
         case 4:
             {
                 const ArchSpec host_arch32 = Host::GetArchitecture (Host::eSystemDefaultArchitecture32);
                 if (host_arch32.GetCore() == arch_spec.GetCore())
                 {
-                    arch_spec.GetTriple().setOSName (Host::GetOSString().GetCString());
-                    arch_spec.GetTriple().setVendorName(Host::GetVendorString().GetCString());
+                    arch_spec.GetTriple().setOSName(HostInfo::GetOSString().data());
+                    arch_spec.GetTriple().setVendorName(HostInfo::GetVendorString().data());
                 }
             }
             break;
         case 8:
             {
                 const ArchSpec host_arch64 = Host::GetArchitecture (Host::eSystemDefaultArchitecture64);
                 if (host_arch64.GetCore() == arch_spec.GetCore())
                 {
-                    arch_spec.GetTriple().setOSName (Host::GetOSString().GetCString());
-                    arch_spec.GetTriple().setVendorName(Host::GetVendorString().GetCString());
+                    arch_spec.GetTriple().setOSName(HostInfo::GetOSString().data());
+                    arch_spec.GetTriple().setVendorName(HostInfo::GetVendorString().data());
                 }
             }
             break;
         }
     }
 
     // If there are no section headers we are done.
     if (header.e_shnum == 0)

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

 #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/Host/HostInfo.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Target.h"
 
 using namespace lldb;
 using namespace lldb_private;
     
 static uint32_t g_initialize_count = 0;

 lldb_private::Error
 PlatformMacOSX::GetFileWithUUID (const lldb_private::FileSpec &platform_file,
                                  const lldb_private::UUID *uuid_ptr,
                                  lldb_private::FileSpec &local_file)
 {
     if (IsRemote() && m_remote_platform_sp)
     {
         std::string local_os_build;
-        Host::GetOSBuildString(local_os_build);
+#if !defined(__linux__)
+        HostInfo::GetOSBuildString(local_os_build);
+#endif
         std::string remote_os_build;
         m_remote_platform_sp->GetOSBuildString(remote_os_build);
         if (local_os_build.compare(remote_os_build) == 0)
         {
             // same OS version: the local file is good enough
             local_file = platform_file;
             return Error();
         }

lldb/trunk/source/Plugins/Platform/Windows/PlatformWindows.cpp

 
 // C++ Includes
 // Other libraries and framework includes
 // Project includes
 #include "lldb/Core/Error.h"
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Host/Host.h"
+#include "lldb/Host/HostInfo.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Breakpoint/BreakpointLocation.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 static uint32_t g_initialize_count = 0;

 PlatformWindows::GetStatus (Stream &strm)
 {
     Platform::GetStatus(strm);
 
 #ifdef _WIN32
     uint32_t major;
     uint32_t minor;
     uint32_t update;
-    if (!Host::GetOSVersion(major, minor, update))
+    if (!HostInfo::GetOSVersion(major, minor, update))
     {
         strm << "Windows";
         return;
     }
 
     strm << "Host: Windows " << major
          << '.' << minor
          << " Build: " << update << '\n';
 #endif
 }

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

 #include "lldb/Interpreter/Args.h"
 #include "lldb/Core/ConnectionFileDescriptor.h"
 #include "lldb/Core/Log.h"
 #include "lldb/Core/State.h"
 #include "lldb/Core/StreamGDBRemote.h"
 #include "lldb/Core/StreamString.h"
 #include "lldb/Host/Endian.h"
 #include "lldb/Host/Host.h"
+#include "lldb/Host/HostInfo.h"
 #include "lldb/Host/TimeValue.h"
 #include "lldb/Target/Target.h"
 
 // Project includes
 #include "Utility/StringExtractorGDBRemote.h"
 #include "ProcessGDBRemote.h"
 #include "ProcessGDBRemoteLog.h"
 #include "lldb/Host/Config.h"
GDBRemoteCommunicationClient::LaunchGDBserverAndGetPort (lldb::pid_t &pid, const char *remote_accept_hostname)
     StringExtractorGDBRemote response;
     StreamString stream;
     stream.PutCString("qLaunchGDBServer;");
     std::string hostname;
     if (remote_accept_hostname  && remote_accept_hostname[0])
         hostname = remote_accept_hostname;
     else
     {
-        if (Host::GetHostname (hostname))
+        if (HostInfo::GetHostname(hostname))
         {
             // Make the GDB server we launch only accept connections from this host
             stream.Printf("host:%s;", hostname.c_str());
         }
         else
         {
             // Make the GDB server we launch accept connections from any host since we can't figure out the hostname
             stream.Printf("host:*;");

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

 #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/HostInfo.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"
 
#endif
     case eByteOrderLittle:  response.PutCString ("endian:little;"); break;
     case eByteOrderPDP:     response.PutCString ("endian:pdp;"); break;
     default:                response.PutCString ("endian:unknown;"); break;
     }
 
     uint32_t major = UINT32_MAX;
     uint32_t minor = UINT32_MAX;
     uint32_t update = UINT32_MAX;
-    if (Host::GetOSVersion (major, minor, update))
+    if (HostInfo::GetOSVersion(major, minor, update))
     {
         if (major != UINT32_MAX)
         {
             response.Printf("os_version:%u", major);
             if (minor != UINT32_MAX)
             {
                 response.Printf(".%u", minor);
                 if (update != UINT32_MAX)
                     response.Printf(".%u", update);
             }
             response.PutChar(';');
         }
     }
 
     std::string s;
-    if (Host::GetOSBuildString (s))
+#if !defined(__linux__)
+    if (HostInfo::GetOSBuildString(s))
     {
         response.PutCString ("os_build:");
         response.PutCStringAsRawHex8(s.c_str());
         response.PutChar(';');
     }
-    if (Host::GetOSKernelDescription (s))
+    if (HostInfo::GetOSKernelDescription(s))
     {
         response.PutCString ("os_kernel:");
         response.PutCStringAsRawHex8(s.c_str());
         response.PutChar(';');
     }
+#endif
+
 #if defined(__APPLE__)
 
 #if defined(__arm__) || defined(__arm64__) || defined(__aarch64__)
     // For iOS devices, we are connected through a USB Mux so we never pretend
     // to actually have a hostname as far as the remote lldb that is connecting
     // to this lldb-platform is concerned
     response.PutCString ("hostname:");
     response.PutCStringAsRawHex8("127.0.0.1");
     response.PutChar(';');
 #else   // #if defined(__arm__) || defined(__arm64__) || defined(__aarch64__)
-    if (Host::GetHostname (s))
+    if (HostInfo::GetHostname(s))
     {
         response.PutCString ("hostname:");
         response.PutCStringAsRawHex8(s.c_str());
         response.PutChar(';');
     }
 #endif  // #if defined(__arm__) || defined(__arm64__) || defined(__aarch64__)
 
 #else   // #if defined(__APPLE__)
-    if (Host::GetHostname (s))
+    if (HostInfo::GetHostname(s))
     {
         response.PutCString ("hostname:");
         response.PutCStringAsRawHex8(s.c_str());
         response.PutChar(';');
     }
 #endif  // #if defined(__APPLE__)
 
     return SendPacketNoLock (response.GetData(), response.GetSize());

lldb/trunk/source/Target/Platform.cpp

 #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/Host/HostInfo.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/Utils.h"
 
 using namespace lldb;
 using namespace lldb_private;
     
 // Use a singleton function for g_local_platform_sp to avoid init
Platform::GetOSVersion (uint32_t &major,
                         uint32_t &update)
 {
     bool success = m_major_os_version != UINT32_MAX;
     if (IsHost())
     {
         if (!success)
         {
             // We have a local host platform
-            success = Host::GetOSVersion (m_major_os_version, 
-                                          m_minor_os_version, 
-                                          m_update_os_version);
+            success = HostInfo::GetOSVersion(m_major_os_version, m_minor_os_version, m_update_os_version);
             m_os_version_set_while_connected = success;
         }
     }
     else 
     {
         // We have a remote platform. We can only fetch the remote
         // OS version if we are connected, and we don't want to do it
         // more than once.
if (success)
         update = m_update_os_version;
     }
     return success;
 }
 
 bool
 Platform::GetOSBuildString (std::string &s)
 {
+    s.clear();
+
     if (IsHost())
-        return Host::GetOSBuildString (s);
+#if !defined(__linux__)
+        return HostInfo::GetOSBuildString(s);
+#else
+        return false;
+#endif
     else
         return GetRemoteOSBuildString (s);
 }
 
 bool
 Platform::GetOSKernelDescription (std::string &s)
 {
     if (IsHost())
-        return Host::GetOSKernelDescription (s);
+#if !defined(__linux__)
+        return HostInfo::GetOSKernelDescription(s);
+#else
+        return false;
+#endif
     else
         return GetRemoteOSKernelDescription (s);
 }
 
 ConstString
 Platform::GetWorkingDirectory ()
 {
     if (IsHost())

 
 bool
 Platform::SetOSVersion (uint32_t major, 
                         uint32_t minor, 
                         uint32_t update)
 {
     if (IsHost())
     {
-        // We don't need anyone setting the OS version for the host platform, 
-        // we should be able to figure it out by calling Host::GetOSVersion(...).
+        // We don't need anyone setting the OS version for the host platform,
+        // we should be able to figure it out by calling HostInfo::GetOSVersion(...).
         return false; 
     }
     else
     {
         // We have a remote platform, allow setting the target OS version if
         // we aren't connected, since if we are connected, we should be able to
         // request the remote OS version from the connected platform.
         if (IsConnected())

lldb/trunk/source/Target/ThreadPlanCallUserExpression.cpp

 // Project includes
 #include "lldb/lldb-private-log.h"
 #include "lldb/Breakpoint/Breakpoint.h"
 #include "lldb/Breakpoint/BreakpointLocation.h"
 #include "lldb/Core/Address.h"
 #include "lldb/Core/Log.h"
 #include "lldb/Core/Stream.h"
 #include "lldb/Expression/ClangUserExpression.h"
+#include "lldb/Host/HostInfo.h"
 #include "lldb/Target/LanguageRuntime.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/RegisterContext.h"
 #include "lldb/Target/StopInfo.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Target/ThreadPlanRunToAddress.h"
 
if (IsPlanComplete())
                         static_cast<void*>(this));
 
         if (m_manage_materialization && PlanSucceeded() && m_user_expression_sp)
         {
             lldb::addr_t function_stack_top;
             lldb::addr_t function_stack_bottom;
             lldb::addr_t function_stack_pointer = GetFunctionStackPointer();
 
-            function_stack_bottom = function_stack_pointer - Host::GetPageSize();
+            function_stack_bottom = function_stack_pointer - HostInfo::GetPageSize();
             function_stack_top = function_stack_pointer;
             
             StreamString  error_stream;
             
             ExecutionContext exe_ctx(GetThread());
 
             m_user_expression_sp->FinalizeJITExecution(error_stream, exe_ctx, m_result_var_sp, function_stack_bottom, function_stack_top);
         }