Move several plugin to its own namespace

[tberghammer]

Summary

Move several plugin to its own namespace

Affected paths:

• Plugins/Platform/Android/*
• Plugins/Platform/Linux/*
• Plugins/Platform/gdb-server/*
• Plugins/Process/Linux/*
• Plugins/Process/gdb-remote/*

[clayborg]

The main question is do we want to move each plug-in into its own namespace within lldb_private namespace?

All code from the GDB remote process plug-in could be in:

namespace lldb_private {
  namespace plugin {
    namespace process {
      namespace gdb_remote {
        // Code here
      }
    }
  }
}

Or just

namespace lldb_private {
  namespace process_gdb_remote {
        // Code here
  }
}

[ovyalov]

Looks good.

[tberghammer]

In D8654#147918, @clayborg wrote:

The main question is do we want to move each plug-in into its own namespace within lldb_private namespace?

All code from the GDB remote process plug-in could be in:

namespace lldb_private {
  namespace plugin {
    namespace process {
      namespace gdb_remote {
        // Code here
      }
    }
  }
}

Or just

namespace lldb_private {
  namespace process_gdb_remote {
        // Code here
  }
}

I am not sure if moving each plugin into its own namespace will make too much sense because most of the plugin is very small (1 or 2 cpp file) so the additional namespaces just adding some noise to the code without any real benefit. What I would consider is to leave the public part of the plugins directly in the lldb_private namespace and if a plugin require additional classes which are private to the plugin then put them into a nested namespace inside lldb_private.

From the two namespace structure you suggested I would prefer the second one as the first one create a very deep nesting so if we have to refer to a plugin from a header file outside of that plugin (e.g.: from a platform plugin to a process plugin) then it will create extremely long fully qualified names.

If we want to go with adding nested namespace then I would also consider the following structures because the plugins for the same OS usually tied together in some level:

namespace lldb_private {
  namespace linux {
    namespace process {
      // Code here
    }
  }
}

Or just an OS level separation (then we don't have to postfix almost all class with the OS name as ProcessLinux, PlatformWindows, ...)

namespace lldb_private {
  namespace linux {
    // Code here
  }
}

[clayborg]

I would prefer each plug-in use its own namespace, even if the the shallow version is fine. I would just like people to see the error of their ways if they are in ProcessLinux.cpp and you see:

lldb_private::gdb_remote::something();

or if "using namespace lldb_private;":

gdb_remote::something();

This should be a good indication that the abstraction was broken since you are in ProcessLinux.cpp and you are accessing code from a plug-in. Where as if you saw:

lldb_private::something();

or if "using namespace lldb_private;":

something();

You might think the above code would be OK since it is in the lldb_private namespace, whereas seeing "gdb_remote" namespace quickly tells you something is up.

[tberghammer]

Move plugins to their own namespace

This change exposed several flows in the current design (mostly classes leaving in the wrong place). I will try to fix them in the future when I have some time for it.

[clayborg]

lgtm

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

 
 // Get the process info with additional information from /proc/$PID/stat (like process state, and tracer pid).
 static bool GetProcessAndStatInfo (lldb::pid_t pid, ProcessInstanceInfo &process_info, ProcessStatInfo &stat_info, lldb::pid_t &tracerpid);
 
 static bool
 ReadProcPseudoFileStat (lldb::pid_t pid, ProcessStatInfo& stat_info)
 {
     // Read the /proc/$PID/stat file.
-    lldb::DataBufferSP buf_sp = ProcFileReader::ReadIntoDataBuffer (pid, "stat");
+    lldb::DataBufferSP buf_sp = process_linux::ProcFileReader::ReadIntoDataBuffer (pid, "stat");
 
     // The filename of the executable is stored in parenthesis right after the pid. We look for the closing
     // parenthesis for the filename and work from there in case the name has something funky like ')' in it.
     const char *filename_end = strrchr ((const char *)buf_sp->GetBytes(), ')');
     if (filename_end)
     {
         char state = '\0';
         int ppid = LLDB_INVALID_PROCESS_ID;

 {
     tracerpid = 0;
     uint32_t rUid = UINT32_MAX;     // Real User ID
     uint32_t eUid = UINT32_MAX;     // Effective User ID
     uint32_t rGid = UINT32_MAX;     // Real Group ID
     uint32_t eGid = UINT32_MAX;     // Effective Group ID
 
     // Read the /proc/$PID/status file and parse the Uid:, Gid:, and TracerPid: fields.
-    lldb::DataBufferSP buf_sp = ProcFileReader::ReadIntoDataBuffer (pid, "status");
+    lldb::DataBufferSP buf_sp = process_linux::ProcFileReader::ReadIntoDataBuffer (pid, "status");
 
     static const char uid_token[] = "Uid:";
     char *buf_uid = strstr ((char *)buf_sp->GetBytes(), uid_token);
     if (buf_uid)
     {
         // Real, effective, saved set, and file system UIDs. Read the first two.
         buf_uid += sizeof(uid_token);
         rUid = strtol (buf_uid, &buf_uid, 10);
GetLinuxProcessUserAndGroup (lldb::pid_t pid, ProcessInstanceInfo &process_info, lldb::pid_t &tracerpid)
     process_info.SetEffectiveUserID (eUid);
     process_info.SetGroupID (rGid);
     process_info.SetEffectiveGroupID (eGid);
 }
 
 lldb::DataBufferSP
 Host::GetAuxvData(lldb_private::Process *process)
 {
-    return ProcFileReader::ReadIntoDataBuffer (process->GetID(), "auxv");
+    return process_linux::ProcFileReader::ReadIntoDataBuffer (process->GetID(), "auxv");
 }
 
 lldb::DataBufferSP
 Host::GetAuxvData (lldb::pid_t pid)
 {
-    return ProcFileReader::ReadIntoDataBuffer (pid, "auxv");
+    return process_linux::ProcFileReader::ReadIntoDataBuffer (pid, "auxv");
 }
 
 static bool
 IsDirNumeric(const char *dname)
 {
     for (; *dname; dname++)
     {
         if (!isdigit (*dname))
GetProcessAndStatInfo (lldb::pid_t pid, ProcessInstanceInfo &process_info, ProcessStatInfo &stat_info, lldb::pid_t &tracerpid)
 
     process_info.SetProcessID(pid);
     process_info.GetExecutableFile().SetFile(exe_path, false);
     process_info.GetArchitecture().MergeFrom(HostInfo::GetArchitecture());
 
     lldb::DataBufferSP buf_sp;
 
     // Get the process environment.
-    buf_sp = ProcFileReader::ReadIntoDataBuffer(pid, "environ");
+    buf_sp = process_linux::ProcFileReader::ReadIntoDataBuffer(pid, "environ");
     Args &info_env = process_info.GetEnvironmentEntries();
     char *next_var = (char *)buf_sp->GetBytes();
     char *end_buf = next_var + buf_sp->GetByteSize();
     while (next_var < end_buf && 0 != *next_var)
     {
         info_env.AppendArgument(next_var);
         next_var += strlen(next_var) + 1;
     }
 
     // Get the command line used to start the process.
-    buf_sp = ProcFileReader::ReadIntoDataBuffer(pid, "cmdline");
+    buf_sp = process_linux::ProcFileReader::ReadIntoDataBuffer(pid, "cmdline");
 
     // Grab Arg0 first, if there is one.
     char *cmd = (char *)buf_sp->GetBytes();
     if (cmd)
     {
         process_info.SetArg0(cmd);
 
         // Now process any remaining arguments.

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

 {
     ::pthread_setname_np(thread, name.data());
 }
 
 void
 HostThreadLinux::GetName(lldb::thread_t thread, llvm::SmallVectorImpl<char> &name)
 {
     // Read /proc/$TID/comm file.
-    lldb::DataBufferSP buf_sp = ProcFileReader::ReadIntoDataBuffer(thread, "comm");
+    lldb::DataBufferSP buf_sp = process_linux::ProcFileReader::ReadIntoDataBuffer(thread, "comm");
     const char *comm_str = (const char *)buf_sp->GetBytes();
     const char *cr_str = ::strchr(comm_str, '\n');
     size_t length = cr_str ? (cr_str - comm_str) : strlen(comm_str);
 
     name.clear();
     name.append(comm_str, comm_str + length);
 }

lldb/trunk/source/Initialization/InitializeLLDB.cpp

#endif
 
     Log::Initialize();
     HostInfo::Initialize();
     Timer::Initialize();
     Timer scoped_timer(__PRETTY_FUNCTION__, __PRETTY_FUNCTION__);
 
     llvm::install_fatal_error_handler(fatal_error_handler, 0);
 
-    ProcessGDBRemoteLog::Initialize();
+    process_gdb_remote::ProcessGDBRemoteLog::Initialize();
 
     // Initialize plug-ins
     ObjectContainerBSDArchive::Initialize();
     ObjectFileELF::Initialize();
     ObjectFilePECOFF::Initialize();
     DynamicLoaderPOSIXDYLD::Initialize();
     PlatformFreeBSD::Initialize();
-    PlatformLinux::Initialize();
+    platform_linux::PlatformLinux::Initialize();
     PlatformWindows::Initialize();
     PlatformKalimba::Initialize();
-    PlatformAndroid::Initialize();
+    platform_android::PlatformAndroid::Initialize();
 
     //----------------------------------------------------------------------
     // Apple/Darwin hosted plugins
     //----------------------------------------------------------------------
     DynamicLoaderMacOSXDYLD::Initialize();
     ObjectContainerUniversalMachO::Initialize();
 
     PlatformRemoteiOS::Initialize();
InitializePrivate()
     AppleObjCRuntimeV2::Initialize();
     AppleObjCRuntimeV1::Initialize();
     SystemRuntimeMacOSX::Initialize();
 
 #if defined(__linux__)
     //----------------------------------------------------------------------
     // Linux hosted plugins
     //----------------------------------------------------------------------
-    ProcessLinux::Initialize();
+    process_linux::ProcessLinux::Initialize();
 #endif
 #if defined(_MSC_VER)
     DynamicLoaderWindows::Initialize();
     ProcessWindows::Initialize();
 #endif
 #if defined(__FreeBSD__)
     ProcessFreeBSD::Initialize();
 #endif
 #if defined(__APPLE__)
     SymbolVendorMacOSX::Initialize();
     ProcessKDP::Initialize();
     ProcessMachCore::Initialize();
 #endif
     //----------------------------------------------------------------------
     // Platform agnostic plugins
     //----------------------------------------------------------------------
-    PlatformRemoteGDBServer::Initialize();
+    platform_gdb_server::PlatformRemoteGDBServer::Initialize();
 
-    ProcessGDBRemote::Initialize();
+    process_gdb_remote::ProcessGDBRemote::Initialize();
     DynamicLoaderStatic::Initialize();
 
     // Scan for any system or user LLDB plug-ins
     PluginManager::Initialize();
 
     // The process settings need to know about installed plug-ins, so the Settings must be initialized
     // AFTER PluginManager::Initialize is called.
 
     Debugger::SettingsInitialize();
 }
 
 static void
 TerminateForLLGSPrivate()
 {
     if (!g_inited_for_llgs)
         return;
     g_inited_for_llgs = false;
 
     Timer scoped_timer(__PRETTY_FUNCTION__, __PRETTY_FUNCTION__);
     ObjectContainerBSDArchive::Terminate();
     ObjectFileELF::Terminate();
     ObjectFilePECOFF::Terminate();
     DynamicLoaderPOSIXDYLD::Terminate();
     PlatformFreeBSD::Terminate();
-    PlatformLinux::Terminate();
+    platform_linux::PlatformLinux::Terminate();
     PlatformWindows::Terminate();
     PlatformKalimba::Terminate();
-    PlatformAndroid::Terminate();
+    platform_android::PlatformAndroid::Terminate();
     DynamicLoaderMacOSXDYLD::Terminate();
     ObjectContainerUniversalMachO::Terminate();
     PlatformMacOSX::Terminate();
     PlatformRemoteiOS::Terminate();
     PlatformiOSSimulator::Terminate();
 
 #if defined(__APPLE__)
     DynamicLoaderDarwinKernel::Terminate();
#if defined(__APPLE__)
     ProcessKDP::Terminate();
     SymbolVendorMacOSX::Terminate();
 #endif
 #if defined(_MSC_VER)
     DynamicLoaderWindows::Terminate();
 #endif
 
 #if defined(__linux__)
-    ProcessLinux::Terminate();
+    process_linux::ProcessLinux::Terminate();
 #endif
 
 #if defined(__FreeBSD__)
     ProcessFreeBSD::Terminate();
 #endif
     Debugger::SettingsTerminate();
 
-    PlatformRemoteGDBServer::Terminate();
-    ProcessGDBRemote::Terminate();
+    platform_gdb_server::PlatformRemoteGDBServer::Terminate();
+    process_gdb_remote::ProcessGDBRemote::Terminate();
     DynamicLoaderStatic::Terminate();
 
     TerminateForLLGSPrivate();
 }
 
 void
 lldb_private::InitializeForLLGS(LoadPluginCallbackType load_plugin_callback)
 {

lldb/trunk/source/Plugins/Platform/Android/AdbClient.h

 
 // Other libraries and framework includes
 // Project includes
 
 #include "lldb/Core/Error.h"
 #include "lldb/Host/ConnectionFileDescriptor.h"
 
 namespace lldb_private {
+namespace platform_android {
 
 class AdbClient
 {
 public:
     using DeviceIDList = std::list<std::string>;
 
     static Error
     CreateByDeviceID (const char* device_id, AdbClient &adb);
private:
 
     Error
     ReadResponseStatus ();
 
     std::string m_device_id;
     ConnectionFileDescriptor m_conn;
 };
 
+} // namespace platform_android
 } // namespace lldb_private
 
 #endif  // liblldb_AdbClient_h_

lldb/trunk/source/Plugins/Platform/Android/AdbClient.cpp

 // Project includes
 #include "AdbClient.h"
 
 #include <algorithm>
 #include <sstream>
 
 using namespace lldb;
 using namespace lldb_private;
+using namespace lldb_private::platform_android;
 
 namespace {
 
 const uint32_t kConnTimeout = 10000; // 10 ms
 const char * kOKAY = "OKAY";
 const char * kFAIL = "FAIL";
 
 }  // namespace

lldb/trunk/source/Plugins/Platform/Android/PlatformAndroid.h

 
 #include <string>
 
 // Other libraries and framework includes
 // Project includes
 #include "Plugins/Platform/Linux/PlatformLinux.h"
 
 namespace lldb_private {
+namespace platform_android {
 
-    class PlatformAndroid : public PlatformLinux
+    class PlatformAndroid : public platform_linux::PlatformLinux
     {
     public:
         static void
         Initialize ();
 
         static void
         Terminate ();
 
         PlatformAndroid (bool is_host);
 
         virtual
         ~PlatformAndroid();
 
         //------------------------------------------------------------
         // lldb_private::PluginInterface functions
         //------------------------------------------------------------
         static lldb::PlatformSP
-        CreateInstance (bool force, const lldb_private::ArchSpec *arch);
+        CreateInstance (bool force, const ArchSpec *arch);
 
-        static lldb_private::ConstString
+        static ConstString
         GetPluginNameStatic (bool is_host);
 
         static const char *
         GetPluginDescriptionStatic (bool is_host);
 
-        lldb_private::ConstString
+        ConstString
         GetPluginName() override;
         
         uint32_t
         GetPluginVersion() override
         {
             return 1;
         }
 
         //------------------------------------------------------------
         // lldb_private::Platform functions
         //------------------------------------------------------------
 
-        lldb_private::Error
-        ConnectRemote (lldb_private::Args& args) override;
+        Error
+        ConnectRemote (Args& args) override;
 
     protected:
         const char *
         GetCacheHostname () override;
 
     private:
         std::string m_device_id;
         DISALLOW_COPY_AND_ASSIGN (PlatformAndroid);
     };
+
+} // namespace platofor_android
 } // namespace lldb_private
 
 #endif  // liblldb_PlatformAndroid_h_

lldb/trunk/source/Plugins/Platform/Android/PlatformAndroid.cpp

 
 // Project includes
 #include "AdbClient.h"
 #include "PlatformAndroid.h"
 #include "PlatformAndroidRemoteGDBServer.h"
 
 using namespace lldb;
 using namespace lldb_private;
+using namespace lldb_private::platform_android;
 
 static uint32_t g_initialize_count = 0;
 
 void
 PlatformAndroid::Initialize ()
 {
     PlatformLinux::Initialize ();
 
PlatformAndroid::Terminate ()
     }
 
     PlatformLinux::Terminate ();
 }
 
 PlatformSP
 PlatformAndroid::CreateInstance (bool force, const ArchSpec *arch)
 {
-    Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PLATFORM));
+    Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_PLATFORM));
     if (log)
     {
         const char *arch_name;
         if (arch && arch->GetArchitectureName ())
             arch_name = arch->GetArchitectureName ();
         else
             arch_name = "<null>";
 
PlatformAndroid::PlatformAndroid (bool is_host) :
     PlatformLinux(is_host)
 {
 }
 
 PlatformAndroid::~PlatformAndroid()
 {
 }
 
-lldb_private::ConstString
+ConstString
 PlatformAndroid::GetPluginNameStatic (bool is_host)
 {
     if (is_host)
     {
         static ConstString g_host_name(Platform::GetHostPlatformName ());
         return g_host_name;
     }
     else
     {
         static ConstString g_remote_name("remote-android");
         return g_remote_name;
     }
 }
 
 const char *
 PlatformAndroid::GetPluginDescriptionStatic (bool is_host)
 {
     if (is_host)
         return "Local Android user platform plug-in.";
     else
         return "Remote Android user platform plug-in.";
 }
 
-lldb_private::ConstString
+ConstString
 PlatformAndroid::GetPluginName()
 {
     return GetPluginNameStatic(IsHost());
 }
 
 Error
 PlatformAndroid::ConnectRemote (Args& args)
 {

lldb/trunk/source/Plugins/Platform/Android/PlatformAndroidRemoteGDBServer.h

 // C++ Includes
 #include <map>
 #include <utility>
 
 // Other libraries and framework includes
 // Project includes
 #include "Plugins/Platform/gdb-server/PlatformRemoteGDBServer.h"
 
-class PlatformAndroidRemoteGDBServer : public PlatformRemoteGDBServer
+namespace lldb_private {
+namespace platform_android {
+
+class PlatformAndroidRemoteGDBServer : public platform_gdb_server::PlatformRemoteGDBServer
 {
 public:
     PlatformAndroidRemoteGDBServer ();
 
     virtual
     ~PlatformAndroidRemoteGDBServer ();
 
-    lldb_private::Error
-    ConnectRemote (lldb_private::Args& args) override;
+    Error
+    ConnectRemote (Args& args) override;
 
-    lldb_private::Error
+    Error
     DisconnectRemote () override;
 
 protected:
     std::map<lldb::pid_t, std::pair<uint16_t, std::string>> m_port_forwards;
 
     uint16_t
     LaunchGDBserverAndGetPort (lldb::pid_t &pid) override;
 
     bool
     KillSpawnedProcess (lldb::pid_t pid) override;
 
 private:
     DISALLOW_COPY_AND_ASSIGN (PlatformAndroidRemoteGDBServer);
 
 };
 
+} // namespace platform_android
+} // namespace lldb_private
+
 #endif  // liblldb_PlatformAndroidRemoteGDBServer_h_

lldb/trunk/source/Plugins/Platform/Android/PlatformAndroidRemoteGDBServer.cpp

 
 // Project includes
 #include "AdbClient.h"
 #include "PlatformAndroidRemoteGDBServer.h"
 #include "Utility/UriParser.h"
 
 using namespace lldb;
 using namespace lldb_private;
+using namespace platform_android;
 
 static const lldb::pid_t g_remote_platform_pid = 0; // Alias for the process id of lldb-platform
 
 static Error
 ForwardPortWithAdb (uint16_t port, std::string& device_id)
 {
-    Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PLATFORM));
+    Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_PLATFORM));
 
     // Fetch the device list from ADB and if only 1 device found then use that device
     // TODO: Handle the case when more device is available
     AdbClient adb;
     auto error = AdbClient::CreateByDeviceID (nullptr, adb);
     if (error.Fail ())
         return error;
 

lldb/trunk/source/Plugins/Platform/Linux/PlatformLinux.h

 
 // C Includes
 // C++ Includes
 // Other libraries and framework includes
 // Project includes
 #include "Plugins/Platform/POSIX/PlatformPOSIX.h"
 
 namespace lldb_private {
+namespace platform_linux {
 
     class PlatformLinux : public PlatformPOSIX
     {
     public:
 
         static void
-        DebuggerInitialize (lldb_private::Debugger &debugger);
+        DebuggerInitialize (Debugger &debugger);
 
         static void
         Initialize ();
 
         static void
         Terminate ();
 
         PlatformLinux (bool is_host);
 
         virtual
         ~PlatformLinux();
 
         //------------------------------------------------------------
         // lldb_private::PluginInterface functions
         //------------------------------------------------------------
         static lldb::PlatformSP
-        CreateInstance (bool force, const lldb_private::ArchSpec *arch);
+        CreateInstance (bool force, const ArchSpec *arch);
 
-        static lldb_private::ConstString
+        static ConstString
         GetPluginNameStatic (bool is_host);
 
         static const char *
         GetPluginDescriptionStatic (bool is_host);
 
-        lldb_private::ConstString
+        ConstString
         GetPluginName() override;
 
         uint32_t
         GetPluginVersion() override
         {
             return 1;
         }
 
         //------------------------------------------------------------
         // lldb_private::Platform functions
         //------------------------------------------------------------
         Error
-        ResolveExecutable (const lldb_private::ModuleSpec &module_spec,
+        ResolveExecutable (const ModuleSpec &module_spec,
                            lldb::ModuleSP &module_sp,
                            const FileSpecList *module_search_paths_ptr) override;
 
         const char *
         GetDescription () override
         {
             return GetPluginDescriptionStatic(IsHost());
         }
public:
                       Error &error) override;
 
         void
         CalculateTrapHandlerSymbolNames () override;
 
         Error
         LaunchNativeProcess (
             ProcessLaunchInfo &launch_info,
-            lldb_private::NativeProcessProtocol::NativeDelegate &native_delegate,
+            NativeProcessProtocol::NativeDelegate &native_delegate,
             NativeProcessProtocolSP &process_sp) override;
 
         Error
         AttachNativeProcess (lldb::pid_t pid,
-                             lldb_private::NativeProcessProtocol::NativeDelegate &native_delegate,
+                             NativeProcessProtocol::NativeDelegate &native_delegate,
                              NativeProcessProtocolSP &process_sp) override;
 
         static bool
         UseLlgsForLocalDebugging ();
 
     private:
         DISALLOW_COPY_AND_ASSIGN (PlatformLinux);
     };
+
+} // namespace platform_linux
 } // namespace lldb_private
 
 #endif  // liblldb_PlatformLinux_h_

lldb/trunk/source/Plugins/Platform/Linux/PlatformLinux.cpp

 #include "lldb/Target/Process.h"
 
 #if defined(__linux__)
 #include "../../Process/Linux/NativeProcessLinux.h"
 #endif
 
 using namespace lldb;
 using namespace lldb_private;
+using namespace lldb_private::platform_linux;
+using namespace lldb_private::process_linux;
 
 static uint32_t g_initialize_count = 0;
 
 //------------------------------------------------------------------
 /// Code to handle the PlatformLinux settings
 //------------------------------------------------------------------
 
 namespace
 {
     enum
     {
         ePropertyUseLlgsForLocal = 0,
     };
 
-    const PropertyDefinition*
-    GetStaticPropertyDefinitions ()
-    {
-        static PropertyDefinition
-        g_properties[] =
-        {
-            { "use-llgs-for-local" , OptionValue::eTypeBoolean, true, true, NULL, NULL, "Control whether the platform uses llgs for local debug sessions." },
-            {  NULL        , OptionValue::eTypeInvalid, false, 0  , NULL, NULL, NULL  }
-        };
+    class PlatformLinuxProperties : public Properties
+    public:
+        static ConstString&
+        GetSettingName ();
 
-        // Allow environment variable to disable llgs-local.
-        if (getenv("PLATFORM_LINUX_DISABLE_LLGS_LOCAL"))
-            g_properties[ePropertyUseLlgsForLocal].default_uint_value = false;
+        PlatformLinuxProperties();
 
-        return g_properties;
-    }
-}
+        virtual
+        ~PlatformLinuxProperties() = default;
 
-class PlatformLinuxProperties : public Properties
-{
-public:
+        bool
+        GetUseLlgsForLocal() const;
 
-    static ConstString &
-    GetSettingName ()
-    {
-        static ConstString g_setting_name("linux");
-        return g_setting_name;
-    }
+    private:
+        static const PropertyDefinition*
+        GetStaticPropertyDefinitions();
+    };
+
+    typedef std::shared_ptr<PlatformLinuxProperties> PlatformLinuxPropertiesSP;
+
+} // anonymous namespace
 
-    PlatformLinuxProperties() :
+PlatformLinuxProperties::PlatformLinuxProperties() :
     Properties ()
-    {
-        m_collection_sp.reset (new OptionValueProperties(GetSettingName ()));
-        m_collection_sp->Initialize (GetStaticPropertyDefinitions ());
-    }
 
-    virtual
-    ~PlatformLinuxProperties()
-    {
-    }
+ConstString&
+PlatformLinuxProperties::GetSettingName ()
+    static ConstString g_setting_name("linux");
+    return g_setting_name;
 
-    bool
-    GetUseLlgsForLocal() const
-    {
-        const uint32_t idx = ePropertyUseLlgsForLocal;
-        return m_collection_sp->GetPropertyAtIndexAsBoolean (NULL, idx, GetStaticPropertyDefinitions()[idx].default_uint_value != 0);
-    }
+PlatformLinuxProperties::GetUseLlgsForLocal() const
+
+const PropertyDefinition*
+PlatformLinuxProperties::GetStaticPropertyDefinitions()
+{
+    static PropertyDefinition
+    g_properties[] =
+    {
+        { "use-llgs-for-local" , OptionValue::eTypeBoolean, true, true, NULL, NULL, "Control whether the platform uses llgs for local debug sessions." },
+        {  NULL        , OptionValue::eTypeInvalid, false, 0  , NULL, NULL, NULL  }
     };
 
-typedef std::shared_ptr<PlatformLinuxProperties> PlatformLinuxPropertiesSP;
+    // Allow environment variable to disable llgs-local.
+    if (getenv("PLATFORM_LINUX_DISABLE_LLGS_LOCAL"))
+        g_properties[ePropertyUseLlgsForLocal].default_uint_value = false;
+
+    return g_properties;
+}
 
 static const PlatformLinuxPropertiesSP &
 GetGlobalProperties()
 {
     static PlatformLinuxPropertiesSP g_settings_sp;
     if (!g_settings_sp)
         g_settings_sp.reset (new PlatformLinuxProperties ());
     return g_settings_sp;
 }
 
 void
-PlatformLinux::DebuggerInitialize (lldb_private::Debugger &debugger)
+PlatformLinux::DebuggerInitialize (Debugger &debugger)
 {
     if (!PluginManager::GetSettingForPlatformPlugin (debugger, PlatformLinuxProperties::GetSettingName()))
     {
         const bool is_global_setting = true;
         PluginManager::CreateSettingForPlatformPlugin (debugger,
                                                        GetGlobalProperties()->GetValueProperties(),
                                                        ConstString ("Properties for the PlatformLinux plug-in."),
                                                        is_global_setting);
     }
 }
 
 
 //------------------------------------------------------------------
 
 PlatformSP
 PlatformLinux::CreateInstance (bool force, const ArchSpec *arch)
 {
-    Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PLATFORM));
+    Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_PLATFORM));
     if (log)
     {
         const char *arch_name;
         if (arch && arch->GetArchitectureName ())
             arch_name = arch->GetArchitectureName ();
         else
             arch_name = "<null>";
 
#endif
 
     if (log)
         log->Printf ("PlatformLinux::%s() aborting creation of remote-linux platform", __FUNCTION__);
 
     return PlatformSP();
 }
 
 
-lldb_private::ConstString
+ConstString
 PlatformLinux::GetPluginNameStatic (bool is_host)
 {
     if (is_host)
     {
         static ConstString g_host_name(Platform::GetHostPlatformName ());
         return g_host_name;
     }
     else
     {
         static ConstString g_remote_name("remote-linux");
         return g_remote_name;
     }
 }
 
 const char *
 PlatformLinux::GetPluginDescriptionStatic (bool is_host)
 {
     if (is_host)
         return "Local Linux user platform plug-in.";
     else
         return "Remote Linux user platform plug-in.";
 }
 
-lldb_private::ConstString
+ConstString
 PlatformLinux::GetPluginName()
 {
     return GetPluginNameStatic(IsHost());
 }
 
 void
 PlatformLinux::Initialize ()
 {

 // lldb-launch, llgs-attach.  This differs from current lldb-launch, debugserver-attach
 // approach on MacOSX.
 lldb::ProcessSP
 PlatformLinux::DebugProcess (ProcessLaunchInfo &launch_info,
                              Debugger &debugger,
                              Target *target,       // Can be NULL, if NULL create a new target, else use existing one
                              Error &error)
 {
-    Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PLATFORM));
+    Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_PLATFORM));
     if (log)
         log->Printf ("PlatformLinux::%s entered (target %p)", __FUNCTION__, static_cast<void*>(target));
 
     // If we're a remote host, use standard behavior from parent class.
     if (!IsHost ())
         return PlatformPOSIX::DebugProcess (launch_info, debugger, target, error);
 
     //

 
 void
 PlatformLinux::CalculateTrapHandlerSymbolNames ()
 {
     m_trap_handlers.push_back (ConstString ("_sigtramp"));
 }
 
 Error
-PlatformLinux::LaunchNativeProcess (
-    ProcessLaunchInfo &launch_info,
-    lldb_private::NativeProcessProtocol::NativeDelegate &native_delegate,
+PlatformLinux::LaunchNativeProcess (ProcessLaunchInfo &launch_info,
+                                    NativeProcessProtocol::NativeDelegate &native_delegate,
                                     NativeProcessProtocolSP &process_sp)
 {
 #if !defined(__linux__)
     return Error("Only implemented on Linux hosts");
 #else
     if (!IsHost ())
         return Error("PlatformLinux::%s (): cannot launch a debug process when not the host", __FUNCTION__);
 
     // Retrieve the exe module.
error = NativeProcessLinux::LaunchProcess (
         process_sp);
 
     return error;
 #endif
 }
 
 Error
 PlatformLinux::AttachNativeProcess (lldb::pid_t pid,
-                                    lldb_private::NativeProcessProtocol::NativeDelegate &native_delegate,
+                                    NativeProcessProtocol::NativeDelegate &native_delegate,
                                     NativeProcessProtocolSP &process_sp)
 {
 #if !defined(__linux__)
     return Error("Only implemented on Linux hosts");
 #else
     if (!IsHost ())
         return Error("PlatformLinux::%s (): cannot attach to a debug process when not the host", __FUNCTION__);
 
     // Launch it for debugging
     return NativeProcessLinux::AttachToProcess (pid, native_delegate, process_sp);
 #endif
 }

lldb/trunk/source/Plugins/Platform/gdb-server/PlatformRemoteGDBServer.h

 // C++ Includes
 #include <string>
 
 // Other libraries and framework includes
 // Project includes
 #include "lldb/Target/Platform.h"
 #include "../../Process/gdb-remote/GDBRemoteCommunicationClient.h"
 
-class PlatformRemoteGDBServer : public lldb_private::Platform
+namespace lldb_private {
+namespace platform_gdb_server {
+
+class PlatformRemoteGDBServer : public Platform
 {
 public:
 
     static void
     Initialize ();
 
     static void
     Terminate ();
     
     static lldb::PlatformSP
-    CreateInstance (bool force, const lldb_private::ArchSpec *arch);
+    CreateInstance (bool force, const ArchSpec *arch);
 
-    static lldb_private::ConstString
+    static ConstString
     GetPluginNameStatic();
 
     static const char *
     GetDescriptionStatic();
 
 
     PlatformRemoteGDBServer ();
 
     virtual
     ~PlatformRemoteGDBServer();
 
     //------------------------------------------------------------
     // lldb_private::PluginInterface functions
     //------------------------------------------------------------
-    lldb_private::ConstString
+    ConstString
     GetPluginName() override
     {
         return GetPluginNameStatic();
     }
     
     uint32_t
     GetPluginVersion() override
     {
         return 1;
     }
     
 
     //------------------------------------------------------------
     // lldb_private::Platform functions
     //------------------------------------------------------------
-    lldb_private::Error
-    ResolveExecutable (const lldb_private::ModuleSpec &module_spec,
+    Error
+    ResolveExecutable (const ModuleSpec &module_spec,
                        lldb::ModuleSP &module_sp,
-                       const lldb_private::FileSpecList *module_search_paths_ptr) override;
+                       const FileSpecList *module_search_paths_ptr) override;
 
     bool
-    GetModuleSpec (const lldb_private::FileSpec& module_file_spec,
-                   const lldb_private::ArchSpec& arch,
-                   lldb_private::ModuleSpec &module_spec) override;
+    GetModuleSpec (const FileSpec& module_file_spec,
+                   const ArchSpec& arch,
+                   ModuleSpec &module_spec) override;
 
     const char *
     GetDescription () override;
 
-    lldb_private::Error
-    GetFileWithUUID (const lldb_private::FileSpec &platform_file, 
-                     const lldb_private::UUID *uuid_ptr,
-                     lldb_private::FileSpec &local_file) override;
+    Error
+    GetFileWithUUID (const FileSpec &platform_file, 
+                     const UUID *uuid_ptr,
+                     FileSpec &local_file) override;
 
     bool
-    GetProcessInfo (lldb::pid_t pid, 
-                    lldb_private::ProcessInstanceInfo &proc_info) override;
+    GetProcessInfo (lldb::pid_t pid, ProcessInstanceInfo &proc_info) override;
     
     uint32_t
-    FindProcesses (const lldb_private::ProcessInstanceInfoMatch &match_info,
-                   lldb_private::ProcessInstanceInfoList &process_infos) override;
+    FindProcesses (const ProcessInstanceInfoMatch &match_info,
+                   ProcessInstanceInfoList &process_infos) override;
 
-    lldb_private::Error
-    LaunchProcess (lldb_private::ProcessLaunchInfo &launch_info) override;
+    Error
+    LaunchProcess (ProcessLaunchInfo &launch_info) override;
 
-    lldb_private::Error
+    Error
     KillProcess (const lldb::pid_t pid) override;
 
     lldb::ProcessSP
-    DebugProcess (lldb_private::ProcessLaunchInfo &launch_info,
-                  lldb_private::Debugger &debugger,
-                  lldb_private::Target *target,       // Can be NULL, if NULL create a new target, else use existing one
-                  lldb_private::Error &error) override;
+    DebugProcess (ProcessLaunchInfo &launch_info,
+                  Debugger &debugger,
+                  Target *target,       // Can be NULL, if NULL create a new target, else use existing one
+                  Error &error) override;
 
     lldb::ProcessSP
-    Attach (lldb_private::ProcessAttachInfo &attach_info,
-            lldb_private::Debugger &debugger,
-            lldb_private::Target *target,       // Can be NULL, if NULL create a new target, else use existing one
-            lldb_private::Error &error) override;
+    Attach (ProcessAttachInfo &attach_info,
+            Debugger &debugger,
+            Target *target,       // Can be NULL, if NULL create a new target, else use existing one
+            Error &error) override;
 
     bool
-    GetSupportedArchitectureAtIndex (uint32_t idx, lldb_private::ArchSpec &arch) override;
+    GetSupportedArchitectureAtIndex (uint32_t idx, ArchSpec &arch) override;
 
     size_t
-    GetSoftwareBreakpointTrapOpcode (lldb_private::Target &target, 
-                                     lldb_private::BreakpointSite *bp_site) override;
+    GetSoftwareBreakpointTrapOpcode (Target &target, BreakpointSite *bp_site) override;
 
     bool
     GetRemoteOSVersion () override;
 
     bool
     GetRemoteOSBuildString (std::string &s) override;
     
     bool
     GetRemoteOSKernelDescription (std::string &s) override;
 
     // Remote Platform subclasses need to override this function
-    lldb_private::ArchSpec
+    ArchSpec
     GetRemoteSystemArchitecture () override;
 
-    lldb_private::ConstString
+    ConstString
     GetRemoteWorkingDirectory() override;
     
     bool
-    SetRemoteWorkingDirectory(const lldb_private::ConstString &path) override;
+    SetRemoteWorkingDirectory(const ConstString &path) override;
 
     // Remote subclasses should override this and return a valid instance
     // name if connected.
     const char *
     GetHostname () override;
 
     const char *
     GetUserName (uint32_t uid) override;
     
     const char *
     GetGroupName (uint32_t gid) override;
 
     bool
     IsConnected () const override;
 
-    lldb_private::Error
-    ConnectRemote (lldb_private::Args& args) override;
+    Error
+    ConnectRemote (Args& args) override;
 
-    lldb_private::Error
+    Error
     DisconnectRemote () override;
     
-    lldb_private::Error
+    Error
     MakeDirectory (const char *path, uint32_t file_permissions) override;
     
-    lldb_private::Error
+    Error
     GetFilePermissions (const char *path, uint32_t &file_permissions) override;
     
-    lldb_private::Error
+    Error
     SetFilePermissions (const char *path, uint32_t file_permissions) override;
     
 
     lldb::user_id_t
-    OpenFile (const lldb_private::FileSpec& file_spec,
-              uint32_t flags,
-              uint32_t mode,
-              lldb_private::Error &error) override;
+    OpenFile (const FileSpec& file_spec, uint32_t flags, uint32_t mode, Error &error) override;
     
     bool
-    CloseFile (lldb::user_id_t fd,
-               lldb_private::Error &error) override;
+    CloseFile (lldb::user_id_t fd, Error &error) override;
     
     uint64_t
     ReadFile (lldb::user_id_t fd,
               uint64_t offset,
               void *data_ptr,
               uint64_t len,
-              lldb_private::Error &error) override;
+              Error &error) override;
     
     uint64_t
     WriteFile (lldb::user_id_t fd,
                uint64_t offset,
                const void* data,
                uint64_t len,
-               lldb_private::Error &error) override;
+               Error &error) override;
 
     lldb::user_id_t
-    GetFileSize (const lldb_private::FileSpec& file_spec) override;
+    GetFileSize (const FileSpec& file_spec) override;
 
-    lldb_private::Error
-    PutFile (const lldb_private::FileSpec& source,
-             const lldb_private::FileSpec& destination,
+    Error
+    PutFile (const FileSpec& source,
+             const FileSpec& destination,
              uint32_t uid = UINT32_MAX,
              uint32_t gid = UINT32_MAX) override;
     
-    lldb_private::Error
+    Error
     CreateSymlink (const char *src, const char *dst) override;
 
     bool
-    GetFileExists (const lldb_private::FileSpec& file_spec) override;
+    GetFileExists (const FileSpec& file_spec) override;
 
-    lldb_private::Error
+    Error
     Unlink (const char *path) override;
 
-    lldb_private::Error
+    Error
     RunShellCommand (const char *command,            // Shouldn't be NULL
                      const char *working_dir,        // Pass NULL to use the current working directory
                      int *status_ptr,                // Pass NULL if you don't want the process exit status
                      int *signo_ptr,                 // Pass NULL if you don't want the signal that caused the process to exit
                      std::string *command_output,    // Pass NULL if you don't want the command output
                      uint32_t timeout_sec) override; // Timeout in seconds to wait for shell program to finish
 
     void
     CalculateTrapHandlerSymbolNames () override;
 
 protected:
-    GDBRemoteCommunicationClient m_gdb_client;
+    process_gdb_remote::GDBRemoteCommunicationClient m_gdb_client;
     std::string m_platform_description; // After we connect we can get a more complete description of what we are connected to
     std::string m_platform_hostname;
 
     // Launch the lldb-gdbserver on the remote host and return the port it is listening on or 0 on
     // failure. Subclasses should override this method if they want to do extra actions before or
     // after launching the lldb-gdbserver.
     virtual uint16_t
     LaunchGDBserverAndGetPort (lldb::pid_t &pid);
 
     virtual bool
     KillSpawnedProcess (lldb::pid_t pid);
 
 private:
     DISALLOW_COPY_AND_ASSIGN (PlatformRemoteGDBServer);
 
 };
 
+} // namespace platform_gdb_server
+} // namespace lldb_private
+
 #endif  // liblldb_PlatformRemoteGDBServer_h_

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

 #include "lldb/Host/StringConvert.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Target.h"
 
 #include "Utility/UriParser.h"
 
 using namespace lldb;
 using namespace lldb_private;
+using namespace lldb_private::platform_gdb_server;
 
 static bool g_initialized = false;
 
 static std::string MakeGdbServerUrl (const std::string &platform_hostname, uint16_t port)
 {
     const char *override_hostname = getenv("LLDB_PLATFORM_REMOTE_GDB_SERVER_HOSTNAME");
     const char *port_offset_c_str = getenv("LLDB_PLATFORM_REMOTE_GDB_SERVER_PORT_OFFSET");
     int port_offset = port_offset_c_str ? ::atoi(port_offset_c_str) : 0;
-    lldb_private::StreamString result;
+    StreamString result;
     result.Printf("connect://%s:%u",
             override_hostname ? override_hostname : platform_hostname.c_str(),
             port + port_offset);
     return result.GetString();
 }
 
 void
 PlatformRemoteGDBServer::Initialize ()
if (g_initialized)
         g_initialized = false;
         PluginManager::UnregisterPlugin (PlatformRemoteGDBServer::CreateInstance);
     }
 
     Platform::Terminate ();
 }
 
 PlatformSP
-PlatformRemoteGDBServer::CreateInstance (bool force, const lldb_private::ArchSpec *arch)
+PlatformRemoteGDBServer::CreateInstance (bool force, const ArchSpec *arch)
 {
     bool create = force;
     if (!create)
     {
         create = !arch->TripleVendorWasSpecified() && !arch->TripleOSWasSpecified();
     }
     if (create)
         return PlatformSP(new PlatformRemoteGDBServer());
     return PlatformSP();
 }
 
 
-lldb_private::ConstString
+ConstString
 PlatformRemoteGDBServer::GetPluginNameStatic()
 {
     static ConstString g_name("remote-gdb-server");
     return g_name;
 }
 
 const char *
 PlatformRemoteGDBServer::GetDescriptionStatic()

 
 // Remote Platform subclasses need to override this function
 ArchSpec
 PlatformRemoteGDBServer::GetRemoteSystemArchitecture ()
 {
     return m_gdb_client.GetSystemArchitecture();
 }
 
-lldb_private::ConstString
+ConstString
 PlatformRemoteGDBServer::GetRemoteWorkingDirectory()
 {
     if (IsConnected())
     {
         Log *log = GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PLATFORM);
         std::string cwd;
         if (m_gdb_client.GetWorkingDir(cwd))
         {
PlatformRemoteGDBServer::GetRemoteWorkingDirectory()
     }
     else
     {
         return Platform::GetRemoteWorkingDirectory();
     }
 }
 
 bool
-PlatformRemoteGDBServer::SetRemoteWorkingDirectory(const lldb_private::ConstString &path)
+PlatformRemoteGDBServer::SetRemoteWorkingDirectory(const ConstString &path)
 {
     if (IsConnected())
     {
         // Clear the working directory it case it doesn't get set correctly. This will
         // for use to re-read it
         Log *log = GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PLATFORM);
         if (log)
             log->Printf("PlatformRemoteGDBServer::SetRemoteWorkingDirectory('%s')", path.GetCString());

 {
     return m_gdb_client.GetProcessInfo (pid, process_info);
 }
 
 
 Error
 PlatformRemoteGDBServer::LaunchProcess (ProcessLaunchInfo &launch_info)
 {
-    Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PLATFORM));
+    Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_PLATFORM));
     Error error;
 
     if (log)
         log->Printf ("PlatformRemoteGDBServer::%s() called", __FUNCTION__);
 
     auto num_file_actions = launch_info.GetNumFileActions ();
     for (decltype(num_file_actions) i = 0; i < num_file_actions; ++i)
     {
PlatformRemoteGDBServer::LaunchProcess (ProcessLaunchInfo &launch_info)
     
     m_gdb_client.SendLaunchArchPacket(arch_triple);
     if (log)
         log->Printf ("PlatformRemoteGDBServer::%s() set launch architecture triple to '%s'", __FUNCTION__, arch_triple ? arch_triple : "<NULL>");
 
     int arg_packet_err;
     {
         // Scope for the scoped timeout object
-        GDBRemoteCommunication::ScopedTimeout timeout(m_gdb_client, 5);
+        process_gdb_remote::GDBRemoteCommunication::ScopedTimeout timeout(m_gdb_client, 5);
         arg_packet_err = m_gdb_client.SendArgumentsPacket (launch_info);
     }
 
     if (arg_packet_err == 0)
     {
         std::string error_str;
         if (m_gdb_client.GetLaunchSuccess (error_str))
         {

 PlatformRemoteGDBServer::KillProcess (const lldb::pid_t pid)
 {
     if (!KillSpawnedProcess(pid))
         return Error("failed to kill remote spawned process");
     return Error();
 }
 
 lldb::ProcessSP
-PlatformRemoteGDBServer::DebugProcess (lldb_private::ProcessLaunchInfo &launch_info,
-                                       lldb_private::Debugger &debugger,
-                                       lldb_private::Target *target,       // Can be NULL, if NULL create a new target, else use existing one
-                                       lldb_private::Error &error)
+PlatformRemoteGDBServer::DebugProcess (ProcessLaunchInfo &launch_info,
+                                       Debugger &debugger,
+                                       Target *target,       // Can be NULL, if NULL create a new target, else use existing one
+                                       Error &error)
 {
     lldb::ProcessSP process_sp;
     if (IsRemote())
     {
         if (IsConnected())
         {
             lldb::pid_t debugserver_pid = LLDB_INVALID_PROCESS_ID;
             uint16_t port = LaunchGDBserverAndGetPort(debugserver_pid);

 
 bool
 PlatformRemoteGDBServer::KillSpawnedProcess (lldb::pid_t pid)
 {
     return m_gdb_client.KillSpawnedProcess (pid);
 }
 
 lldb::ProcessSP
-PlatformRemoteGDBServer::Attach (lldb_private::ProcessAttachInfo &attach_info,
+PlatformRemoteGDBServer::Attach (ProcessAttachInfo &attach_info,
                                  Debugger &debugger,
                                  Target *target,       // Can be NULL, if NULL create a new target, else use existing one
                                  Error &error)
 {
     lldb::ProcessSP process_sp;
     if (IsRemote())
     {
         if (IsConnected())
PlatformRemoteGDBServer::SetFilePermissions (const char *path, uint32_t file_permissions)
     Log *log = GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PLATFORM);
     if (log)
         log->Printf ("PlatformRemoteGDBServer::SetFilePermissions(path='%s', file_permissions=%o) error = %u (%s)", path, file_permissions, error.GetError(), error.AsCString());
     return error;
 }
 
 
 lldb::user_id_t
-PlatformRemoteGDBServer::OpenFile (const lldb_private::FileSpec& file_spec,
+PlatformRemoteGDBServer::OpenFile (const FileSpec& file_spec,
                                    uint32_t flags,
                                    uint32_t mode,
                                    Error &error)
 {
     return m_gdb_client.OpenFile (file_spec, flags, mode, error);
 }
 
 bool
 PlatformRemoteGDBServer::CloseFile (lldb::user_id_t fd, Error &error)
 {
     return m_gdb_client.CloseFile (fd, error);
 }
 
 lldb::user_id_t
-PlatformRemoteGDBServer::GetFileSize (const lldb_private::FileSpec& file_spec)
+PlatformRemoteGDBServer::GetFileSize (const FileSpec& file_spec)
 {
     return m_gdb_client.GetFileSize(file_spec);
 }
 
 uint64_t
 PlatformRemoteGDBServer::ReadFile (lldb::user_id_t fd,
                                    uint64_t offset,
                                    void *dst,
                                    uint64_t dst_len,
                                    Error &error)
 {
     return m_gdb_client.ReadFile (fd, offset, dst, dst_len, error);
 }
 
 uint64_t
 PlatformRemoteGDBServer::WriteFile (lldb::user_id_t fd,
                                     uint64_t offset,
                                     const void* src,
                                     uint64_t src_len,
                                     Error &error)
 {
     return m_gdb_client.WriteFile (fd, offset, src, src_len, error);
 }
 
-lldb_private::Error
-PlatformRemoteGDBServer::PutFile (const lldb_private::FileSpec& source,
-         const lldb_private::FileSpec& destination,
+Error
+PlatformRemoteGDBServer::PutFile (const FileSpec& source,
+         const FileSpec& destination,
          uint32_t uid,
          uint32_t gid)
 {
     return Platform::PutFile(source,destination,uid,gid);
 }
 
 Error
 PlatformRemoteGDBServer::CreateSymlink (const char *src,    // The name of the link is in src
PlatformRemoteGDBServer::Unlink (const char *path)
     Error error = m_gdb_client.Unlink (path);
     Log *log = GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PLATFORM);
     if (log)
         log->Printf ("PlatformRemoteGDBServer::Unlink(path='%s') error = %u (%s)", path, error.GetError(), error.AsCString());
     return error;
 }
 
 bool
-PlatformRemoteGDBServer::GetFileExists (const lldb_private::FileSpec& file_spec)
+PlatformRemoteGDBServer::GetFileExists (const FileSpec& file_spec)
 {
     return m_gdb_client.GetFileExists (file_spec);
 }
 
-lldb_private::Error
+Error
 PlatformRemoteGDBServer::RunShellCommand (const char *command,           // Shouldn't be NULL
                                           const char *working_dir,       // Pass NULL to use the current working directory
                                           int *status_ptr,               // Pass NULL if you don't want the process exit status
                                           int *signo_ptr,                // Pass NULL if you don't want the signal that caused the process to exit
                                           std::string *command_output,   // Pass NULL if you don't want the command output
                                           uint32_t timeout_sec)          // Timeout in seconds to wait for shell program to finish
 {
     return m_gdb_client.RunShellCommand (command, working_dir, status_ptr, signo_ptr, command_output, timeout_sec);
 }
 
 void
 PlatformRemoteGDBServer::CalculateTrapHandlerSymbolNames ()
 {   
     m_trap_handlers.push_back (ConstString ("_sigtramp"));
 }

lldb/trunk/source/Plugins/Process/Linux/LinuxThread.h

 //===-- LinuxThread.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_LinuxThread_H_
 #define liblldb_LinuxThread_H_
 
 // Other libraries and framework includes
 #include "Plugins/Process/POSIX/POSIXThread.h"
 
+namespace lldb_private {
+namespace process_linux {
+
 //------------------------------------------------------------------------------
 // @class LinuxThread
 // @brief Abstraction of a Linux thread.
-class LinuxThread
-    : public POSIXThread
+class LinuxThread : public POSIXThread
 {
 public:
 
     //------------------------------------------------------------------
     // Constructors and destructors
     //------------------------------------------------------------------
-    LinuxThread(lldb_private::Process &process, lldb::tid_t tid);
+    LinuxThread(Process &process, lldb::tid_t tid);
 
     virtual ~LinuxThread();
 
     //--------------------------------------------------------------------------
     // LinuxThread internal API.
 
     // POSIXThread override
     void
     RefreshStateAfterStop() override;
 };
 
+} // namespace process_linux
+} // namespace lldb_private
+
 #endif // #ifndef liblldb_LinuxThread_H_

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

 // C Includes
 // C++ Includes
 // Other libraries and framework includes
 // Project includes
 #include "LinuxThread.h"
 
 using namespace lldb;
 using namespace lldb_private;
+using namespace lldb_private::process_linux;
 
 //------------------------------------------------------------------------------
 // Constructors and destructors.
 
 LinuxThread::LinuxThread(Process &process, lldb::tid_t tid)
     : POSIXThread(process, tid)
 {
 }

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

 #include "lldb/lldb-types.h"
 #include "lldb/Host/Debug.h"
 #include "lldb/Host/HostThread.h"
 #include "lldb/Host/Mutex.h"
 #include "lldb/Target/MemoryRegionInfo.h"
 
 #include "lldb/Host/common/NativeProcessProtocol.h"
 
-namespace lldb_private
-{
+namespace lldb_private {
     class Error;
     class Module;
-    class ThreadStateCoordinator;
     class Scalar;
 
+namespace process_linux {
+    class ThreadStateCoordinator;
+
     /// @class NativeProcessLinux
     /// @brief Manages communication with the inferior (debugee) process.
     ///
     /// Upon construction, this class prepares and launches an inferior process for
     /// debugging.
     ///
     /// Changes in the inferior process state are broadcasted.
     class NativeProcessLinux: public NativeProcessProtocol
     {
     public:
 
-        static lldb_private::Error
+        static Error
         LaunchProcess (
             Module *exe_module,
             ProcessLaunchInfo &launch_info,
-            lldb_private::NativeProcessProtocol::NativeDelegate &native_delegate,
+            NativeProcessProtocol::NativeDelegate &native_delegate,
             NativeProcessProtocolSP &native_process_sp);
 
-        static lldb_private::Error
+        static Error
         AttachToProcess (
             lldb::pid_t pid,
-            lldb_private::NativeProcessProtocol::NativeDelegate &native_delegate,
+            NativeProcessProtocol::NativeDelegate &native_delegate,
             NativeProcessProtocolSP &native_process_sp);
 
         // ---------------------------------------------------------------------
         // NativeProcessProtocol Interface
         // ---------------------------------------------------------------------
         Error
         Resume (const ResumeActionList &resume_actions) override;
 
public:
         // ---------------------------------------------------------------------
 
         /// Reads the contents from the register identified by the given (architecture
         /// dependent) offset.
         ///
         /// This method is provided for use by RegisterContextLinux derivatives.
         Error
         ReadRegisterValue(lldb::tid_t tid, unsigned offset, const char *reg_name,
-                          unsigned size, lldb_private::RegisterValue &value);
+                          unsigned size, RegisterValue &value);
 
         /// Writes the given value to the register identified by the given
         /// (architecture dependent) offset.
         ///
         /// This method is provided for use by RegisterContextLinux derivatives.
         Error
         WriteRegisterValue(lldb::tid_t tid, unsigned offset, const char *reg_name,
-                           const lldb_private::RegisterValue &value);
+                           const RegisterValue &value);
 
         /// Reads all general purpose registers into the specified buffer.
         Error
         ReadGPR(lldb::tid_t tid, void *buf, size_t buf_size);
 
         /// Reads generic floating point registers into the specified buffer.
         Error
         ReadFPR(lldb::tid_t tid, void *buf, size_t buf_size);
protected:
         // ---------------------------------------------------------------------
         // NativeProcessProtocol protected interface
         // ---------------------------------------------------------------------
         Error
         GetSoftwareBreakpointTrapOpcode (size_t trap_opcode_size_hint, size_t &actual_opcode_size, const uint8_t *&trap_opcode_bytes) override;
 
     private:
 
-        lldb_private::ArchSpec m_arch;
+        ArchSpec m_arch;
 
         HostThread m_operation_thread;
         HostThread m_monitor_thread;
 
         // current operation which must be executed on the priviliged thread
         void *m_operation;
-        lldb_private::Mutex m_operation_mutex;
+        Mutex m_operation_mutex;
 
         // semaphores notified when Operation is ready to be processed and when
         // the operation is complete.
         sem_t m_operation_pending;
         sem_t m_operation_done;
 
-        lldb_private::LazyBool m_supports_mem_region;
+        LazyBool m_supports_mem_region;
         std::vector<MemoryRegionInfo> m_mem_region_cache;
-        lldb_private::Mutex m_mem_region_cache_mutex;
+        Mutex m_mem_region_cache_mutex;
 
         std::unique_ptr<ThreadStateCoordinator> m_coordinator_up;
         HostThread m_coordinator_thread;
 
         struct OperationArgs
         {
             OperationArgs(NativeProcessLinux *monitor);
 
             ~OperationArgs();
 
             NativeProcessLinux *m_monitor;      // The monitor performing the attach.
             sem_t m_semaphore;              // Posted to once operation complete.
-            lldb_private::Error m_error;    // Set if process operation failed.
+            Error m_error;    // Set if process operation failed.
         };
 
         /// @class LauchArgs
         ///
         /// @brief Simple structure to pass data to the thread responsible for
         /// launching a child process.
         struct LaunchArgs : OperationArgs
         {
             LaunchArgs(NativeProcessLinux *monitor,
-                    lldb_private::Module *module,
+                    Module *module,
                     char const **argv,
                     char const **envp,
                     const std::string &stdin_path,
                     const std::string &stdout_path,
                     const std::string &stderr_path,
                     const char *working_dir,
-                    const lldb_private::ProcessLaunchInfo &launch_info);
+                    const ProcessLaunchInfo &launch_info);
 
             ~LaunchArgs();
 
-            lldb_private::Module *m_module; // The executable image to launch.
-            char const **m_argv;            // Process arguments.
-            char const **m_envp;            // Process environment.
+            Module *m_module;                 // The executable image to launch.
+            char const **m_argv;              // Process arguments.
+            char const **m_envp;              // Process environment.
             const std::string &m_stdin_path;  // Redirect stdin if not empty.
             const std::string &m_stdout_path; // Redirect stdout if not empty.
             const std::string &m_stderr_path; // Redirect stderr if not empty.
-            const char *m_working_dir;      // Working directory or NULL.
-            const lldb_private::ProcessLaunchInfo &m_launch_info;
+            const char *m_working_dir;        // Working directory or NULL.
+            const ProcessLaunchInfo &m_launch_info;
         };
 
         struct AttachArgs : OperationArgs
         {
             AttachArgs(NativeProcessLinux *monitor,
                        lldb::pid_t pid);
 
             ~AttachArgs();
private:
         LaunchInferior (
             Module *module,
             char const *argv[],
             char const *envp[],
             const std::string &stdin_path,
             const std::string &stdout_path,
             const std::string &stderr_path,
             const char *working_dir,
-            const lldb_private::ProcessLaunchInfo &launch_info,
+            const ProcessLaunchInfo &launch_info,
             Error &error);
 
         /// Attaches to an existing process.  Forms the
         /// implementation of Process::DoAttach
         void
         AttachToInferior (lldb::pid_t pid, Error &error);
 
         void
-        StartLaunchOpThread(LaunchArgs *args, lldb_private::Error &error);
+        StartLaunchOpThread(LaunchArgs *args, Error &error);
 
         static void *
         LaunchOpThread(void *arg);
 
         static bool
         Launch(LaunchArgs *args);
 
         void
-        StartAttachOpThread(AttachArgs *args, lldb_private::Error &error);
+        StartAttachOpThread(AttachArgs *args, Error &error);
 
         static void *
         AttachOpThread(void *args);
 
         static bool
         Attach(AttachArgs *args);
 
         static Error
#endif
         CallAfterRunningThreadsStop (lldb::tid_t tid,
                                      const std::function<void (lldb::tid_t tid)> &call_after_function);
 
         void
         CallAfterRunningThreadsStopWithSkipTID (lldb::tid_t deferred_signal_tid,
                                                 lldb::tid_t skip_stop_request_tid,
                                                 const std::function<void (lldb::tid_t tid)> &call_after_function);
 
-        lldb_private::Error
+        Error
         Detach(lldb::tid_t tid);
 
-        lldb_private::Error
+        Error
         RequestThreadStop (const lldb::pid_t pid, const lldb::tid_t tid);
     };
-} // End lldb_private namespace.
+
+} // namespace process_linux
+} // namespace lldb_private
 
 #endif // #ifndef liblldb_NativeProcessLinux_H_

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

#define PTRACE(req, pid, addr, data, data_size, error) \
     PtraceWrapper((req), (pid), (addr), (data), (data_size), (error), #req, __FILE__, __LINE__)
 #else
 #define PTRACE(req, pid, addr, data, data_size, error) \
     PtraceWrapper((req), (pid), (addr), (data), (data_size), (error))
 #endif
 
 using namespace lldb;
 using namespace lldb_private;
+using namespace lldb_private::process_linux;
 using namespace llvm;
 
 // Private bits we only need internally.
 namespace
 {
     static void * const EXIT_OPERATION = nullptr;
 
     const UnixSignals&
namespace
     }
 
     Error
     ResolveProcessArchitecture (lldb::pid_t pid, Platform &platform, ArchSpec &arch)
     {
         // Grab process info for the running process.
         ProcessInstanceInfo process_info;
         if (!platform.GetProcessInfo (pid, process_info))
-            return lldb_private::Error("failed to get process info");
+            return Error("failed to get process info");
 
         // Resolve the executable module.
         ModuleSP exe_module_sp;
         ModuleSpec exe_module_spec(process_info.GetExecutableFile(), process_info.GetArchitecture());
         FileSpecList executable_search_paths (Target::GetDefaultExecutableSearchPaths ());
         Error error = platform.ResolveExecutable(
             exe_module_spec,
             exe_module_sp,
             executable_search_paths.GetSize () ? &executable_search_paths : NULL);
 
         if (!error.Success ())
             return error;
 
         // Check if we've got our architecture from the exe_module.
         arch = exe_module_sp->GetArchitecture ();
         if (arch.IsValid ())
             return Error();
         else
             return Error("failed to retrieve a valid architecture from the exe module");
     }
 
     void
-    DisplayBytes (lldb_private::StreamString &s, void *bytes, uint32_t count)
+    DisplayBytes (StreamString &s, void *bytes, uint32_t count)
     {
         uint8_t *ptr = (uint8_t *)bytes;
         const uint32_t loop_count = std::min<uint32_t>(DEBUG_PTRACE_MAXBYTES, count);
         for(uint32_t i=0; i<loop_count; i++)
         {
             s.Printf ("[%x]", *ptr);
             ptr++;
         }
#if defined (__arm64__) || defined (__aarch64__)
             int regset = NT_FPREGSET;
             struct iovec ioVec;
 
             ioVec.iov_base = &regs;
             ioVec.iov_len = sizeof regs;
             PTRACE(PTRACE_GETREGSET, m_tid, &regset, &ioVec, sizeof regs, m_error);
             if (m_error.Success())
             {
-                lldb_private::ArchSpec arch;
+                ArchSpec arch;
                 if (monitor->GetArchitecture(arch))
                     m_value.SetBytes((void *)(((unsigned char *)(&regs)) + offset), 16, arch.GetByteOrder());
                 else
                     m_error.SetErrorString("failed to get architecture");
             }
         }
         else
         {
             elf_gregset_t regs;
             int regset = NT_PRSTATUS;
             struct iovec ioVec;
 
             ioVec.iov_base = &regs;
             ioVec.iov_len = sizeof regs;
             PTRACE(PTRACE_GETREGSET, m_tid, &regset, &ioVec, sizeof regs, m_error);
             if (m_error.Success())
             {
-                lldb_private::ArchSpec arch;
+                ArchSpec arch;
                 if (monitor->GetArchitecture(arch))
                     m_value.SetBytes((void *)(((unsigned char *)(regs)) + m_offset), 8, arch.GetByteOrder());
                 else
                     m_error.SetErrorString("failed to get architecture");
             }
         }
 #else
         Log *log (ProcessPOSIXLog::GetLogIfAllCategoriesSet (POSIX_LOG_REGISTERS));

 }
 
 NativeProcessLinux::OperationArgs::~OperationArgs()
 {
     sem_destroy(&m_semaphore);
 }
 
 NativeProcessLinux::LaunchArgs::LaunchArgs(NativeProcessLinux *monitor,
-                                       lldb_private::Module *module,
+                                       Module *module,
                                        char const **argv,
                                        char const **envp,
                                        const std::string &stdin_path,
                                        const std::string &stdout_path,
                                        const std::string &stderr_path,
                                        const char *working_dir,
-                                       const lldb_private::ProcessLaunchInfo &launch_info)
+                                       const ProcessLaunchInfo &launch_info)
     : OperationArgs(monitor),
       m_module(module),
       m_argv(argv),
       m_envp(envp),
       m_stdin_path(stdin_path),
       m_stdout_path(stdout_path),
       m_stderr_path(stderr_path),
       m_working_dir(working_dir),

 
 NativeProcessLinux::AttachArgs::~AttachArgs()
 { }
 
 // -----------------------------------------------------------------------------
 // Public Static Methods
 // -----------------------------------------------------------------------------
 
-lldb_private::Error
+Error
 NativeProcessLinux::LaunchProcess (
-    lldb_private::Module *exe_module,
-    lldb_private::ProcessLaunchInfo &launch_info,
-    lldb_private::NativeProcessProtocol::NativeDelegate &native_delegate,
+    Module *exe_module,
+    ProcessLaunchInfo &launch_info,
+    NativeProcessProtocol::NativeDelegate &native_delegate,
     NativeProcessProtocolSP &native_process_sp)
 {
     Log *log (GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
 
     Error error;
 
     // Verify the working directory is valid if one was specified.
     const char* working_dir = launch_info.GetWorkingDirectory ();
     if (working_dir)
     {
       FileSpec working_dir_fs (working_dir, true);
       if (!working_dir_fs || working_dir_fs.GetFileType () != FileSpec::eFileTypeDirectory)
       {
           error.SetErrorStringWithFormat ("No such file or directory: %s", working_dir);
           return error;
       }
     }
 
-    const lldb_private::FileAction *file_action;
+    const FileAction *file_action;
 
     // Default of NULL will mean to use existing open file descriptors.
     std::string stdin_path;
     std::string stdout_path;
     std::string stderr_path;
 
     file_action = launch_info.GetFileActionForFD (STDIN_FILENO);
     if (file_action)
if (error.Fail ())
         return error;
     }
 
     launch_info.SetProcessID (native_process_sp->GetID ());
 
     return error;
 }
 
-lldb_private::Error
+Error
 NativeProcessLinux::AttachToProcess (
     lldb::pid_t pid,
-    lldb_private::NativeProcessProtocol::NativeDelegate &native_delegate,
+    NativeProcessProtocol::NativeDelegate &native_delegate,
     NativeProcessProtocolSP &native_process_sp)
 {
     Log *log (GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
     if (log && log->GetMask ().Test (POSIX_LOG_VERBOSE))
         log->Printf ("NativeProcessLinux::%s(pid = %" PRIi64 ")", __FUNCTION__, pid);
 
     // Grab the current platform architecture.  This should be Linux,
     // since this code is only intended to run on a Linux host.

 NativeProcessLinux::LaunchInferior (
     Module *module,
     const char *argv[],
     const char *envp[],
     const std::string &stdin_path,
     const std::string &stdout_path,
     const std::string &stderr_path,
     const char *working_dir,
-    const lldb_private::ProcessLaunchInfo &launch_info,
-    lldb_private::Error &error)
+    const ProcessLaunchInfo &launch_info,
+    Error &error)
 {
     if (module)
         m_arch = module->GetArchitecture ();
 
     SetState (eStateLaunching);
 
     std::unique_ptr<LaunchArgs> args(
         new LaunchArgs(
WAIT_AGAIN:
     {
         error.SetErrorToGenericError();
         error.SetErrorString ("Process attach failed to create monitor thread for NativeProcessLinux::MonitorCallback.");
         return;
     }
 }
 
 void
-NativeProcessLinux::AttachToInferior (lldb::pid_t pid, lldb_private::Error &error)
+NativeProcessLinux::AttachToInferior (lldb::pid_t pid, Error &error)
 {
     Log *log (GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
     if (log)
         log->Printf ("NativeProcessLinux::%s (pid = %" PRIi64 ")", __FUNCTION__, pid);
 
     // We can use the Host for everything except the ResolveExecutable portion.
     PlatformSP platform_sp = Platform::GetHostPlatform ();
     if (!platform_sp)
if (log)
                 __FUNCTION__,
                 args->m_error.AsCString ());
         }
     }
     return args->m_error.Success();
 }
 
 void
-NativeProcessLinux::StartAttachOpThread(AttachArgs *args, lldb_private::Error &error)
+NativeProcessLinux::StartAttachOpThread(AttachArgs *args, Error &error)
 {
     static const char *g_thread_name = "lldb.process.linux.operation";
 
     if (m_operation_thread.IsJoinable())
         return;
 
     m_operation_thread = ThreadLauncher::LaunchThread(g_thread_name, AttachOpThread, args, &error);
 }

 Error
 NativeProcessLinux::GetEventMessage(lldb::tid_t tid, unsigned long *message)
 {
     EventMessageOperation op(tid, message);
     DoOperation(&op);
     return op.GetError();
 }
 
-lldb_private::Error
+Error
 NativeProcessLinux::Detach(lldb::tid_t tid)
 {
     if (tid == LLDB_INVALID_THREAD_ID)
         return Error();
 
     DetachOperation op(tid);
     DoOperation(&op);
     return op.GetError();
m_coordinator_up->CallAfterRunningThreadsStopWithSkipTIDs (deferred_signal_tid,
                                                                [=](lldb::tid_t request_stop_tid)
                                                                {
                                                                    return RequestThreadStop(pid, request_stop_tid);
                                                                },
                                                                call_after_function,
                                                                CoordinatorErrorHandler);
 }
 
-lldb_private::Error
+Error
 NativeProcessLinux::RequestThreadStop (const lldb::pid_t pid, const lldb::tid_t tid)
 {
     Log* log (GetLogIfAllCategoriesSet (LIBLLDB_LOG_THREAD));
     if (log)
         log->Printf ("NativeProcessLinux::%s requesting thread stop(pid: %" PRIu64 ", tid: %" PRIu64 ")", __FUNCTION__, pid, tid);
 
     Error err;
     errno = 0;

lldb/trunk/source/Plugins/Process/Linux/NativeRegisterContextLinux_arm64.h

 //===-- NativeRegisterContextLinux_arm64.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_NativeRegisterContextLinux_arm64_h
 #define lldb_NativeRegisterContextLinux_arm64_h
 
 #include "lldb/Host/common/NativeRegisterContextRegisterInfo.h"
 #include "Plugins/Process/Utility/lldb-arm64-register-enums.h"
 
-namespace lldb_private
-{
+namespace lldb_private {
+namespace process_linux {
+
     class NativeProcessLinux;
 
     class NativeRegisterContextLinux_arm64 : public NativeRegisterContextRegisterInfo
     {
     public:
         NativeRegisterContextLinux_arm64 (NativeThreadProtocol &native_thread,
                                           uint32_t concrete_frame_idx,
                                           RegisterInfoInterface *reg_info_interface_p);
private:
         // based on RegisterContextDarwin_arm64.h
         struct FPU
         {
             VReg        v[32];
             uint32_t    fpsr;
             uint32_t    fpcr;
         };
 
-        uint64_t m_gpr_arm64[lldb_private::k_num_gpr_registers_arm64]; // 64-bit general purpose registers.
+        uint64_t m_gpr_arm64[k_num_gpr_registers_arm64]; // 64-bit general purpose registers.
         RegInfo  m_reg_info;
         FPU m_fpr; // floating-point registers including extended register sets.
 
         bool
         IsGPR(unsigned reg) const;
 
         bool
         ReadGPR ();
 
         bool
         WriteGPR ();
 
         bool
         IsFPR(unsigned reg) const;
 
         bool
         ReadFPR ();
 
         bool
         WriteFPR ();
 
-        lldb_private::Error
+        Error
         ReadRegisterRaw (uint32_t reg_index, RegisterValue &reg_value);
 
-        lldb_private::Error
+        Error
         WriteRegisterRaw (uint32_t reg_index, const RegisterValue &reg_value);
 
         lldb::ByteOrder
         GetByteOrder() const;
 
         size_t
         GetGPRSize() const;
     };
-}
+
+} // namespace process_linux
+} // namespace lldb_private
 
 #endif // #ifndef lldb_NativeRegisterContextLinux_arm64_h
 

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

 #include "lldb/Host/common/NativeProcessProtocol.h"
 #include "lldb/Host/common/NativeThreadProtocol.h"
 #include "Plugins/Process/Linux/NativeProcessLinux.h"
 
 #define REG_CONTEXT_SIZE (GetGPRSize() + sizeof (m_fpr))
 
 using namespace lldb;
 using namespace lldb_private;
+using namespace lldb_private::process_linux;
 
 // ARM64 general purpose registers.
 static const uint32_t g_gpr_regnums_arm64[] =
 {
     gpr_x0_arm64,
     gpr_x1_arm64,
     gpr_x2_arm64,
     gpr_x3_arm64,
namespace {
     // Number of register sets provided by this context.
     enum
     {
         k_num_register_sets = 2
     };
 }
 
 // Register sets for ARM64.
-static const lldb_private::RegisterSet
+static const RegisterSet
 g_reg_sets_arm64[k_num_register_sets] =
 {
     { "General Purpose Registers",  "gpr", k_num_gpr_registers_arm64, g_gpr_regnums_arm64 },
     { "Floating Point Registers",   "fpu", k_num_fpr_registers_arm64, g_fpu_regnums_arm64 }
 };
 
 NativeRegisterContextLinux_arm64::NativeRegisterContextLinux_arm64 (
         NativeThreadProtocol &native_thread,

 }
 
 uint32_t
 NativeRegisterContextLinux_arm64::GetRegisterSetCount () const
 {
     return k_num_register_sets;
 }
 
-const lldb_private::RegisterSet *
+const RegisterSet *
 NativeRegisterContextLinux_arm64::GetRegisterSet (uint32_t set_index) const
 {
     if (set_index < k_num_register_sets)
         return &g_reg_sets_arm64[set_index];
 
     return nullptr;
 }
 
-lldb_private::Error
+Error
 NativeRegisterContextLinux_arm64::ReadRegister (const RegisterInfo *reg_info, RegisterValue &reg_value)
 {
     Error error;
 
     if (!reg_info)
     {
         error.SetErrorString ("reg_info NULL");
         return error;
switch (reg_info->byte_size)
             assert(false && "Unhandled data size.");
             error.SetErrorStringWithFormat ("unhandled byte size: %" PRIu32, reg_info->byte_size);
             break;
     }
 
     return error;
 }
 
-lldb_private::Error
+Error
 NativeRegisterContextLinux_arm64::WriteRegister (const RegisterInfo *reg_info, const RegisterValue &reg_value)
 {
     if (!reg_info)
         return Error ("reg_info NULL");
 
     const uint32_t reg_index = reg_info->kinds[lldb::eRegisterKindLLDB];
     if (reg_index == LLDB_INVALID_REGNUM)
         return Error ("no lldb regnum for %s", reg_info && reg_info->name ? reg_info->name : "<unknown register>");
if (IsFPR(reg_index))
         }
 
         return Error ();
     }
 
     return Error ("failed - register wasn't recognized to be a GPR or an FPR, write strategy unknown");
 }
 
-lldb_private::Error
+Error
 NativeRegisterContextLinux_arm64::ReadAllRegisterValues (lldb::DataBufferSP &data_sp)
 {
     Error error;
 
-    data_sp.reset (new lldb_private::DataBufferHeap (REG_CONTEXT_SIZE, 0));
+    data_sp.reset (new DataBufferHeap (REG_CONTEXT_SIZE, 0));
     if (!data_sp)
         return Error ("failed to allocate DataBufferHeap instance of size %" PRIu64, REG_CONTEXT_SIZE);
 
     if (!ReadGPR ())
     {
         error.SetErrorString ("ReadGPR() failed");
         return error;
     }
NativeRegisterContextLinux_arm64::ReadAllRegisterValues (lldb::DataBufferSP &data_sp)
 
     ::memcpy (dst, &m_gpr_arm64, GetGPRSize());
     dst += GetGPRSize();
     ::memcpy (dst, &m_fpr, sizeof(m_fpr));
 
     return error;
 }
 
-lldb_private::Error
+Error
 NativeRegisterContextLinux_arm64::WriteAllRegisterValues (const lldb::DataBufferSP &data_sp)
 {
     Error error;
 
     if (!data_sp)
     {
         error.SetErrorStringWithFormat ("NativeRegisterContextLinux_x86_64::%s invalid data_sp provided", __FUNCTION__);
         return error;
NativeRegisterContextLinux_arm64::WriteAllRegisterValues (const lldb::DataBufferSP &data_sp)
     {
         error.SetErrorStringWithFormat ("NativeRegisterContextLinux_x86_64::%s WriteFPR() failed", __FUNCTION__);
         return error;
     }
 
     return error;
 }
 
-lldb_private::Error
+Error
 NativeRegisterContextLinux_arm64::WriteRegisterRaw (uint32_t reg_index, const RegisterValue &reg_value)
 {
     Error error;
 
     uint32_t reg_to_write = reg_index;
     RegisterValue value_to_write = reg_value;
 
     // Check if this is a subregister of a full register.
NativeRegisterContextLinux_arm64::WriteRegisterRaw (uint32_t reg_index, const RegisterValue &reg_value)
 
     NativeProcessLinux *const process_p = reinterpret_cast<NativeProcessLinux*> (process_sp.get ());
     return process_p->WriteRegisterValue(m_thread.GetID(),
                                          register_to_write_info_p->byte_offset,
                                          register_to_write_info_p->name,
                                          value_to_write);
 }
 
-lldb_private::Error
+Error
 NativeRegisterContextLinux_arm64::ReadRegisterRaw (uint32_t reg_index, RegisterValue &reg_value)
 {
     Error error;
     const RegisterInfo *const reg_info = GetRegisterInfoAtIndex (reg_index);
     if (!reg_info)
     {
         error.SetErrorStringWithFormat ("register %" PRIu32 " not found", reg_index);
         return error;

lldb/trunk/source/Plugins/Process/Linux/NativeRegisterContextLinux_mips64.h

 
 #ifndef lldb_NativeRegisterContextLinux_mips64_h
 #define lldb_NativeRegisterContextLinux_mips64_h
 
 #include "lldb/Host/common/NativeRegisterContextRegisterInfo.h"
 #include "Plugins/Process/Utility/RegisterContext_mips64.h"
 #include "Plugins/Process/Utility/RegisterContextLinux_mips64.h"
 
+
+namespace lldb_private {
+namespace process_linux {
+
+    class NativeProcessLinux;
+
     // ---------------------------------------------------------------------------
     // Internal codes for mips64 GP registers.
     // ---------------------------------------------------------------------------
     enum
     {
         k_first_gp_reg_mips64,
         gp_reg_r0_mips64 = k_first_gp_reg_mips64,
         gp_reg_r1_mips64,
         gp_reg_r2_mips64,
         gp_reg_r3_mips64,
         gp_reg_r4_mips64,
         gp_reg_r5_mips64,
         gp_reg_r6_mips64,
         gp_reg_r7_mips64,
         gp_reg_r8_mips64,
         gp_reg_r9_mips64,
         gp_reg_r10_mips64,
         gp_reg_r11_mips64,
         gp_reg_r12_mips64,
         gp_reg_r13_mips64,
         gp_reg_r14_mips64,
         gp_reg_r15_mips64,
         gp_reg_r16_mips64,
         gp_reg_r17_mips64,
         gp_reg_r18_mips64,
         gp_reg_r19_mips64,
         gp_reg_r20_mips64,
         gp_reg_r21_mips64,
         gp_reg_r22_mips64,
         gp_reg_r23_mips64,
         gp_reg_r24_mips64,
         gp_reg_r25_mips64,
         gp_reg_r26_mips64,
         gp_reg_r27_mips64,
         gp_reg_r28_mips64,
         gp_reg_r29_mips64,
         gp_reg_r30_mips64,
         gp_reg_r31_mips64,
         gp_reg_mullo_mips64,
         gp_reg_mulhi_mips64,
         gp_reg_pc_mips64,
         gp_reg_badvaddr_mips64,
         gp_reg_sr_mips64,
         gp_reg_cause_mips64,
         k_num_gp_reg_mips64,
     };
 
-namespace lldb_private
-{
-    class NativeProcessLinux;
-
     class NativeRegisterContextLinux_mips64 : public NativeRegisterContextRegisterInfo
     {
     public:
         NativeRegisterContextLinux_mips64 (NativeThreadProtocol &native_thread, 
             uint32_t concrete_frame_idx, RegisterInfoInterface *reg_info_interface_p);
 
         uint32_t
         GetRegisterSetCount () const override;
public:
                 uint32_t watch_flags) override;
 
         lldb::addr_t
         GetWatchpointAddress (uint32_t wp_index) override;
 
         uint32_t
         NumSupportedHardwareWatchpoints () override;
     };
-}
+
+} // namespace process_linux
+} // namespace lldb_private
 
 #endif // #ifndef lldb_NativeRegisterContextLinux_mips64_h
 

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

 #include "lldb/Core/DataBufferHeap.h"
 #include "lldb/Core/Error.h"
 #include "lldb/Core/RegisterValue.h"
 #include "lldb/Host/common/NativeProcessProtocol.h"
 #include "lldb/Host/common/NativeThreadProtocol.h"
 #include "Plugins/Process/Linux/NativeProcessLinux.h"
 
 using namespace lldb_private;
+using namespace lldb_private::process_linux;
 
 // ----------------------------------------------------------------------------
 // Private namespace.
 // ----------------------------------------------------------------------------
 
 namespace
 {
     // mips64 general purpose registers.

 }
 
 uint32_t
 NativeRegisterContextLinux_mips64::GetRegisterSetCount () const
 {
     return k_num_register_sets;
 }
 
-const lldb_private::RegisterSet *
+const RegisterSet *
 NativeRegisterContextLinux_mips64::GetRegisterSet (uint32_t set_index) const
 {
     if (set_index >= k_num_register_sets)
         return nullptr;
 
     switch (GetRegisterInfoInterface ().GetTargetArchitecture ().GetMachine ())
     {
         case llvm::Triple::mips64:
         case llvm::Triple::mips64el:
             return &g_reg_sets_mips64[set_index];
         default:
             assert (false && "Unhandled target architecture.");
             return nullptr;
     }
 
     return nullptr;
 }
 
-lldb_private::Error
+Error
 NativeRegisterContextLinux_mips64::ReadRegister (const RegisterInfo *reg_info, RegisterValue &reg_value)
 {
     Error error;
     error.SetErrorString ("MIPS TODO: NativeRegisterContextLinux_mips64::ReadRegister not implemented");
     return error;
 }
 
-lldb_private::Error
+Error
 NativeRegisterContextLinux_mips64::WriteRegister (const RegisterInfo *reg_info, const RegisterValue &reg_value)
 {
     Error error;
     error.SetErrorString ("MIPS TODO: NativeRegisterContextLinux_mips64::WriteRegister not implemented");
     return error;
 }
 
-lldb_private::Error
+Error
 NativeRegisterContextLinux_mips64::ReadAllRegisterValues (lldb::DataBufferSP &data_sp)
 {
     Error error;
     error.SetErrorString ("MIPS TODO: NativeRegisterContextLinux_mips64::ReadAllRegisterValues not implemented");
     return error;
 }
 
-lldb_private::Error
+Error
 NativeRegisterContextLinux_mips64::WriteAllRegisterValues (const lldb::DataBufferSP &data_sp)
 {
     Error error;
     error.SetErrorString ("MIPS TODO: NativeRegisterContextLinux_mips64::WriteAllRegisterValues not implemented");
     return error;
 }
 
 Error

lldb/trunk/source/Plugins/Process/Linux/NativeRegisterContextLinux_x86_64.h

 
 #ifndef lldb_NativeRegisterContextLinux_x86_64_h
 #define lldb_NativeRegisterContextLinux_x86_64_h
 
 #include "lldb/Host/common/NativeRegisterContextRegisterInfo.h"
 #include "Plugins/Process/Utility/RegisterContext_x86.h"
 #include "Plugins/Process/Utility/lldb-x86-register-enums.h"
 
-namespace lldb_private
-{
+namespace lldb_private {
+namespace process_linux {
+
     class NativeProcessLinux;
 
     class NativeRegisterContextLinux_x86_64 : public NativeRegisterContextRegisterInfo
     {
     public:
         NativeRegisterContextLinux_x86_64 (NativeThreadProtocol &native_thread, uint32_t concrete_frame_idx, RegisterInfoInterface *reg_info_interface_p);
 
         uint32_t
private:
         mutable FPRType m_fpr_type;
         FPR m_fpr;
         IOVEC m_iovec;
         YMM m_ymm_set;
         RegInfo m_reg_info;
         uint64_t m_gpr_x86_64[k_num_gpr_registers_x86_64];
 
         // Private member methods.
-        lldb_private::Error
+        Error
         WriteRegister(const uint32_t reg, const RegisterValue &value);
 
         bool IsRegisterSetAvailable (uint32_t set_index) const;
 
         lldb::ByteOrder
         GetByteOrder() const;
 
         bool
private:
         CopyYMMtoXSTATE(uint32_t reg, lldb::ByteOrder byte_order);
 
         bool
         IsAVX (uint32_t reg_index) const;
 
         bool
         ReadFPR ();
 
-        lldb_private::Error
+        Error
         ReadRegisterRaw (uint32_t reg_index, RegisterValue &reg_value);
 
         bool
         ReadGPR();
 
         bool
         WriteGPR();
     };
-}
+
+} // namespace process_linux
+} // namespace lldb_private
 
 #endif // #ifndef lldb_NativeRegisterContextLinux_x86_64_h
 

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

 #include "lldb/Core/DataBufferHeap.h"
 #include "lldb/Core/Error.h"
 #include "lldb/Core/RegisterValue.h"
 #include "lldb/Host/common/NativeProcessProtocol.h"
 #include "lldb/Host/common/NativeThreadProtocol.h"
 #include "Plugins/Process/Linux/NativeProcessLinux.h"
 
 using namespace lldb_private;
+using namespace lldb_private::process_linux;
 
 // ----------------------------------------------------------------------------
 // Private namespace.
 // ----------------------------------------------------------------------------
 
 namespace
 {
     // x86 32-bit general purpose registers.

 }
 
 uint32_t
 NativeRegisterContextLinux_x86_64::GetUserRegisterCount() const
 {
     uint32_t count = 0;
     for (uint32_t set_index = 0; set_index < k_num_register_sets; ++set_index)
     {
-        const lldb_private::RegisterSet* set = GetRegisterSet(set_index);
+        const RegisterSet* set = GetRegisterSet(set_index);
         if (set)
             count += set->num_registers;
     }
     return count;
 }
 
-const lldb_private::RegisterSet *
+const RegisterSet *
 NativeRegisterContextLinux_x86_64::GetRegisterSet (uint32_t set_index) const
 {
     if (!IsRegisterSetAvailable (set_index))
         return nullptr;
 
     switch (GetRegisterInfoInterface ().GetTargetArchitecture ().GetMachine ())
     {
         case llvm::Triple::x86:
             return &g_reg_sets_i386[set_index];
         case llvm::Triple::x86_64:
             return &g_reg_sets_x86_64[set_index];
         default:
             assert (false && "Unhandled target architecture.");
             return nullptr;
     }
 
     return nullptr;
 }
 
-lldb_private::Error
+Error
 NativeRegisterContextLinux_x86_64::ReadRegisterRaw (uint32_t reg_index, RegisterValue &reg_value)
 {
     Error error;
     const RegisterInfo *const reg_info = GetRegisterInfoAtIndex (reg_index);
     if (!reg_info)
     {
         error.SetErrorStringWithFormat ("register %" PRIu32 " not found", reg_index);
         return error;
NativeRegisterContextLinux_x86_64::ReadRegisterRaw (uint32_t reg_index, RegisterValue &reg_value)
     NativeProcessLinux *const process_p = reinterpret_cast<NativeProcessLinux*> (process_sp.get ());
     return process_p->ReadRegisterValue(m_thread.GetID(),
                                         reg_info->byte_offset,
                                         reg_info->name,
                                         reg_info->byte_size,
                                         reg_value);
 }
 
-lldb_private::Error
+Error
 NativeRegisterContextLinux_x86_64::ReadRegister (const RegisterInfo *reg_info, RegisterValue &reg_value)
 {
     Error error;
 
     if (!reg_info)
     {
         error.SetErrorString ("reg_info NULL");
         return error;
switch (reg_info->byte_size)
             assert(false && "Unhandled data size.");
             error.SetErrorStringWithFormat ("unhandled byte size: %" PRIu32, reg_info->byte_size);
             break;
     }
 
     return error;
 }
 
-lldb_private::Error
+Error
 NativeRegisterContextLinux_x86_64::WriteRegister(const uint32_t reg,
                                                  const RegisterValue &value)
 {
     Error error;
 
     uint32_t reg_to_write = reg;
     RegisterValue value_to_write = value;
 
NativeRegisterContextLinux_x86_64::WriteRegister(const uint32_t reg,
 
     NativeProcessLinux *const process_p = reinterpret_cast<NativeProcessLinux*> (process_sp.get ());
     return process_p->WriteRegisterValue(m_thread.GetID(),
                                          register_to_write_info_p->byte_offset,
                                          register_to_write_info_p->name,
                                          value_to_write);
 }
 
-lldb_private::Error
+Error
 NativeRegisterContextLinux_x86_64::WriteRegister (const RegisterInfo *reg_info, const RegisterValue &reg_value)
 {
     assert (reg_info && "reg_info is null");
 
     const uint32_t reg_index = reg_info->kinds[lldb::eRegisterKindLLDB];
     if (reg_index == LLDB_INVALID_REGNUM)
         return Error ("no lldb regnum for %s", reg_info && reg_info->name ? reg_info->name : "<unknown register>");
 
if (IsFPR(reg_index, GetFPRType()))
                     return Error ("CopyYMMtoXSTATE() failed");
             }
             return Error ();
         }
     }
     return Error ("failed - register wasn't recognized to be a GPR or an FPR, write strategy unknown");
 }
 
-lldb_private::Error
+Error
 NativeRegisterContextLinux_x86_64::ReadAllRegisterValues (lldb::DataBufferSP &data_sp)
 {
     Error error;
 
     data_sp.reset (new DataBufferHeap (REG_CONTEXT_SIZE, 0));
     if (!data_sp)
     {
         error.SetErrorStringWithFormat ("failed to allocate DataBufferHeap instance of size %" PRIu64, REG_CONTEXT_SIZE);
NativeRegisterContextLinux_x86_64::ReadAllRegisterValues (lldb::DataBufferSP &data_sp)
     {
         assert (false && "how do we save the floating point registers?");
         error.SetErrorString ("unsure how to save the floating point registers");
     }
 
     return error;
 }
 
-lldb_private::Error
+Error
 NativeRegisterContextLinux_x86_64::WriteAllRegisterValues (const lldb::DataBufferSP &data_sp)
 {
     Error error;
 
     if (!data_sp)
     {
         error.SetErrorStringWithFormat ("NativeRegisterContextLinux_x86_64::%s invalid data_sp provided", __FUNCTION__);
         return error;

lldb/trunk/source/Plugins/Process/Linux/NativeThreadLinux.h

 #define liblldb_NativeThreadLinux_H_
 
 #include "lldb/lldb-private-forward.h"
 #include "lldb/Host/common/NativeThreadProtocol.h"
 
 #include <map>
 #include <string>
 
-namespace lldb_private
-{
+namespace lldb_private {
+namespace process_linux {
+
     class NativeProcessLinux;
 
     class NativeThreadLinux : public NativeThreadProtocol
     {
         friend class NativeProcessLinux;
 
     public:
         NativeThreadLinux (NativeProcessLinux *process, lldb::tid_t tid);
private:
         // ---------------------------------------------------------------------
         lldb::StateType m_state;
         ThreadStopInfo m_stop_info;
         NativeRegisterContextSP m_reg_context_sp;
         std::string m_stop_description;
         using WatchpointIndexMap = std::map<lldb::addr_t, uint32_t>;
         WatchpointIndexMap m_watchpoint_index_map;
     };
-}
+
+} // namespace process_linux
+} // namespace lldb_private
 
 #endif // #ifndef liblldb_NativeThreadLinux_H_

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

 #include "Plugins/Process/Utility/RegisterContextLinux_arm64.h"
 #include "Plugins/Process/Utility/RegisterContextLinux_i386.h"
 #include "Plugins/Process/Utility/RegisterContextLinux_x86_64.h"
 #include "Plugins/Process/Utility/RegisterContextLinux_mips64.h"
 #include "Plugins/Process/Utility/RegisterInfoInterface.h"
 
 using namespace lldb;
 using namespace lldb_private;
+using namespace lldb_private::process_linux;
 
 namespace
 {
     void LogThreadStopInfo (Log &log, const ThreadStopInfo &stop_info, const char *const header)
     {
         switch (stop_info.reason)
         {
             case eStopReasonNone:
case eStateDetached:
             log->Printf ("NativeThreadLinux::%s tid %" PRIu64 " in state %s cannot answer stop reason",
                     __FUNCTION__, GetID (), StateAsCString (m_state));
         }
         return false;
     }
     llvm_unreachable("unhandled StateType!");
 }
 
-lldb_private::NativeRegisterContextSP
+NativeRegisterContextSP
 NativeThreadLinux::GetRegisterContext ()
 {
     // Return the register context if we already created it.
     if (m_reg_context_sp)
         return m_reg_context_sp;
 
     // First select the appropriate RegisterInfoInterface.
     RegisterInfoInterface *reg_interface = nullptr;

lldb/trunk/source/Plugins/Process/Linux/ProcFileReader.h

 #ifndef liblldb_ProcFileReader_h_
 #define liblldb_ProcFileReader_h_
 
 #include <functional>
 
 #include "lldb/lldb-forward.h"
 #include "lldb/lldb-types.h"
 
-namespace lldb_private
-{
+namespace lldb_private {
+namespace process_linux {
+
     class ProcFileReader
     {
     public:
 
         static lldb::DataBufferSP
         ReadIntoDataBuffer (lldb::pid_t pid, const char *name);
 
         /// Parse the /proc/{@a pid}/{@a name} file line by line, passing each line to line_parser, until
         /// either end of file or until line_parser returns false.
-        static lldb_private::Error
+        static Error
         ProcessLineByLine (lldb::pid_t pid, const char *name, std::function<bool (const std::string &line)> line_parser);
     };
-}
+
+} // namespace process_linux
+} // namespace lldb_private
 
 #endif // #ifndef liblldb_ProcFileReader_h_

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

 
 // C++ Headers
 #include <fstream>
 
 // LLDB Headers
 #include "lldb/Core/DataBufferHeap.h"
 #include "lldb/Core/Error.h"
 
+using namespace lldb_private;
+using namespace lldb_private::process_linux;
+
 lldb::DataBufferSP
-lldb_private::ProcFileReader::ReadIntoDataBuffer (lldb::pid_t pid, const char *name)
+ProcFileReader::ReadIntoDataBuffer (lldb::pid_t pid, const char *name)
 {
     int fd;
     char path[PATH_MAX];
 
     // Make sure we've got a nil terminated buffer for all the folks calling
     // GetBytes() directly off our returned DataBufferSP if we hit an error.
     lldb::DataBufferSP buf_sp (new DataBufferHeap(1, 0));
 
if (snprintf (path, PATH_MAX, "/proc/%" PRIu64 "/%s", pid, name) > 0)
             
             close (fd);
         }
     }
     
     return buf_sp;
 }
 
-lldb_private::Error
-lldb_private::ProcFileReader::ProcessLineByLine (lldb::pid_t pid, const char *name, std::function<bool (const std::string &line)> line_parser)
+Error
+ProcFileReader::ProcessLineByLine (lldb::pid_t pid, const char *name, std::function<bool (const std::string &line)> line_parser)
 {
-    lldb_private::Error error;
+    Error error;
 
     // Try to open the /proc/{pid}/maps entry.
     char filename [PATH_MAX];
     snprintf (filename, sizeof(filename), "/proc/%" PRIu64 "/%s", pid, name);
     filename[sizeof (filename) - 1] = '\0';
 
     std::ifstream proc_file (filename);
     if (proc_file.fail ())

lldb/trunk/source/Plugins/Process/Linux/ProcessLinux.h

 
 // Other libraries and framework includes
 #include "lldb/Target/Process.h"
 #include "Plugins/Process/POSIX/ProcessMessage.h"
 #include "Plugins/Process/POSIX/ProcessPOSIX.h"
 
 class ProcessMonitor;
 
-class ProcessLinux :
-    public ProcessPOSIX
+namespace lldb_private {
+namespace process_linux {
+
+class ProcessLinux : public ProcessPOSIX
 {
 public:
     //------------------------------------------------------------------
     // Static functions.
     //------------------------------------------------------------------
     static lldb::ProcessSP
-    CreateInstance(lldb_private::Target& target,
-                   lldb_private::Listener &listener,
-                   const lldb_private::FileSpec *);
+    CreateInstance(Target& target,
+                   Listener &listener,
+                   const FileSpec *);
 
     static void
     Initialize();
 
     static void
     Terminate();
 
-    static lldb_private::ConstString
+    static ConstString
     GetPluginNameStatic();
 
     static const char *
     GetPluginDescriptionStatic();
 
     //------------------------------------------------------------------
     // Constructors and destructors
     //------------------------------------------------------------------
-    ProcessLinux(lldb_private::Target& target,
-                 lldb_private::Listener &listener,
-                 lldb_private::FileSpec *core_file);
+    ProcessLinux(Target& target,
+                 Listener &listener,
+                 FileSpec *core_file);
 
-    lldb_private::Error
+    Error
     DoDetach(bool keep_stopped) override;
 
     bool
     DetachRequiresHalt() override { return true; }
 
     bool
-    UpdateThreadList(lldb_private::ThreadList &old_thread_list, lldb_private::ThreadList &new_thread_list) override;
+    UpdateThreadList(ThreadList &old_thread_list, ThreadList &new_thread_list) override;
 
     //------------------------------------------------------------------
     // PluginInterface protocol
     //------------------------------------------------------------------
-    lldb_private::ConstString
+    ConstString
     GetPluginName() override;
 
     uint32_t
     GetPluginVersion() override;
 
     virtual void
-    GetPluginCommandHelp(const char *command, lldb_private::Stream *strm);
+    GetPluginCommandHelp(const char *command, Stream *strm);
 
-    virtual lldb_private::Error
-    ExecutePluginCommand(lldb_private::Args &command,
-                         lldb_private::Stream *strm);
-
-    virtual lldb_private::Log *
-    EnablePluginLogging(lldb_private::Stream *strm,
-                        lldb_private::Args &command);
+    virtual Error
+    ExecutePluginCommand(Args &command,
+                         Stream *strm);
+
+    virtual Log *
+    EnablePluginLogging(Stream *strm,
+                        Args &command);
 
     bool
-    CanDebug(lldb_private::Target &target, bool plugin_specified_by_name) override;
+    CanDebug(Target &target, bool plugin_specified_by_name) override;
 
     //------------------------------------------------------------------
     // ProcessPOSIX overrides
     //------------------------------------------------------------------
     void
     StopAllThreads(lldb::tid_t stop_tid) override;
 
     POSIXThread *
-    CreateNewPOSIXThread(lldb_private::Process &process, lldb::tid_t tid) override;
+    CreateNewPOSIXThread(Process &process, lldb::tid_t tid) override;
 
 private:
 
-    lldb_private::FileSpec *m_core_file;
+    FileSpec *m_core_file;
 
     // Flag to avoid recursion when stopping all threads.
     bool m_stopping_threads;
 };
 
+} // namespace process_linux
+} // namespace lldb_private
+
 #endif  // liblldb_ProcessLinux_H_

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

 #include "Plugins/Process/POSIX/ProcessPOSIXLog.h"
 #include "Plugins/Process/Utility/InferiorCallPOSIX.h"
 #include "Plugins/Process/Utility/LinuxSignals.h"
 #include "ProcessMonitor.h"
 #include "LinuxThread.h"
 
 using namespace lldb;
 using namespace lldb_private;
+using namespace lldb_private::process_linux;
 
 namespace
 {
     UnixSignalsSP&
     GetStaticLinuxSignalsSP ()
     {
         static UnixSignalsSP s_unix_signals_sp (new process_linux::LinuxSignals ());
         return s_unix_signals_sp;
if (plugin_specified_by_name)
         return true;
 
     /* If core file is specified then let elf-core plugin handle it */
     if (m_core_file)
         return false;
 
     // If we're using llgs for local debugging, we must not say that this process
     // is used for debugging.
-    if (PlatformLinux::UseLlgsForLocalDebugging ())
+    if (platform_linux::PlatformLinux::UseLlgsForLocalDebugging ())
         return false;
 
     return ProcessPOSIX::CanDebug(target, plugin_specified_by_name);
 }
 

lldb/trunk/source/Plugins/Process/Linux/ProcessMonitor.h

 #include <signal.h>
 
 // C++ Includes
 // Other libraries and framework includes
 #include "lldb/lldb-types.h"
 #include "lldb/Host/HostThread.h"
 #include "lldb/Host/Mutex.h"
 
-namespace lldb_private
-{
+namespace lldb_private {
+
 class Error;
 class Module;
 class Scalar;
-} // End lldb_private namespace.
+
+namespace process_linux {
 
 class ProcessLinux;
+
+} // namespace process_linux
+
+} // namespace lldb_private
+
 class Operation;
 
 /// @class ProcessMonitor
 /// @brief Manages communication with the inferior (debugee) process.
 ///
 /// Upon construction, this class prepares and launches an inferior process for
 /// debugging.
 ///
enum ResumeSignals
         eResumeSignalNone = 0
     };
 
     /// Provides the process number of debugee.
     lldb::pid_t
     GetPID() const { return m_pid; }
 
     /// Returns the process associated with this ProcessMonitor.
-    ProcessLinux &
+    lldb_private::process_linux::ProcessLinux &
     GetProcess() { return *m_process; }
 
     /// Returns a file descriptor to the controlling terminal of the inferior
     /// process.
     ///
     /// Reads from this file descriptor yield both the standard output and
     /// standard error of this debugee.  Even if stderr and stdout were
     /// redirected on launch it may still happen that data is available on this
public:
     bool
     StopThread(lldb::tid_t tid);
 
     // Waits for the initial stop message from a new thread.
     bool
     WaitForInitialTIDStop(lldb::tid_t tid);
 
 private:
-    ProcessLinux *m_process;
+    lldb_private::process_linux::ProcessLinux *m_process;
 
     lldb_private::HostThread m_operation_thread;
     lldb_private::HostThread m_monitor_thread;
     lldb::pid_t m_pid;
     int m_terminal_fd;
 
     // current operation which must be executed on the priviliged thread
     Operation *m_operation;

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

 #endif
 
 // Try to define a macro to encapsulate the tgkill syscall
 // fall back on kill() if tgkill isn't available
 #define tgkill(pid, tid, sig) \
     syscall(SYS_tgkill, static_cast<::pid_t>(pid), static_cast<::pid_t>(tid), sig)
 
 using namespace lldb_private;
+using namespace lldb_private::process_linux;
 
 static Operation* EXIT_OPERATION = nullptr;
 
 // FIXME: this code is host-dependent with respect to types and
 // endianness and needs to be fixed.  For example, lldb::addr_t is
 // hard-coded to uint64_t, but on a 32-bit Linux host, ptrace requires
 // 32-bit pointer arguments.  This code uses casts to work around the
 // problem.

lldb/trunk/source/Plugins/Process/Linux/ThreadStateCoordinator.h

 #include <queue>
 #include <unordered_map>
 #include <unordered_set>
 
 #include "lldb/lldb-types.h"
 
 #include "lldb/Core/Error.h"
 
-namespace lldb_private
-{
+namespace lldb_private {
+namespace process_linux {
+
     class ThreadStateCoordinator
     {
     public:
 
         // Typedefs.
         typedef std::unordered_set<lldb::tid_t> ThreadIDSet;
 
         enum EventLoopResult
private:
 
         EventBaseSP m_pending_notification_sp;
 
         // Maps known TIDs to ThreadContext.
         TIDContextMap m_tid_map;
 
         bool m_log_event_processing;
     };
-}
+
+} // namespace process_linux
+} // namespace lldb_private
 
 #endif

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

 #include <inttypes.h>
 
 #include "ThreadStateCoordinator.h"
 #include <memory>
 #include <cstdarg>
 #include <sstream>
 
 using namespace lldb_private;
+using namespace lldb_private::process_linux;
 
 //===----------------------------------------------------------------------===//
 
 class ThreadStateCoordinator::EventBase : public std::enable_shared_from_this<ThreadStateCoordinator::EventBase>
 {
 public:
     EventBase ()
     {

lldb/trunk/source/Plugins/Process/Utility/LinuxSignals.h

 #define liblldb_LinuxSignals_H_
 
 // C Includes
 // C++ Includes
 // Other libraries and framework includes
 // Project includes
 #include "lldb/Target/UnixSignals.h"
 
-namespace process_linux
-{
+namespace lldb_private {
+namespace process_linux {
 
     /// Linux specific set of Unix signals.
     class LinuxSignals
         : public lldb_private::UnixSignals
     {
     public:
         LinuxSignals();
 
     private:
         void
         Reset();
     };
-}
+
+} // namespace lldb_private
+} // namespace process_linux
 
 #endif

lldb/trunk/source/Plugins/Process/Utility/LinuxSignals.cpp

 //===-- LinuxSignals.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
 // Other libraries and framework includes
 // Project includes
 #include "LinuxSignals.h"
 
-using namespace process_linux;
+using namespace lldb_private::process_linux;
 
 LinuxSignals::LinuxSignals()
     : UnixSignals()
 {
     Reset();
 }
 
 void

lldb/trunk/source/Plugins/Process/Utility/RegisterContextLinux_mips64.cpp

 
 // For GDB, GCC and DWARF Register numbers
 #include "RegisterContextLinux_mips64.h"
 
 // Internal codes for all mips64 registers
 #include "Plugins/Process/Linux/NativeRegisterContextLinux_mips64.h"
 #include "RegisterContext_mips64.h"
 
-using namespace lldb_private;
 using namespace lldb;
+using namespace lldb_private;
+using namespace lldb_private::process_linux;
 
 // GP registers
 typedef struct _GPR
 {
     uint64_t    gp_reg[32];
     uint64_t    mul_lo;
     uint64_t    mul_hi;
     uint64_t    cp0_epc;

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

 #include "lldb/Core/Listener.h"
 #include "lldb/Host/HostThread.h"
 #include "lldb/Host/Mutex.h"
 #include "lldb/Host/Predicate.h"
 #include "lldb/Host/TimeValue.h"
 
 #include "Utility/StringExtractorGDBRemote.h"
 
+namespace lldb_private {
+namespace process_gdb_remote {
+
 typedef enum
 {
     eStoppointInvalid = -1,
     eBreakpointSoftware = 0,
     eBreakpointHardware,
     eWatchpointWrite,
     eWatchpointRead,
     eWatchpointReadWrite
 } GDBStoppointType;
 
 class ProcessGDBRemote;
 
-class GDBRemoteCommunication : public lldb_private::Communication
+class GDBRemoteCommunication : public Communication
 {
 public:
     enum
     {
         eBroadcastBitRunPacketSent = kLoUserBroadcastBit
     };
     
     enum class PacketResult
public:
     size_t
     SendNack ();
 
     char
     CalculcateChecksum (const char *payload,
                         size_t payload_length);
 
     bool
-    GetSequenceMutex (lldb_private::Mutex::Locker& locker, const char *failure_message = NULL);
+    GetSequenceMutex (Mutex::Locker& locker, const char *failure_message = NULL);
 
     bool
     CheckForPacket (const uint8_t *src, 
                     size_t src_len, 
                     StringExtractorGDBRemote &packet);
     bool
     IsRunning() const
     {
SetPacketTimeout (uint32_t packet_timeout)
         const uint32_t old_packet_timeout = m_packet_timeout;
         m_packet_timeout = packet_timeout;
         return old_packet_timeout;
     }
 
     uint32_t
     GetPacketTimeoutInMicroSeconds () const
     {
-        return m_packet_timeout * lldb_private::TimeValue::MicroSecPerSec;
+        return m_packet_timeout * TimeValue::MicroSecPerSec;
     }
     //------------------------------------------------------------------
     // Start a debugserver instance on the current host using the
     // supplied connection URL.
     //------------------------------------------------------------------
-    lldb_private::Error
+    Error
     StartDebugserverProcess (const char *hostname,
                              uint16_t in_port, // If set to zero, then out_port will contain the bound port on exit
-                             lldb_private::ProcessLaunchInfo &launch_info,
+                             ProcessLaunchInfo &launch_info,
                              uint16_t &out_port);
 
     void
-    DumpHistory(lldb_private::Stream &strm);
+    DumpHistory(Stream &strm);
     
 protected:
 
     class History
     {
     public:
         enum PacketType
         {
public:
                    uint32_t bytes_transmitted);
         void
         AddPacket (const std::string &src,
                    uint32_t src_len,
                    PacketType type,
                    uint32_t bytes_transmitted);
         
         void
-        Dump (lldb_private::Stream &strm) const;
+        Dump (Stream &strm) const;
 
         void
-        Dump (lldb_private::Log *log) const;
+        Dump (Log *log) const;
 
         bool
         DidDumpToLog () const
         {
             return m_dumped_to_log;
         }
     
 protected:
protected:
     SendPacketNoLock (const char *payload, 
                       size_t payload_length);
 
     PacketResult
     WaitForPacketWithTimeoutMicroSecondsNoLock (StringExtractorGDBRemote &response, 
                                                 uint32_t timeout_usec);
 
     bool
-    WaitForNotRunningPrivate (const lldb_private::TimeValue *timeout_ptr);
+    WaitForNotRunningPrivate (const TimeValue *timeout_ptr);
 
     //------------------------------------------------------------------
     // Classes that inherit from GDBRemoteCommunication can see and modify these
     //------------------------------------------------------------------
     uint32_t m_packet_timeout;
 #ifdef ENABLE_MUTEX_ERROR_CHECKING
-    lldb_private::TrackingMutex m_sequence_mutex;
+    TrackingMutex m_sequence_mutex;
 #else
-    lldb_private::Mutex m_sequence_mutex;    // Restrict access to sending/receiving packets to a single thread at a time
+    Mutex m_sequence_mutex;    // Restrict access to sending/receiving packets to a single thread at a time
 #endif
-    lldb_private::Predicate<bool> m_public_is_running;
-    lldb_private::Predicate<bool> m_private_is_running;
+    Predicate<bool> m_public_is_running;
+    Predicate<bool> m_private_is_running;
     History m_history;
     bool m_send_acks;
     bool m_is_platform; // Set to true if this class represents a platform,
                         // false if this class represents a debug session for
                         // a single process
     
 
-    lldb_private::Error
-    StartListenThread (const char *hostname = "127.0.0.1",
-                       uint16_t port = 0);
+    Error
+    StartListenThread (const char *hostname = "127.0.0.1", uint16_t port = 0);
 
     bool
     JoinListenThread ();
 
     static lldb::thread_result_t
     ListenThread (lldb::thread_arg_t arg);
 
 private:
-    lldb_private::HostThread m_listen_thread;
+    HostThread m_listen_thread;
     std::string m_listen_url;
 
     //------------------------------------------------------------------
     // For GDBRemoteCommunication only
     //------------------------------------------------------------------
     DISALLOW_COPY_AND_ASSIGN (GDBRemoteCommunication);
 };
 
+} // namespace process_gdb_remote
+} // namespace lldb_private
+
 #endif  // liblldb_GDBRemoteCommunication_h_

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

 #if defined(__APPLE__)
 # define DEBUGSERVER_BASENAME    "debugserver"
 #else
 # define DEBUGSERVER_BASENAME    "lldb-server"
 #endif
 
 using namespace lldb;
 using namespace lldb_private;
+using namespace lldb_private::process_gdb_remote;
 
 GDBRemoteCommunication::History::History (uint32_t size) :
     m_packets(),
     m_curr_idx (0),
     m_total_packet_count (0),
     m_dumped_to_log (false)
 {
     m_packets.resize(size);
if (size > 0)
         m_packets[idx].type = type;
         m_packets[idx].bytes_transmitted = bytes_transmitted;
         m_packets[idx].packet_idx = m_total_packet_count;
         m_packets[idx].tid = Host::GetCurrentThreadID();
     }
 }
 
 void
-GDBRemoteCommunication::History::Dump (lldb_private::Stream &strm) const
+GDBRemoteCommunication::History::Dump (Stream &strm) const
 {
     const uint32_t size = GetNumPacketsInHistory ();
     const uint32_t first_idx = GetFirstSavedPacketIndex ();
     const uint32_t stop_idx = m_curr_idx + size;
     for (uint32_t i = first_idx;  i < stop_idx; ++i)
     {
         const uint32_t idx = NormalizeIndex (i);
         const Entry &entry = m_packets[idx];
         if (entry.type == ePacketTypeInvalid || entry.packet.empty())
             break;
         strm.Printf ("history[%u] tid=0x%4.4" PRIx64 " <%4u> %s packet: %s\n",
                      entry.packet_idx,
                      entry.tid,
                      entry.bytes_transmitted,
                      (entry.type == ePacketTypeSend) ? "send" : "read",
                      entry.packet.c_str());
     }
 }
 
 void
-GDBRemoteCommunication::History::Dump (lldb_private::Log *log) const
+GDBRemoteCommunication::History::Dump (Log *log) const
 {
     if (log && !m_dumped_to_log)
     {
         m_dumped_to_log = true;
         const uint32_t size = GetNumPacketsInHistory ();
         const uint32_t first_idx = GetFirstSavedPacketIndex ();
         const uint32_t stop_idx = m_curr_idx + size;
         for (uint32_t i = first_idx;  i < stop_idx; ++i)
if (connection)
             comm->SetConnection(NULL);
     }
     return NULL;
 }
 
 Error
 GDBRemoteCommunication::StartDebugserverProcess (const char *hostname,
                                                  uint16_t in_port,
-                                                 lldb_private::ProcessLaunchInfo &launch_info,
+                                                 ProcessLaunchInfo &launch_info,
                                                  uint16_t &out_port)
 {
     Log *log (ProcessGDBRemoteLog::GetLogIfAllCategoriesSet (GDBR_LOG_PROCESS));
     if (log)
         log->Printf ("GDBRemoteCommunication::%s(hostname=%s, in_port=%" PRIu16 ", out_port=%" PRIu16, __FUNCTION__, hostname ? hostname : "<empty>", in_port, out_port);
 
     out_port = in_port;
     Error error;

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

 
 // Other libraries and framework includes
 // Project includes
 #include "lldb/Core/ArchSpec.h"
 #include "lldb/Target/Process.h"
 
 #include "GDBRemoteCommunication.h"
 
+namespace lldb_private {
+namespace process_gdb_remote {
+
 class GDBRemoteCommunicationClient : public GDBRemoteCommunication
 {
 public:
     //------------------------------------------------------------------
     // Constructors and Destructors
     //------------------------------------------------------------------
     GDBRemoteCommunicationClient();
 
     ~GDBRemoteCommunicationClient();
 
     //------------------------------------------------------------------
     // After connecting, send the handshake to the server to make sure
     // we are communicating with it.
     //------------------------------------------------------------------
     bool
-    HandshakeWithServer (lldb_private::Error *error_ptr);
+    HandshakeWithServer (Error *error_ptr);
 
     PacketResult
     SendPacketAndWaitForResponse (const char *send_payload,
                                   StringExtractorGDBRemote &response,
                                   bool send_async);
 
     PacketResult
     SendPacketAndWaitForResponse (const char *send_payload,
public:
 
     void
     GetListThreadsInStopReplySupported ();
 
     bool
     SendAsyncSignal (int signo);
 
     bool
-    SendInterrupt (lldb_private::Mutex::Locker &locker, 
+    SendInterrupt (Mutex::Locker &locker, 
                    uint32_t seconds_to_wait_for_stop, 
                    bool &timed_out);
 
     lldb::pid_t
     GetCurrentProcessID (bool allow_lazy = true);
 
     bool
     GetLaunchSuccess (std::string &error_str);
public:
     ///
     /// @return
     ///     Zero if the response was "OK", a positive value if the
     ///     the response was "Exx" where xx are two hex digits, or
     ///     -1 if the call is unsupported or any other unexpected
     ///     response was received.
     //------------------------------------------------------------------
     int
-    SendArgumentsPacket (const lldb_private::ProcessLaunchInfo &launch_info);
+    SendArgumentsPacket (const ProcessLaunchInfo &launch_info);
 
     //------------------------------------------------------------------
     /// Sends a "QEnvironment:NAME=VALUE" packet that will build up the
     /// environment that will get used when launching an application
     /// in conjunction with the 'A' packet. This function can be called
     /// multiple times in a row in order to pass on the desired
     /// environment that the inferior should be launched with.
     ///
public:
     GetWorkingDir (std::string &cwd);
 
     lldb::addr_t
     AllocateMemory (size_t size, uint32_t permissions);
 
     bool
     DeallocateMemory (lldb::addr_t addr);
 
-    lldb_private::Error
+    Error
     Detach (bool keep_stopped);
 
-    lldb_private::Error
-    GetMemoryRegionInfo (lldb::addr_t addr, 
-                        lldb_private::MemoryRegionInfo &range_info); 
+    Error
+    GetMemoryRegionInfo (lldb::addr_t addr, MemoryRegionInfo &range_info); 
 
-    lldb_private::Error
+    Error
     GetWatchpointSupportInfo (uint32_t &num); 
 
-    lldb_private::Error
+    Error
     GetWatchpointSupportInfo (uint32_t &num, bool& after);
     
-    lldb_private::Error
+    Error
     GetWatchpointsTriggerAfterInstruction (bool &after);
 
-    const lldb_private::ArchSpec &
+    const ArchSpec &
     GetHostArchitecture ();
     
     uint32_t
     GetHostDefaultPacketTimeout();
 
-    const lldb_private::ArchSpec &
+    const ArchSpec &
     GetProcessArchitecture ();
 
     void
     GetRemoteQSupported();
 
     bool
     GetVContSupported (char flavor);
 
GetOSVersion (uint32_t &major,
                   uint32_t &update);
 
     bool
     GetOSBuildString (std::string &s);
     
     bool
     GetOSKernelDescription (std::string &s);
 
-    lldb_private::ArchSpec
+    ArchSpec
     GetSystemArchitecture ();
 
     bool
     GetHostname (std::string &s);
 
     lldb::addr_t
     GetShlibInfoAddr();
 
     bool
     GetSupportsThreadSuffix ();
 
     bool
-    GetProcessInfo (lldb::pid_t pid, 
-                    lldb_private::ProcessInstanceInfo &process_info);
+    GetProcessInfo (lldb::pid_t pid, ProcessInstanceInfo &process_info);
 
     uint32_t
-    FindProcesses (const lldb_private::ProcessInstanceInfoMatch &process_match_info,
-                   lldb_private::ProcessInstanceInfoList &process_infos);
+    FindProcesses (const ProcessInstanceInfoMatch &process_match_info,
+                   ProcessInstanceInfoList &process_infos);
 
     bool
     GetUserName (uint32_t uid, std::string &name);
     
     bool
     GetGroupName (uint32_t gid, std::string &name);
 
     bool
public:
     GetQXferLibrariesSVR4ReadSupported ();
 
     uint64_t
     GetRemoteMaxPacketSize();
 
     bool
     GetAugmentedLibrariesSVR4ReadSupported ();
 
-    lldb_private::LazyBool
+    LazyBool
     SupportsAllocDeallocMemory () // const
     {
         // Uncomment this to have lldb pretend the debug server doesn't respond to alloc/dealloc memory packets.
         // m_supports_alloc_dealloc_memory = lldb_private::eLazyBoolNo;
         return m_supports_alloc_dealloc_memory;
     }
 
     size_t
     GetCurrentThreadIDs (std::vector<lldb::tid_t> &thread_ids,
                          bool &sequence_mutex_unavailable);
     
     bool
     GetInterruptWasSent () const
     {
         return m_interrupt_sent;
     }
     
     lldb::user_id_t
-    OpenFile (const lldb_private::FileSpec& file_spec,
-              uint32_t flags,
-              mode_t mode,
-              lldb_private::Error &error);
+    OpenFile (const FileSpec& file_spec, uint32_t flags, mode_t mode, Error &error);
     
     bool
-    CloseFile (lldb::user_id_t fd,
-               lldb_private::Error &error);
+    CloseFile (lldb::user_id_t fd, Error &error);
     
     lldb::user_id_t
-    GetFileSize (const lldb_private::FileSpec& file_spec);
+    GetFileSize (const FileSpec& file_spec);
     
-    lldb_private::Error
+    Error
     GetFilePermissions(const char *path, uint32_t &file_permissions);
 
-    lldb_private::Error
+    Error
     SetFilePermissions(const char *path, uint32_t file_permissions);
 
     uint64_t
     ReadFile (lldb::user_id_t fd,
               uint64_t offset,
               void *dst,
               uint64_t dst_len,
-              lldb_private::Error &error);
+              Error &error);
     
     uint64_t
     WriteFile (lldb::user_id_t fd,
                uint64_t offset,
                const void* src,
                uint64_t src_len,
-               lldb_private::Error &error);
+               Error &error);
     
-    lldb_private::Error
+    Error
     CreateSymlink (const char *src,
                    const char *dst);
     
-    lldb_private::Error
+    Error
     Unlink (const char *path);
 
-    lldb_private::Error
-    MakeDirectory (const char *path,
-                   uint32_t mode);
+    Error
+    MakeDirectory (const char *path, uint32_t mode);
     
     bool
-    GetFileExists (const lldb_private::FileSpec& file_spec);
+    GetFileExists (const FileSpec& file_spec);
     
-    lldb_private::Error
+    Error
     RunShellCommand (const char *command,           // Shouldn't be NULL
                      const char *working_dir,       // Pass NULL to use the current working directory
                      int *status_ptr,               // Pass NULL if you don't want the process exit status
                      int *signo_ptr,                // Pass NULL if you don't want the signal that caused the process to exit
                      std::string *command_output,   // Pass NULL if you don't want the command output
                      uint32_t timeout_sec);         // Timeout in seconds to wait for shell program to finish
     
     bool
-    CalculateMD5 (const lldb_private::FileSpec& file_spec,
-                  uint64_t &high,
-                  uint64_t &low);
+    CalculateMD5 (const FileSpec& file_spec, uint64_t &high, uint64_t &low);
     
     std::string
     HarmonizeThreadIdsForProfileData (ProcessGDBRemote *process,
                                       StringExtractorGDBRemote &inputStringExtractor);
 
     bool
     ReadRegister(lldb::tid_t tid,
                  uint32_t reg_num,
public:
 
     bool
     AvoidGPackets(ProcessGDBRemote *process);
 
     bool
     GetThreadExtendedInfoSupported();
 
     bool
-    GetModuleInfo (const lldb_private::FileSpec& module_file_spec,
-                   const lldb_private::ArchSpec& arch_spec,
-                   lldb_private::ModuleSpec &module_spec);
+    GetModuleInfo (const FileSpec& module_file_spec,
+                   const ArchSpec& arch_spec,
+                   ModuleSpec &module_spec);
 
 protected:
 
     PacketResult
     SendPacketAndWaitForResponseNoLock (const char *payload,
                                         size_t payload_length,
                                         StringExtractorGDBRemote &response);
 
     bool
     GetCurrentProcessInfo (bool allow_lazy_pid = true);
 
     bool
     GetGDBServerVersion();
 
     //------------------------------------------------------------------
     // Classes that inherit from GDBRemoteCommunicationClient can see and modify these
     //------------------------------------------------------------------
-    lldb_private::LazyBool m_supports_not_sending_acks;
-    lldb_private::LazyBool m_supports_thread_suffix;
-    lldb_private::LazyBool m_supports_threads_in_stop_reply;
-    lldb_private::LazyBool m_supports_vCont_all;
-    lldb_private::LazyBool m_supports_vCont_any;
-    lldb_private::LazyBool m_supports_vCont_c;
-    lldb_private::LazyBool m_supports_vCont_C;
-    lldb_private::LazyBool m_supports_vCont_s;
-    lldb_private::LazyBool m_supports_vCont_S;
-    lldb_private::LazyBool m_qHostInfo_is_valid;
-    lldb_private::LazyBool m_curr_pid_is_valid;
-    lldb_private::LazyBool m_qProcessInfo_is_valid;
-    lldb_private::LazyBool m_qGDBServerVersion_is_valid;
-    lldb_private::LazyBool m_supports_alloc_dealloc_memory;
-    lldb_private::LazyBool m_supports_memory_region_info;
-    lldb_private::LazyBool m_supports_watchpoint_support_info;
-    lldb_private::LazyBool m_supports_detach_stay_stopped;
-    lldb_private::LazyBool m_watchpoints_trigger_after_instruction;
-    lldb_private::LazyBool m_attach_or_wait_reply;
-    lldb_private::LazyBool m_prepare_for_reg_writing_reply;
-    lldb_private::LazyBool m_supports_p;
-    lldb_private::LazyBool m_supports_x;
-    lldb_private::LazyBool m_avoid_g_packets;
-    lldb_private::LazyBool m_supports_QSaveRegisterState;
-    lldb_private::LazyBool m_supports_qXfer_auxv_read;
-    lldb_private::LazyBool m_supports_qXfer_libraries_read;
-    lldb_private::LazyBool m_supports_qXfer_libraries_svr4_read;
-    lldb_private::LazyBool m_supports_augmented_libraries_svr4_read;
-    lldb_private::LazyBool m_supports_jThreadExtendedInfo;
+    LazyBool m_supports_not_sending_acks;
+    LazyBool m_supports_thread_suffix;
+    LazyBool m_supports_threads_in_stop_reply;
+    LazyBool m_supports_vCont_all;
+    LazyBool m_supports_vCont_any;
+    LazyBool m_supports_vCont_c;
+    LazyBool m_supports_vCont_C;
+    LazyBool m_supports_vCont_s;
+    LazyBool m_supports_vCont_S;
+    LazyBool m_qHostInfo_is_valid;
+    LazyBool m_curr_pid_is_valid;
+    LazyBool m_qProcessInfo_is_valid;
+    LazyBool m_qGDBServerVersion_is_valid;
+    LazyBool m_supports_alloc_dealloc_memory;
+    LazyBool m_supports_memory_region_info;
+    LazyBool m_supports_watchpoint_support_info;
+    LazyBool m_supports_detach_stay_stopped;
+    LazyBool m_watchpoints_trigger_after_instruction;
+    LazyBool m_attach_or_wait_reply;
+    LazyBool m_prepare_for_reg_writing_reply;
+    LazyBool m_supports_p;
+    LazyBool m_supports_x;
+    LazyBool m_avoid_g_packets;
+    LazyBool m_supports_QSaveRegisterState;
+    LazyBool m_supports_qXfer_auxv_read;
+    LazyBool m_supports_qXfer_libraries_read;
+    LazyBool m_supports_qXfer_libraries_svr4_read;
+    LazyBool m_supports_augmented_libraries_svr4_read;
+    LazyBool m_supports_jThreadExtendedInfo;
 
     bool
         m_supports_qProcessInfoPID:1,
         m_supports_qfProcessInfo:1,
         m_supports_qUserName:1,
         m_supports_qGroupName:1,
         m_supports_qThreadStopInfo:1,
         m_supports_z0:1,
         m_supports_z1:1,
         m_supports_z2:1,
         m_supports_z3:1,
         m_supports_z4:1,
         m_supports_QEnvironment:1,
         m_supports_QEnvironmentHexEncoded:1;
     
     lldb::pid_t m_curr_pid;
     lldb::tid_t m_curr_tid;         // Current gdb remote protocol thread index for all other operations
     lldb::tid_t m_curr_tid_run;     // Current gdb remote protocol thread index for continue, step, etc
 
 
     uint32_t m_num_supported_hardware_watchpoints;
 
     // If we need to send a packet while the target is running, the m_async_XXX
     // member variables take care of making this happen.
-    lldb_private::Mutex m_async_mutex;
-    lldb_private::Predicate<bool> m_async_packet_predicate;
+    Mutex m_async_mutex;
+    Predicate<bool> m_async_packet_predicate;
     std::string m_async_packet;
     PacketResult m_async_result;
     StringExtractorGDBRemote m_async_response;
     int m_async_signal; // We were asked to deliver a signal to the inferior process.
     bool m_interrupt_sent;
     std::string m_partial_profile_data;
     std::map<uint64_t, uint32_t> m_thread_id_to_used_usec_map;
     
-    lldb_private::ArchSpec m_host_arch;
-    lldb_private::ArchSpec m_process_arch;
+    ArchSpec m_host_arch;
+    ArchSpec m_process_arch;
     uint32_t m_os_version_major;
     uint32_t m_os_version_minor;
     uint32_t m_os_version_update;
     std::string m_os_build;
     std::string m_os_kernel;
     std::string m_hostname;
     std::string m_gdb_server_name; // from reply to qGDBServerVersion, empty if qGDBServerVersion is not supported
     uint32_t m_gdb_server_version; // from reply to qGDBServerVersion, zero if qGDBServerVersion is not supported
     uint32_t m_default_packet_timeout;
     uint64_t m_max_packet_size;  // as returned by qSupported
     
     bool
     DecodeProcessInfoResponse (StringExtractorGDBRemote &response, 
-                               lldb_private::ProcessInstanceInfo &process_info);
+                               ProcessInstanceInfo &process_info);
 private:
     //------------------------------------------------------------------
     // For GDBRemoteCommunicationClient only
     //------------------------------------------------------------------
     DISALLOW_COPY_AND_ASSIGN (GDBRemoteCommunicationClient);
 };
 
+} // namespace process_gdb_remote
+} // namespace lldb_private
+
 #endif  // liblldb_GDBRemoteCommunicationClient_h_

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

 // Project includes
 #include "Utility/StringExtractorGDBRemote.h"
 #include "ProcessGDBRemote.h"
 #include "ProcessGDBRemoteLog.h"
 #include "lldb/Host/Config.h"
 
 using namespace lldb;
 using namespace lldb_private;
+using namespace lldb_private::process_gdb_remote;
 
 #if defined(LLDB_DISABLE_POSIX) && !defined(SIGSTOP)
 #define SIGSTOP 17
 #endif
 
 //----------------------------------------------------------------------
 // GDBRemoteCommunicationClient constructor
 //----------------------------------------------------------------------

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

 #include <functional>
 #include <map>
 
 // Other libraries and framework includes
 // Project includes
 #include "lldb/lldb-private-forward.h"
 #include "GDBRemoteCommunication.h"
 
-class ProcessGDBRemote;
 class StringExtractorGDBRemote;
 
-class GDBRemoteCommunicationServer :
-    public GDBRemoteCommunication
+namespace lldb_private {
+namespace process_gdb_remote {
+
+class ProcessGDBRemote;
+
+class GDBRemoteCommunicationServer : public GDBRemoteCommunication
 {
 public:
     using PortMap = std::map<uint16_t, lldb::pid_t>;
     using PacketHandler = std::function<PacketResult(StringExtractorGDBRemote &packet,
-                                                     lldb_private::Error &error,
+                                                     Error &error,
                                                      bool &interrupt,
                                                      bool &quit)>;
 
     GDBRemoteCommunicationServer(const char *comm_name,
                                  const char *listener_name);
 
     virtual
     ~GDBRemoteCommunicationServer();
 
     void RegisterPacketHandler(StringExtractorGDBRemote::ServerPacketType packet_type,
                                PacketHandler handler);
 
     PacketResult
     GetPacketAndSendResponse (uint32_t timeout_usec,
-                              lldb_private::Error &error,
+                              Error &error,
                               bool &interrupt, 
                               bool &quit);
 
     // After connecting, do a little handshake with the client to make sure
     // we are at least communicating
     bool
-    HandshakeWithClient (lldb_private::Error *error_ptr);
+    HandshakeWithClient (Error *error_ptr);
 
 protected:
     std::map<StringExtractorGDBRemote::ServerPacketType, PacketHandler> m_packet_handlers;
     bool m_exit_now; // use in asynchronous handling to indicate process should exit.
 
     PacketResult
     SendUnimplementedResponse (const char *packet);
 
     PacketResult
     SendErrorResponse (uint8_t error);
 
     PacketResult
     SendIllFormedResponse (const StringExtractorGDBRemote &packet, const char *error_message);
 
     PacketResult
     SendOKResponse ();
 
 private:
     //------------------------------------------------------------------
     // For GDBRemoteCommunicationServer only
     //------------------------------------------------------------------
     DISALLOW_COPY_AND_ASSIGN (GDBRemoteCommunicationServer);
 };
 
+} // namespace process_gdb_remote
+} // namespace lldb_private
+
 #endif  // liblldb_GDBRemoteCommunicationServer_h_

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

 #include <cstring>
 
 // Project includes
 #include "ProcessGDBRemoteLog.h"
 #include "Utility/StringExtractorGDBRemote.h"
 
 using namespace lldb;
 using namespace lldb_private;
+using namespace lldb_private::process_gdb_remote;
 
 GDBRemoteCommunicationServer::GDBRemoteCommunicationServer(const char *comm_name,
                                                            const char *listener_name) :
     GDBRemoteCommunication (comm_name, listener_name),
     m_exit_now (false)
 {
 }
 

lldb/trunk/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerCommon.h

 #include "lldb/lldb-private-forward.h"
 #include "lldb/Host/Mutex.h"
 #include "lldb/Target/Process.h"
 
 // Project includes
 #include "GDBRemoteCommunicationServer.h"
 #include "GDBRemoteCommunicationServerCommon.h"
 
-class ProcessGDBRemote;
 class StringExtractorGDBRemote;
 
+namespace lldb_private {
+namespace process_gdb_remote {
+
+class ProcessGDBRemote;
+
 class GDBRemoteCommunicationServerCommon :
     public GDBRemoteCommunicationServer
 {
 public:
     GDBRemoteCommunicationServerCommon(const char *comm_name, const char *listener_name);
 
     virtual
     ~GDBRemoteCommunicationServerCommon();
 
 protected:
     std::set<lldb::pid_t> m_spawned_pids;
-    lldb_private::Mutex m_spawned_pids_mutex;
-    lldb_private::ProcessLaunchInfo m_process_launch_info;
-    lldb_private::Error m_process_launch_error;
-    lldb_private::ProcessInstanceInfoList m_proc_infos;
+    Mutex m_spawned_pids_mutex;
+    ProcessLaunchInfo m_process_launch_info;
+    Error m_process_launch_error;
+    ProcessInstanceInfoList m_proc_infos;
     uint32_t m_proc_infos_index;
     bool m_thread_suffix_supported;
     bool m_list_threads_in_stop_reply;
 
     PacketResult
     Handle_A (StringExtractorGDBRemote &packet);
 
     PacketResult
protected:
 
     PacketResult
     Handle_QLaunchArch (StringExtractorGDBRemote &packet);
 
     bool
     KillSpawnedProcess (lldb::pid_t pid);
 
     static void
-    CreateProcessInfoResponse (const lldb_private::ProcessInstanceInfo &proc_info,
-                               lldb_private::StreamString &response);
+    CreateProcessInfoResponse (const ProcessInstanceInfo &proc_info,
+                               StreamString &response);
 
     static void
-    CreateProcessInfoResponse_DebugServerStyle (const lldb_private::ProcessInstanceInfo &proc_info,
-                                                lldb_private::StreamString &response);
+    CreateProcessInfoResponse_DebugServerStyle (const ProcessInstanceInfo &proc_info,
+                                                StreamString &response);
 
     template <typename T>
     void
     RegisterMemberFunctionHandler (StringExtractorGDBRemote::ServerPacketType packet_type,
                                    PacketResult (T::*handler) (StringExtractorGDBRemote& packet))
     {
         RegisterPacketHandler(packet_type,
                               [this, handler] (StringExtractorGDBRemote packet,
-                                               lldb_private::Error &error,
+                                               Error &error,
                                                bool &interrupt,
                                                bool &quit)
                               {
                                   return (static_cast<T*>(this)->*handler) (packet);
                               });
     }
 
     bool
     GetThreadSuffixSupported () override
     {
         return true;
     }
 
     //------------------------------------------------------------------
     /// Launch a process with the current launch settings.
     ///
     /// This method supports running an lldb-gdbserver or similar
     /// server in a situation where the startup code has been provided
     /// with all the information for a child process to be launched.
     ///
     /// @return
     ///     An Error object indicating the success or failure of the
     ///     launch.
     //------------------------------------------------------------------
-    virtual lldb_private::Error
+    virtual Error
     LaunchProcess () = 0;
 
-    virtual lldb_private::FileSpec
-    FindModuleFile (const std::string& module_path, const lldb_private::ArchSpec& arch);
+    virtual FileSpec
+    FindModuleFile (const std::string& module_path, const ArchSpec& arch);
 };
 
+} // namespace process_gdb_remote
+} // namespace lldb_private
+
 #endif  // liblldb_GDBRemoteCommunicationServerCommon_h_

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

 #include "Utility/StringExtractorGDBRemote.h"
 
 #ifdef __ANDROID__
 #include "lldb/Host/android/HostInfoAndroid.h"
 #endif
 
 using namespace lldb;
 using namespace lldb_private;
+using namespace lldb_private::process_gdb_remote;
 
 #ifdef __ANDROID__
     const static uint32_t g_default_packet_timeout_sec = 20; // seconds
 #else
     const static uint32_t g_default_packet_timeout_sec = 0; // not specified
 #endif
 
 //----------------------------------------------------------------------

lldb/trunk/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.h

 #include "lldb/lldb-private-forward.h"
 #include "lldb/Core/Communication.h"
 #include "lldb/Host/Mutex.h"
 #include "lldb/Host/common/NativeProcessProtocol.h"
 
 // Project includes
 #include "GDBRemoteCommunicationServerCommon.h"
 
-class ProcessGDBRemote;
 class StringExtractorGDBRemote;
 
+namespace lldb_private {
+namespace process_gdb_remote {
+
+class ProcessGDBRemote;
+
 class GDBRemoteCommunicationServerLLGS :
     public GDBRemoteCommunicationServerCommon,
-    public lldb_private::NativeProcessProtocol::NativeDelegate
+    public NativeProcessProtocol::NativeDelegate
 {
 public:
     //------------------------------------------------------------------
     // Constructors and Destructors
     //------------------------------------------------------------------
     GDBRemoteCommunicationServerLLGS(const lldb::PlatformSP& platform_sp,
                       lldb::DebuggerSP& debugger_sp);
 
     virtual
     ~GDBRemoteCommunicationServerLLGS();
 
     //------------------------------------------------------------------
     /// Specify the program to launch and its arguments.
     ///
     /// @param[in] args
     ///     The command line to launch.
     ///
     /// @param[in] argc
     ///     The number of elements in the args array of cstring pointers.
     ///
     /// @return
     ///     An Error object indicating the success or failure of making
     ///     the setting.
     //------------------------------------------------------------------
-    lldb_private::Error
+    Error
     SetLaunchArguments (const char *const args[], int argc);
 
     //------------------------------------------------------------------
     /// Specify the launch flags for the process.
     ///
     /// @param[in] launch_flags
     ///     The launch flags to use when launching this process.
     ///
     /// @return
     ///     An Error object indicating the success or failure of making
     ///     the setting.
     //------------------------------------------------------------------
-    lldb_private::Error
+    Error
     SetLaunchFlags (unsigned int launch_flags);
 
     //------------------------------------------------------------------
     /// Launch a process with the current launch settings.
     ///
     /// This method supports running an lldb-gdbserver or similar
     /// server in a situation where the startup code has been provided
     /// with all the information for a child process to be launched.
     ///
     /// @return
     ///     An Error object indicating the success or failure of the
     ///     launch.
     //------------------------------------------------------------------
-    lldb_private::Error
+    Error
     LaunchProcess () override;
 
     //------------------------------------------------------------------
     /// Attach to a process.
     ///
     /// This method supports attaching llgs to a process accessible via the
     /// configured Platform.
     ///
     /// @return
     ///     An Error object indicating the success or failure of the
     ///     attach operation.
     //------------------------------------------------------------------
-    lldb_private::Error
+    Error
     AttachToProcess (lldb::pid_t pid);
 
     //------------------------------------------------------------------
     // NativeProcessProtocol::NativeDelegate overrides
     //------------------------------------------------------------------
     void
-    InitializeDelegate (lldb_private::NativeProcessProtocol *process) override;
+    InitializeDelegate (NativeProcessProtocol *process) override;
 
     void
-    ProcessStateChanged (lldb_private::NativeProcessProtocol *process, lldb::StateType state) override;
+    ProcessStateChanged (NativeProcessProtocol *process, lldb::StateType state) override;
 
     void
-    DidExec (lldb_private::NativeProcessProtocol *process) override;
+    DidExec (NativeProcessProtocol *process) override;
 
 protected:
     lldb::PlatformSP m_platform_sp;
     lldb::thread_t m_async_thread;
     lldb::tid_t m_current_tid;
     lldb::tid_t m_continue_tid;
-    lldb_private::Mutex m_debugged_process_mutex;
-    lldb_private::NativeProcessProtocolSP m_debugged_process_sp;
+    Mutex m_debugged_process_mutex;
+    NativeProcessProtocolSP m_debugged_process_sp;
     lldb::DebuggerSP m_debugger_sp;
     Communication m_stdio_communication;
     lldb::StateType m_inferior_prev_state;
     lldb::DataBufferSP m_active_auxv_buffer_sp;
-    lldb_private::Mutex m_saved_registers_mutex;
+    Mutex m_saved_registers_mutex;
     std::unordered_map<uint32_t, lldb::DataBufferSP> m_saved_registers_map;
     uint32_t m_next_saved_registers_id;
 
     PacketResult
     SendONotification (const char *buffer, uint32_t len);
 
     PacketResult
-    SendWResponse (lldb_private::NativeProcessProtocol *process);
+    SendWResponse (NativeProcessProtocol *process);
 
     PacketResult
     SendStopReplyPacketForThread (lldb::tid_t tid);
 
     PacketResult
     SendStopReasonForState (lldb::StateType process_state, bool flush_on_exit);
 
     PacketResult
protected:
     GetCurrentThreadID () const;
 
     void
     SetContinueThreadID (lldb::tid_t tid);
 
     lldb::tid_t
     GetContinueThreadID () const { return m_continue_tid; }
 
-    lldb_private::Error
+    Error
     SetSTDIOFileDescriptor (int fd);
 
     static void
     STDIOReadThreadBytesReceived (void *baton, const void *src, size_t src_len);
 
-    lldb_private::FileSpec
-    FindModuleFile (const std::string& module_path, const lldb_private::ArchSpec& arch) override;
+    FileSpec
+    FindModuleFile (const std::string& module_path, const ArchSpec& arch) override;
 
 private:
     bool
     DebuggedProcessReaped (lldb::pid_t pid);
 
     static bool
     ReapDebuggedProcess (void *callback_baton,
                          lldb::pid_t pid,
                          bool exited,
                          int signal,
                          int status);
 
     void
-    HandleInferiorState_Exited (lldb_private::NativeProcessProtocol *process);
+    HandleInferiorState_Exited (NativeProcessProtocol *process);
 
     void
-    HandleInferiorState_Stopped (lldb_private::NativeProcessProtocol *process);
+    HandleInferiorState_Stopped (NativeProcessProtocol *process);
 
     void
     FlushInferiorOutput ();
 
-    lldb_private::NativeThreadProtocolSP
+    NativeThreadProtocolSP
     GetThreadFromSuffix (StringExtractorGDBRemote &packet);
 
     uint32_t
     GetNextSavedRegistersID ();
 
     void
     MaybeCloseInferiorTerminalConnection ();
 
     void
     ClearProcessSpecificData ();
 
     void
     RegisterPacketHandlers ();
 
     //------------------------------------------------------------------
     // For GDBRemoteCommunicationServerLLGS only
     //------------------------------------------------------------------
     DISALLOW_COPY_AND_ASSIGN (GDBRemoteCommunicationServerLLGS);
 };
 
+} // namespace process_gdb_remote
+} // namespace lldb_private
+
 #endif  // liblldb_GDBRemoteCommunicationServerLLGS_h_

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

 // Project includes
 #include "Utility/StringExtractorGDBRemote.h"
 #include "Utility/UriParser.h"
 #include "ProcessGDBRemote.h"
 #include "ProcessGDBRemoteLog.h"
 
 using namespace lldb;
 using namespace lldb_private;
+using namespace lldb_private::process_gdb_remote;
 
 //----------------------------------------------------------------------
 // GDBRemote Errors
 //----------------------------------------------------------------------
 
 namespace
 {
     enum GDBRemoteServerError
RegisterPacketHandler(StringExtractorGDBRemote::eServerPacketType_k,
                                  bool &interrupt,
                                  bool &quit)
                           {
                               quit = true;
                               return this->Handle_k (packet);
                           });
 }
 
-lldb_private::Error
+Error
 GDBRemoteCommunicationServerLLGS::SetLaunchArguments (const char *const args[], int argc)
 {
     if ((argc < 1) || !args || !args[0] || !args[0][0])
-        return lldb_private::Error ("%s: no process command line specified to launch", __FUNCTION__);
+        return Error ("%s: no process command line specified to launch", __FUNCTION__);
 
     m_process_launch_info.SetArguments (const_cast<const char**> (args), true);
-    return lldb_private::Error ();
+    return Error ();
 }
 
-lldb_private::Error
+Error
 GDBRemoteCommunicationServerLLGS::SetLaunchFlags (unsigned int launch_flags)
 {
     m_process_launch_info.GetFlags ().Set (launch_flags);
-    return lldb_private::Error ();
+    return Error ();
 }
 
-lldb_private::Error
+Error
 GDBRemoteCommunicationServerLLGS::LaunchProcess ()
 {
     Log *log (GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS));
 
     if (!m_process_launch_info.GetArguments ().GetArgumentCount ())
-        return lldb_private::Error ("%s: no process command line specified to launch", __FUNCTION__);
+        return Error ("%s: no process command line specified to launch", __FUNCTION__);
 
-    lldb_private::Error error;
+    Error error;
     {
         Mutex::Locker locker (m_debugged_process_mutex);
         assert (!m_debugged_process_sp && "lldb-gdbserver creating debugged process but one already exists");
         error = m_platform_sp->LaunchNativeProcess (
             m_process_launch_info,
             *this,
             m_debugged_process_sp);
     }
if ((pid = m_process_launch_info.GetProcessID ()) != LLDB_INVALID_PROCESS_ID)
         // On an lldb-gdbserver, we would expect there to be only one.
         assert (m_spawned_pids.empty () && "lldb-gdbserver adding tracked process but one already existed");
         m_spawned_pids.insert (pid);
     }
 
     return error;
 }
 
-lldb_private::Error
+Error
 GDBRemoteCommunicationServerLLGS::AttachToProcess (lldb::pid_t pid)
 {
     Error error;
 
     Log *log (GetLogIfAnyCategoriesSet (LIBLLDB_LOG_PROCESS));
     if (log)
         log->Printf ("GDBRemoteCommunicationServerLLGS::%s pid %" PRIu64, __FUNCTION__, pid);
 
// Scope for mutex locker.
         assert (m_spawned_pids.empty () && "lldb-gdbserver adding tracked process but one already existed");
         m_spawned_pids.insert (pid);
 
         return error;
     }
 }
 
 void
-GDBRemoteCommunicationServerLLGS::InitializeDelegate (lldb_private::NativeProcessProtocol *process)
+GDBRemoteCommunicationServerLLGS::InitializeDelegate (NativeProcessProtocol *process)
 {
     assert (process && "process cannot be NULL");
     Log *log (GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS));
     if (log)
     {
         log->Printf ("GDBRemoteCommunicationServerLLGS::%s called with NativeProcessProtocol pid %" PRIu64 ", current state: %s",
                 __FUNCTION__,
                 process->GetID (),
                 StateAsCString (process->GetState ()));
     }
 }
 
 GDBRemoteCommunication::PacketResult
-GDBRemoteCommunicationServerLLGS::SendWResponse (lldb_private::NativeProcessProtocol *process)
+GDBRemoteCommunicationServerLLGS::SendWResponse (NativeProcessProtocol *process)
 {
     assert (process && "process cannot be NULL");
     Log *log (GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS));
 
     // send W notification
     ExitType exit_type = ExitType::eExitTypeInvalid;
     int return_code = 0;
     std::string exit_description;
else if ((tid_stop_info.reason == eStopReasonException) && tid_stop_info.details.exception.type)
             response.PutChar (';');
         }
     }
 
     return SendPacketNoLock (response.GetData(), response.GetSize());
 }
 
 void
-GDBRemoteCommunicationServerLLGS::HandleInferiorState_Exited (lldb_private::NativeProcessProtocol *process)
+GDBRemoteCommunicationServerLLGS::HandleInferiorState_Exited (NativeProcessProtocol *process)
 {
     assert (process && "process cannot be NULL");
 
     Log *log (GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS));
     if (log)
         log->Printf ("GDBRemoteCommunicationServerLLGS::%s called", __FUNCTION__);
 
     // Send the exit result, and don't flush output.
#endif
     // can avoid that scenario altogether.
     MaybeCloseInferiorTerminalConnection ();
 
     // We are ready to exit the debug monitor.
     m_exit_now = true;
 }
 
 void
-GDBRemoteCommunicationServerLLGS::HandleInferiorState_Stopped (lldb_private::NativeProcessProtocol *process)
+GDBRemoteCommunicationServerLLGS::HandleInferiorState_Stopped (NativeProcessProtocol *process)
 {
     assert (process && "process cannot be NULL");
 
     Log *log (GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS));
     if (log)
         log->Printf ("GDBRemoteCommunicationServerLLGS::%s called", __FUNCTION__);
 
     // Send the stop reason unless this is the stop after the
switch (m_inferior_prev_state)
                 if (log)
                     log->Printf ("GDBRemoteCommunicationServerLLGS::%s failed to send stop notification for PID %" PRIu64 ", state: eStateExited", __FUNCTION__, process->GetID ());
             }
             break;
     }
 }
 
 void
-GDBRemoteCommunicationServerLLGS::ProcessStateChanged (lldb_private::NativeProcessProtocol *process, lldb::StateType state)
+GDBRemoteCommunicationServerLLGS::ProcessStateChanged (NativeProcessProtocol *process, lldb::StateType state)
 {
     assert (process && "process cannot be NULL");
     Log *log (GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS));
     if (log)
     {
         log->Printf ("GDBRemoteCommunicationServerLLGS::%s called with NativeProcessProtocol pid %" PRIu64 ", state: %s",
                 __FUNCTION__,
                 process->GetID (),
GDBRemoteCommunicationServerLLGS::SendONotification (const char *buffer, uint32_t len)
 
     StreamString response;
     response.PutChar ('O');
     response.PutBytesAsRawHex8 (buffer, len);
 
     return SendPacketNoLock (response.GetData (), response.GetSize ());
 }
 
-lldb_private::Error
+Error
 GDBRemoteCommunicationServerLLGS::SetSTDIOFileDescriptor (int fd)
 {
     Error error;
 
     // Set up the Read Thread for reading/handling process I/O
     std::unique_ptr<ConnectionFileDescriptor> conn_up (new ConnectionFileDescriptor (fd, true));
     if (!conn_up)
     {
GDBRemoteCommunicationServerLLGS::Handle_C (StringExtractorGDBRemote &packet)
     {
         // FIXME add continue at address support for $C{signo}[;{continue-address}].
         if (*packet.Peek () == ';')
             return SendUnimplementedResponse (packet.GetStringRef().c_str());
         else
             return SendIllFormedResponse (packet, "unexpected content after $C{signal-number}");
     }
 
-    lldb_private::ResumeActionList resume_actions (StateType::eStateRunning, 0);
+    ResumeActionList resume_actions (StateType::eStateRunning, 0);
     Error error;
 
     // We have two branches: what to do if a continue thread is specified (in which case we target
     // sending the signal to that thread), or when we don't have a continue thread set (in which
     // case we send a signal to the process).
 
     // TODO discuss with Greg Clayton, make sure this makes sense.
 
     lldb::tid_t signal_tid = GetContinueThreadID ();
     if (signal_tid != LLDB_INVALID_THREAD_ID)
     {
         // The resume action for the continue thread (or all threads if a continue thread is not set).
-        lldb_private::ResumeAction action = { GetContinueThreadID (), StateType::eStateRunning, static_cast<int> (signo) };
+        ResumeAction action = { GetContinueThreadID (), StateType::eStateRunning, static_cast<int> (signo) };
 
         // Add the action for the continue thread (or all threads when the continue thread isn't present).
         resume_actions.Append (action);
     }
     else
     {
         // Send the signal to the process since we weren't targeting a specific continue thread with the signal.
         error = m_debugged_process_sp->Signal (signo);
GDBRemoteCommunicationServerLLGS::Handle_c (StringExtractorGDBRemote &packet)
     if (!m_debugged_process_sp)
     {
         if (log)
             log->Printf ("GDBRemoteCommunicationServerLLGS::%s no debugged process shared pointer", __FUNCTION__);
         return SendErrorResponse (0x36);
     }
 
     // Build the ResumeActionList
-    lldb_private::ResumeActionList actions (StateType::eStateRunning, 0);
+    ResumeActionList actions (StateType::eStateRunning, 0);
 
     Error error = m_debugged_process_sp->Resume (actions);
     if (error.Fail ())
     {
         if (log)
         {
             log->Printf ("GDBRemoteCommunicationServerLLGS::%s c failed for process %" PRIu64 ": %s",
                          __FUNCTION__,
GDBRemoteCommunicationServerLLGS::Handle_m (StringExtractorGDBRemote &packet)
     // Allocate the response buffer.
     std::string buf(byte_count, '\0');
     if (buf.empty())
         return SendErrorResponse (0x78);
 
 
     // Retrieve the process memory.
     lldb::addr_t bytes_read = 0;
-    lldb_private::Error error = m_debugged_process_sp->ReadMemory (read_addr, &buf[0], byte_count, bytes_read);
+    Error error = m_debugged_process_sp->ReadMemory (read_addr, &buf[0], byte_count, bytes_read);
     if (error.Fail ())
     {
         if (log)
             log->Printf ("GDBRemoteCommunicationServerLLGS::%s pid %" PRIu64 " mem 0x%" PRIx64 ": failed to read. Error: %s", __FUNCTION__, m_debugged_process_sp->GetID (), read_addr, error.AsCString ());
         return SendErrorResponse (0x08);
     }
 
     if (bytes_read == 0)
GDBRemoteCommunicationServerLLGS::Handle_M (StringExtractorGDBRemote &packet)
     {
         if (log)
             log->Printf ("GDBRemoteCommunicationServerLLGS::%s pid %" PRIu64 " mem 0x%" PRIx64 ": asked to write %" PRIu64 " bytes, but only found %" PRIu64 " to convert.", __FUNCTION__, m_debugged_process_sp->GetID (), write_addr, byte_count, convert_count);
         return SendIllFormedResponse (packet, "M content byte length specified did not match hex-encoded content length");
     }
 
     // Write the process memory.
     lldb::addr_t bytes_written = 0;
-    lldb_private::Error error = m_debugged_process_sp->WriteMemory (write_addr, &buf[0], byte_count, bytes_written);
+    Error error = m_debugged_process_sp->WriteMemory (write_addr, &buf[0], byte_count, bytes_written);
     if (error.Fail ())
     {
         if (log)
             log->Printf ("GDBRemoteCommunicationServerLLGS::%s pid %" PRIu64 " mem 0x%" PRIx64 ": failed to write. Error: %s", __FUNCTION__, m_debugged_process_sp->GetID (), write_addr, error.AsCString ());
         return SendErrorResponse (0x09);
     }
 
     if (bytes_written == 0)
GDBRemoteCommunicationServerLLGS::Handle_s (StringExtractorGDBRemote &packet)
 
     // Double check that we have such a thread.
     // TODO investigate: on MacOSX we might need to do an UpdateThreads () here.
     NativeThreadProtocolSP thread_sp = m_debugged_process_sp->GetThreadByID (tid);
     if (!thread_sp || thread_sp->GetID () != tid)
         return SendErrorResponse (0x33);
 
     // Create the step action for the given thread.
-    lldb_private::ResumeAction action = { tid, eStateStepping, 0 };
+    ResumeAction action = { tid, eStateStepping, 0 };
 
     // Setup the actions list.
-    lldb_private::ResumeActionList actions;
+    ResumeActionList actions;
     actions.Append (action);
 
     // All other threads stop while we're single stepping a thread.
     actions.SetDefaultThreadActionIfNeeded(eStateStopped, 0);
     Error error = m_debugged_process_sp->Resume (actions);
     if (error.Fail ())
     {
         if (log)
if (m_stdio_communication.IsConnected())
                 if (log)
                     log->Printf ("GDBRemoteCommunicationServerLLGS::%s disconnect process terminal stdio - FAIL: %s", __FUNCTION__, error.AsCString ());
             }
         }
     }
 }
 
 
-lldb_private::NativeThreadProtocolSP
+NativeThreadProtocolSP
 GDBRemoteCommunicationServerLLGS::GetThreadFromSuffix (StringExtractorGDBRemote &packet)
 {
     NativeThreadProtocolSP thread_sp;
 
     // We have no thread if we don't have a process.
     if (!m_debugged_process_sp || m_debugged_process_sp->GetID () == LLDB_INVALID_PROCESS_ID)
         return thread_sp;
 

lldb/trunk/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerPlatform.h

 //===-- GDBRemoteCommunicationServerPlatform.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_GDBRemoteCommunicationServerPlatform_h_
 #define liblldb_GDBRemoteCommunicationServerPlatform_h_
 
 #include "GDBRemoteCommunicationServerCommon.h"
 
+namespace lldb_private {
+namespace process_gdb_remote {
+
 class GDBRemoteCommunicationServerPlatform :
     public GDBRemoteCommunicationServerCommon
 {
 public:
     typedef std::map<uint16_t, lldb::pid_t> PortMap;
 
     GDBRemoteCommunicationServerPlatform();
 
     virtual
     ~GDBRemoteCommunicationServerPlatform();
 
-    lldb_private::Error
+    Error
     LaunchProcess () override;
 
     // Set both ports to zero to let the platform automatically bind to 
     // a port chosen by the OS.
     void
     SetPortMap (PortMap &&port_map);
 
     //----------------------------------------------------------------------
ReapDebugserverProcess (void *callback_baton,
                             int status);
 
     //------------------------------------------------------------------
     // For GDBRemoteCommunicationServerPlatform only
     //------------------------------------------------------------------
     DISALLOW_COPY_AND_ASSIGN (GDBRemoteCommunicationServerPlatform);
 };
 
+} // namespace process_gdb_remote
+} // namespace lldb_private
+
 #endif  // liblldb_GDBRemoteCommunicationServerPlatform_h_

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

 #include "lldb/Target/Process.h"
 
 // Project includes
 #include "Utility/StringExtractorGDBRemote.h"
 #include "Utility/UriParser.h"
 
 using namespace lldb;
 using namespace lldb_private;
+using namespace lldb_private::process_gdb_remote;
 
 //----------------------------------------------------------------------
 // GDBRemoteCommunicationServerPlatform constructor
 //----------------------------------------------------------------------
 GDBRemoteCommunicationServerPlatform::GDBRemoteCommunicationServerPlatform() :
     GDBRemoteCommunicationServerCommon ("gdb-remote.server", "gdb-remote.server.rx_packet"),
     m_platform_sp (Platform::GetHostPlatform ()),
     m_port_map (),
GDBRemoteCommunicationServerPlatform::ReapDebugserverProcess (void *callback_baton,
                                                    int signal,    // Zero for no signal
                                                    int status)    // Exit value of process if signal is zero
 {
     GDBRemoteCommunicationServerPlatform *server = (GDBRemoteCommunicationServerPlatform *)callback_baton;
     server->DebugserverProcessReaped (pid);
     return true;
 }
 
-lldb_private::Error
+Error
 GDBRemoteCommunicationServerPlatform::LaunchProcess ()
 {
     if (!m_process_launch_info.GetArguments ().GetArgumentCount ())
-        return lldb_private::Error ("%s: no process command line specified to launch", __FUNCTION__);
+        return Error ("%s: no process command line specified to launch", __FUNCTION__);
 
     // specify the process monitor if not already set.  This should
     // generally be what happens since we need to reap started
     // processes.
     if (!m_process_launch_info.GetMonitorProcessCallback ())
         m_process_launch_info.SetMonitorProcessCallback(ReapDebugserverProcess, this, false);
 
-    lldb_private::Error error = m_platform_sp->LaunchProcess (m_process_launch_info);
+    Error error = m_platform_sp->LaunchProcess (m_process_launch_info);
     if (!error.Success ())
     {
         fprintf (stderr, "%s: failed to launch executable %s", __FUNCTION__, m_process_launch_info.GetArguments ().GetArgumentAtIndex (0));
         return error;
     }
 
     printf ("Launched '%s' as process %" PRIu64 "...\n", m_process_launch_info.GetArguments ().GetArgumentAtIndex (0), m_process_launch_info.GetProcessID());
 

lldb/trunk/source/Plugins/Process/gdb-remote/GDBRemoteRegisterContext.h

 #include "lldb/lldb-enumerations.h"
 #include "lldb/Core/ConstString.h"
 #include "lldb/Core/DataExtractor.h"
 #include "lldb/Target/RegisterContext.h"
 #include "Plugins/Process/Utility/DynamicRegisterInfo.h"
 
 #include "GDBRemoteCommunicationClient.h"
 
+class StringExtractor;
+
+namespace lldb_private {
+namespace process_gdb_remote {
+
 class ThreadGDBRemote;
 class ProcessGDBRemote;
-class StringExtractor;
 
 class GDBRemoteDynamicRegisterInfo :
     public DynamicRegisterInfo
 {
 public:
     GDBRemoteDynamicRegisterInfo () :
         DynamicRegisterInfo()
     {
     }
 
     ~GDBRemoteDynamicRegisterInfo ()
     {
     }
 
     void
     HardcodeARMRegisters(bool from_scratch);
 
 };
 
-class GDBRemoteRegisterContext : public lldb_private::RegisterContext
+class GDBRemoteRegisterContext : public RegisterContext
 {
 public:
     //------------------------------------------------------------------
     // Constructors and Destructors
     //------------------------------------------------------------------
     GDBRemoteRegisterContext (ThreadGDBRemote &thread,
                               uint32_t concrete_frame_idx,
                               GDBRemoteDynamicRegisterInfo &reg_info,
                               bool read_all_at_once);
 
     virtual
     ~GDBRemoteRegisterContext ();
 
     //------------------------------------------------------------------
     // Subclasses must override these functions
     //------------------------------------------------------------------
     void
     InvalidateAllRegisters () override;
 
     size_t
     GetRegisterCount () override;
 
-    const lldb_private::RegisterInfo *
+    const RegisterInfo *
     GetRegisterInfoAtIndex (size_t reg) override;
 
     size_t
     GetRegisterSetCount () override;
 
-    const lldb_private::RegisterSet *
+    const RegisterSet *
     GetRegisterSet (size_t reg_set) override;
 
     bool
-    ReadRegister (const lldb_private::RegisterInfo *reg_info, lldb_private::RegisterValue &value) override;
+    ReadRegister (const RegisterInfo *reg_info, RegisterValue &value) override;
 
     bool
-    WriteRegister (const lldb_private::RegisterInfo *reg_info, const lldb_private::RegisterValue &value) override;
+    WriteRegister (const RegisterInfo *reg_info, const RegisterValue &value) override;
     
     bool
     ReadAllRegisterValues (lldb::DataBufferSP &data_sp) override;
 
     bool
     WriteAllRegisterValues (const lldb::DataBufferSP &data_sp) override;
 
     bool
-    ReadAllRegisterValues (lldb_private::RegisterCheckpoint &reg_checkpoint) override;
+    ReadAllRegisterValues (RegisterCheckpoint &reg_checkpoint) override;
 
     bool
-    WriteAllRegisterValues (const lldb_private::RegisterCheckpoint &reg_checkpoint) override;
+    WriteAllRegisterValues (const RegisterCheckpoint &reg_checkpoint) override;
 
     uint32_t
     ConvertRegisterKindToRegisterNumber (lldb::RegisterKind kind, uint32_t num) override;
 
 protected:
     friend class ThreadGDBRemote;
 
     bool
-    ReadRegisterBytes (const lldb_private::RegisterInfo *reg_info,
-                       lldb_private::DataExtractor &data);
+    ReadRegisterBytes (const RegisterInfo *reg_info,
+                       DataExtractor &data);
 
     bool
-    WriteRegisterBytes (const lldb_private::RegisterInfo *reg_info,
-                        lldb_private::DataExtractor &data, 
+    WriteRegisterBytes (const RegisterInfo *reg_info,
+                        DataExtractor &data, 
                         uint32_t data_offset);
 
     bool
     PrivateSetRegisterValue (uint32_t reg, StringExtractor &response);
     
     void
     SetAllRegisterValid (bool b);
 
     bool
     GetRegisterIsValid (uint32_t reg) const
     {
 #if defined (LLDB_CONFIGURATION_DEBUG)
         assert (reg < m_reg_valid.size());
 #endif
         if (reg < m_reg_valid.size())
             return m_reg_valid[reg];
         return false;
     }
 
     void
-    SetRegisterIsValid (const lldb_private::RegisterInfo *reg_info, bool valid)
+    SetRegisterIsValid (const RegisterInfo *reg_info, bool valid)
     {
         if (reg_info)
             return SetRegisterIsValid (reg_info->kinds[lldb::eRegisterKindLLDB], valid);
     }
 
     void
     SetRegisterIsValid (uint32_t reg, bool valid)
     {
 #if defined (LLDB_CONFIGURATION_DEBUG)
         assert (reg < m_reg_valid.size());
 #endif
         if (reg < m_reg_valid.size())
             m_reg_valid[reg] = valid;
     }
 
     void
-    SyncThreadState(lldb_private::Process *process);  // Assumes the sequence mutex has already been acquired.
+    SyncThreadState(Process *process);  // Assumes the sequence mutex has already been acquired.
     
     GDBRemoteDynamicRegisterInfo &m_reg_info;
     std::vector<bool> m_reg_valid;
-    lldb_private::DataExtractor m_reg_data;
+    DataExtractor m_reg_data;
     bool m_read_all_at_once;
 
 private:
     // Helper function for ReadRegisterBytes().
-    bool GetPrimordialRegister(const lldb_private::RegisterInfo *reg_info,
+    bool GetPrimordialRegister(const RegisterInfo *reg_info,
                                GDBRemoteCommunicationClient &gdb_comm);
     // Helper function for WriteRegisterBytes().
-    bool SetPrimordialRegister(const lldb_private::RegisterInfo *reg_info,
+    bool SetPrimordialRegister(const RegisterInfo *reg_info,
                                GDBRemoteCommunicationClient &gdb_comm);
 
     //------------------------------------------------------------------
     // For GDBRemoteRegisterContext only
     //------------------------------------------------------------------
     DISALLOW_COPY_AND_ASSIGN (GDBRemoteRegisterContext);
 };
 
+} // namespace process_gdb_remote
+} // namespace lldb_private
+
 #endif  // lldb_GDBRemoteRegisterContext_h_

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

 #include "ProcessGDBRemote.h"
 #include "ProcessGDBRemoteLog.h"
 #include "ThreadGDBRemote.h"
 #include "Utility/ARM_GCC_Registers.h"
 #include "Utility/ARM_DWARF_Registers.h"
 
 using namespace lldb;
 using namespace lldb_private;
+using namespace lldb_private::process_gdb_remote;
 
 //----------------------------------------------------------------------
 // GDBRemoteRegisterContext constructor
 //----------------------------------------------------------------------
 GDBRemoteRegisterContext::GDBRemoteRegisterContext
 (
     ThreadGDBRemote &thread,
     uint32_t concrete_frame_idx,
else if (bytes_copied > 0)
         // leave it as it was.
         SetRegisterIsValid(reg, false);
     }
     return success;
 }
 
 // Helper function for GDBRemoteRegisterContext::ReadRegisterBytes().
 bool
-GDBRemoteRegisterContext::GetPrimordialRegister(const lldb_private::RegisterInfo *reg_info,
+GDBRemoteRegisterContext::GetPrimordialRegister(const RegisterInfo *reg_info,
                                                 GDBRemoteCommunicationClient &gdb_comm)
 {
     const uint32_t reg = reg_info->kinds[eRegisterKindLLDB];
     StringExtractorGDBRemote response;
     if (gdb_comm.ReadRegister(m_thread.GetProtocolID(), reg, response))
         return PrivateSetRegisterValue (reg, response);
     return false;
 }
GDBRemoteRegisterContext::WriteRegister (const RegisterInfo *reg_info,
     DataExtractor data;
     if (value.GetData (data))
         return WriteRegisterBytes (reg_info, data, 0);
     return false;
 }
 
 // Helper function for GDBRemoteRegisterContext::WriteRegisterBytes().
 bool
-GDBRemoteRegisterContext::SetPrimordialRegister(const lldb_private::RegisterInfo *reg_info,
+GDBRemoteRegisterContext::SetPrimordialRegister(const RegisterInfo *reg_info,
                                                 GDBRemoteCommunicationClient &gdb_comm)
 {
     StreamString packet;
     StringExtractorGDBRemote response;
     const uint32_t reg = reg_info->kinds[eRegisterKindLLDB];
     packet.Printf ("P%x=", reg);
     packet.PutBytesAsRawHex8 (m_reg_data.PeekData(reg_info->byte_offset, reg_info->byte_size),
                               reg_info->byte_size,
if (gdb_comm.SendPacketAndWaitForResponse(packet.GetString().c_str(),
                                               false) == GDBRemoteCommunication::PacketResult::Success)
     {
         if (response.IsOKResponse())
             InvalidateAllRegisters();
     }
 }
 
 bool
-GDBRemoteRegisterContext::WriteRegisterBytes (const lldb_private::RegisterInfo *reg_info, DataExtractor &data, uint32_t data_offset)
+GDBRemoteRegisterContext::WriteRegisterBytes (const RegisterInfo *reg_info, DataExtractor &data, uint32_t data_offset)
 {
     ExecutionContext exe_ctx (CalculateThread());
 
     Process *process = exe_ctx.GetProcessPtr();
     Thread *thread = exe_ctx.GetThreadPtr();
     if (process == NULL || thread == NULL)
         return false;
 
if (data.CopyByteOrderedData (data_offset,                  // src offset
                     log->Printf("error: failed to get packet sequence mutex, not sending write register for \"%s\"", reg_info->name);
             }
         }
     }
     return false;
 }
 
 bool
-GDBRemoteRegisterContext::ReadAllRegisterValues (lldb_private::RegisterCheckpoint &reg_checkpoint)
+GDBRemoteRegisterContext::ReadAllRegisterValues (RegisterCheckpoint &reg_checkpoint)
 {
     ExecutionContext exe_ctx (CalculateThread());
     
     Process *process = exe_ctx.GetProcessPtr();
     Thread *thread = exe_ctx.GetThreadPtr();
     if (process == NULL || thread == NULL)
         return false;
     
GDBRemoteRegisterContext::ReadAllRegisterValues (RegisterCheckpoint &reg_checkpoint)
     else
     {
         reg_checkpoint.SetID(0); // Invalid save ID is zero
         return ReadAllRegisterValues(reg_checkpoint.GetData());
     }
 }
 
 bool
-GDBRemoteRegisterContext::WriteAllRegisterValues (const lldb_private::RegisterCheckpoint &reg_checkpoint)
+GDBRemoteRegisterContext::WriteAllRegisterValues (const RegisterCheckpoint &reg_checkpoint)
 {
     uint32_t save_id = reg_checkpoint.GetID();
     if (save_id != 0)
     {
         ExecutionContext exe_ctx (CalculateThread());
         
         Process *process = exe_ctx.GetProcessPtr();
         Thread *thread = exe_ctx.GetThreadPtr();

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

 #include "lldb/lldb-private-forward.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Thread.h"
 
 #include "GDBRemoteCommunicationClient.h"
 #include "Utility/StringExtractor.h"
 #include "GDBRemoteRegisterContext.h"
 
+namespace lldb_private {
+namespace process_gdb_remote {
+
 class ThreadGDBRemote;
 
-class ProcessGDBRemote : public lldb_private::Process
+class ProcessGDBRemote : public Process
 {
 public:
     //------------------------------------------------------------------
     // Constructors and Destructors
     //------------------------------------------------------------------
     static lldb::ProcessSP
-    CreateInstance (lldb_private::Target& target, 
-                    lldb_private::Listener &listener,
-                    const lldb_private::FileSpec *crash_file_path);
+    CreateInstance (Target& target, 
+                    Listener &listener,
+                    const FileSpec *crash_file_path);
 
     static void
     Initialize();
 
     static void
-    DebuggerInitialize (lldb_private::Debugger &debugger);
+    DebuggerInitialize (Debugger &debugger);
 
     static void
     Terminate();
 
-    static lldb_private::ConstString
+    static ConstString
     GetPluginNameStatic();
 
     static const char *
     GetPluginDescriptionStatic();
 
     //------------------------------------------------------------------
     // Constructors and Destructors
     //------------------------------------------------------------------
-    ProcessGDBRemote(lldb_private::Target& target, lldb_private::Listener &listener);
+    ProcessGDBRemote(Target& target, Listener &listener);
 
     virtual
     ~ProcessGDBRemote();
 
     //------------------------------------------------------------------
     // Check if a given Process
     //------------------------------------------------------------------
     bool
-    CanDebug (lldb_private::Target &target,
-              bool plugin_specified_by_name) override;
+    CanDebug (Target &target, bool plugin_specified_by_name) override;
 
-    lldb_private::CommandObject *
+    CommandObject *
     GetPluginCommandObject() override;
 
     //------------------------------------------------------------------
     // Creating a new process, or attaching to an existing one
     //------------------------------------------------------------------
-    lldb_private::Error
-    WillLaunch (lldb_private::Module* module) override;
+    Error
+    WillLaunch (Module* module) override;
 
-    lldb_private::Error
-    DoLaunch (lldb_private::Module *exe_module, 
-              lldb_private::ProcessLaunchInfo &launch_info) override;
+    Error
+    DoLaunch (Module *exe_module, ProcessLaunchInfo &launch_info) override;
 
     void
     DidLaunch () override;
 
-    lldb_private::Error
+    Error
     WillAttachToProcessWithID (lldb::pid_t pid) override;
 
-    lldb_private::Error
+    Error
     WillAttachToProcessWithName (const char *process_name, bool wait_for_launch) override;
 
-    lldb_private::Error
-    DoConnectRemote (lldb_private::Stream *strm, const char *remote_url) override;
+    Error
+    DoConnectRemote (Stream *strm, const char *remote_url) override;
     
-    lldb_private::Error
+    Error
     WillLaunchOrAttach ();
 
-    lldb_private::Error
+    Error
     DoAttachToProcessWithID (lldb::pid_t pid) override;
     
-    lldb_private::Error
-    DoAttachToProcessWithID (lldb::pid_t pid, const lldb_private::ProcessAttachInfo &attach_info) override;
+    Error
+    DoAttachToProcessWithID (lldb::pid_t pid, const ProcessAttachInfo &attach_info) override;
     
-    lldb_private::Error
+    Error
     DoAttachToProcessWithName (const char *process_name,
-                               const lldb_private::ProcessAttachInfo &attach_info) override;
+                               const ProcessAttachInfo &attach_info) override;
 
     void
-    DidAttach (lldb_private::ArchSpec &process_arch) override;
+    DidAttach (ArchSpec &process_arch) override;
 
     //------------------------------------------------------------------
     // PluginInterface protocol
     //------------------------------------------------------------------
-    lldb_private::ConstString
+    ConstString
     GetPluginName() override;
 
     uint32_t
     GetPluginVersion() override;
 
     //------------------------------------------------------------------
     // Process Control
     //------------------------------------------------------------------
-    lldb_private::Error
+    Error
     WillResume () override;
 
-    lldb_private::Error
+    Error
     DoResume () override;
 
-    lldb_private::Error
+    Error
     DoHalt (bool &caused_stop) override;
 
-    lldb_private::Error
+    Error
     DoDetach (bool keep_stopped) override;
     
     bool
     DetachRequiresHalt() override { return true; }
 
-    lldb_private::Error
+    Error
     DoSignal (int signal) override;
 
-    lldb_private::Error
+    Error
     DoDestroy () override;
 
     void
     RefreshStateAfterStop() override;
 
     //------------------------------------------------------------------
     // Process Queries
     //------------------------------------------------------------------
     bool
     IsAlive () override;
 
     lldb::addr_t
     GetImageInfoAddress() override;
 
     //------------------------------------------------------------------
     // Process Memory
     //------------------------------------------------------------------
     size_t
-    DoReadMemory (lldb::addr_t addr, void *buf, size_t size, lldb_private::Error &error) override;
+    DoReadMemory (lldb::addr_t addr, void *buf, size_t size, Error &error) override;
 
     size_t
-    DoWriteMemory (lldb::addr_t addr, const void *buf, size_t size, lldb_private::Error &error) override;
+    DoWriteMemory (lldb::addr_t addr, const void *buf, size_t size, Error &error) override;
 
     lldb::addr_t
-    DoAllocateMemory (size_t size, uint32_t permissions, lldb_private::Error &error) override;
+    DoAllocateMemory (size_t size, uint32_t permissions, Error &error) override;
 
-    lldb_private::Error
-    GetMemoryRegionInfo (lldb::addr_t load_addr, 
-                         lldb_private::MemoryRegionInfo &region_info) override;
+    Error
+    GetMemoryRegionInfo (lldb::addr_t load_addr, MemoryRegionInfo &region_info) override;
     
-    lldb_private::Error
+    Error
     DoDeallocateMemory (lldb::addr_t ptr) override;
 
     //------------------------------------------------------------------
     // Process STDIO
     //------------------------------------------------------------------
     size_t
-    PutSTDIN (const char *buf, size_t buf_size, lldb_private::Error &error) override;
+    PutSTDIN (const char *buf, size_t buf_size, Error &error) override;
 
     //----------------------------------------------------------------------
     // Process Breakpoints
     //----------------------------------------------------------------------
-    lldb_private::Error
-    EnableBreakpointSite (lldb_private::BreakpointSite *bp_site) override;
+    Error
+    EnableBreakpointSite (BreakpointSite *bp_site) override;
 
-    lldb_private::Error
-    DisableBreakpointSite (lldb_private::BreakpointSite *bp_site) override;
+    Error
+    DisableBreakpointSite (BreakpointSite *bp_site) override;
 
     //----------------------------------------------------------------------
     // Process Watchpoints
     //----------------------------------------------------------------------
-    lldb_private::Error
-    EnableWatchpoint (lldb_private::Watchpoint *wp, bool notify = true) override;
+    Error
+    EnableWatchpoint (Watchpoint *wp, bool notify = true) override;
 
-    lldb_private::Error
-    DisableWatchpoint (lldb_private::Watchpoint *wp, bool notify = true) override;
+    Error
+    DisableWatchpoint (Watchpoint *wp, bool notify = true) override;
 
-    lldb_private::Error
+    Error
     GetWatchpointSupportInfo (uint32_t &num) override;
     
-    lldb_private::Error
+    Error
     GetWatchpointSupportInfo (uint32_t &num, bool& after) override;
     
     bool
     StartNoticingNewThreads() override;
 
     bool
     StopNoticingNewThreads() override;
 
     GDBRemoteCommunicationClient &
     GetGDBRemote()
     {
         return m_gdb_comm;
     }
     
-    lldb_private::Error
+    Error
     SendEventData(const char *data) override;
 
     //----------------------------------------------------------------------
     // Override SetExitStatus so we can disconnect from the remote GDB server
     //----------------------------------------------------------------------
     bool
     SetExitStatus (int exit_status, const char *cstr) override;
 
     void
     SetUserSpecifiedMaxMemoryTransferSize (uint64_t user_specified_max);
 
     bool
-    GetModuleSpec(const lldb_private::FileSpec& module_file_spec,
-                  const lldb_private::ArchSpec& arch,
-                  lldb_private::ModuleSpec &module_spec) override;
+    GetModuleSpec(const FileSpec& module_file_spec,
+                  const ArchSpec& arch,
+                  ModuleSpec &module_spec) override;
 
 protected:
     friend class ThreadGDBRemote;
     friend class GDBRemoteCommunicationClient;
     friend class GDBRemoteRegisterContext;
 
     //----------------------------------------------------------------------
     // Accessors
protected:
     }
 
     bool
     ProcessIDIsValid ( ) const;
 
     void
     Clear ( );
 
-    lldb_private::Flags &
+    Flags &
     GetFlags ()
     {
         return m_flags;
     }
 
-    const lldb_private::Flags &
+    const Flags &
     GetFlags () const
     {
         return m_flags;
     }
 
     bool
-    UpdateThreadList (lldb_private::ThreadList &old_thread_list, 
-                      lldb_private::ThreadList &new_thread_list) override;
+    UpdateThreadList (ThreadList &old_thread_list, 
+                      ThreadList &new_thread_list) override;
 
-    lldb_private::Error
-    LaunchAndConnectToDebugserver (const lldb_private::ProcessInfo &process_info);
+    Error
+    LaunchAndConnectToDebugserver (const ProcessInfo &process_info);
 
     void
     KillDebugserverProcess ();
 
     void
     BuildDynamicRegisterInfo (bool force);
 
     void
     SetLastStopPacket (const StringExtractorGDBRemote &response);
 
     bool
-    ParsePythonTargetDefinition(const lldb_private::FileSpec &target_definition_fspec);
+    ParsePythonTargetDefinition(const FileSpec &target_definition_fspec);
 
     const lldb::DataBufferSP
     GetAuxvData() override;
 
-    lldb_private::StructuredData::ObjectSP
+    StructuredData::ObjectSP
     GetExtendedInfoForThread (lldb::tid_t tid);
 
     void
     GetMaxMemorySize();
 
     //------------------------------------------------------------------
     /// Broadcaster event bits definitions.
     //------------------------------------------------------------------
     enum
     {
         eBroadcastBitAsyncContinue                  = (1 << 0),
         eBroadcastBitAsyncThreadShouldExit          = (1 << 1),
         eBroadcastBitAsyncThreadDidExit             = (1 << 2)
     };
     
-    lldb_private::Flags m_flags;            // Process specific flags (see eFlags enums)
+    Flags m_flags;            // Process specific flags (see eFlags enums)
     GDBRemoteCommunicationClient m_gdb_comm;
     std::atomic<lldb::pid_t> m_debugserver_pid;
     StringExtractorGDBRemote m_last_stop_packet;
-    lldb_private::Mutex m_last_stop_packet_mutex;
+    Mutex m_last_stop_packet_mutex;
     GDBRemoteDynamicRegisterInfo m_register_info;
-    lldb_private::Broadcaster m_async_broadcaster;
-    lldb_private::HostThread m_async_thread;
-    lldb_private::Mutex m_async_thread_state_mutex;
+    Broadcaster m_async_broadcaster;
+    HostThread m_async_thread;
+    Mutex m_async_thread_state_mutex;
     typedef std::vector<lldb::tid_t> tid_collection;
     typedef std::vector< std::pair<lldb::tid_t,int> > tid_sig_collection;
     typedef std::map<lldb::addr_t, lldb::addr_t> MMapMap;
     tid_collection m_thread_ids; // Thread IDs for all threads. This list gets updated after stopping
     tid_collection m_continue_c_tids;                  // 'c' for continue
     tid_sig_collection m_continue_C_tids; // 'C' for continue with signal
     tid_collection m_continue_s_tids;                  // 's' for step
     tid_sig_collection m_continue_S_tids; // 'S' for step with signal
protected:
 
     void
     ClearThreadIDList ();
 
     bool
     UpdateThreadIDList ();
 
     void
-    DidLaunchOrAttach (lldb_private::ArchSpec& process_arch);
+    DidLaunchOrAttach (ArchSpec& process_arch);
 
-    lldb_private::Error
+    Error
     ConnectToDebugserver (const char *host_port);
 
     const char *
     GetDispatchQueueNameForThread (lldb::addr_t thread_dispatch_qaddr,
                                    std::string &dispatch_queue_name);
 
-    lldb_private::DynamicLoader *
+    DynamicLoader *
     GetDynamicLoader () override;
 
 private:
     //------------------------------------------------------------------
     // For ProcessGDBRemote only
     //------------------------------------------------------------------
     static bool
     NewThreadNotifyBreakpointHit (void *baton,
-                         lldb_private::StoppointCallbackContext *context,
+                         StoppointCallbackContext *context,
                          lldb::user_id_t break_id,
                          lldb::user_id_t break_loc_id);
 
     DISALLOW_COPY_AND_ASSIGN (ProcessGDBRemote);
 
 };
 
+} // namespace process_gdb_remote
+} // namespace lldb_private
+
 #endif  // liblldb_ProcessGDBRemote_h_

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

 #include "Plugins/Process/Utility/StopInfoMachException.h"
 #include "Plugins/Platform/MacOSX/PlatformRemoteiOS.h"
 #include "Utility/StringExtractorGDBRemote.h"
 #include "GDBRemoteRegisterContext.h"
 #include "ProcessGDBRemote.h"
 #include "ProcessGDBRemoteLog.h"
 #include "ThreadGDBRemote.h"
 
+#define DEBUGSERVER_BASENAME    "debugserver"
+using namespace lldb;
+using namespace lldb_private;
+using namespace lldb_private::process_gdb_remote;
 
 namespace lldb
 {
     // Provide a function that can easily dump the packet history if we know a
     // ProcessGDBRemote * value (which we can get from logs or from debugging).
     // We need the function in the lldb namespace so it makes it into the final
     // executable since the LLDB shared library only exports stuff in the lldb
     // namespace. This allows you to attach with a debugger and call this
     // function and get the packet history dumped to a file.
     void
     DumpProcessGDBRemotePacketHistory (void *p, const char *path)
     {
-        lldb_private::StreamFile strm;
-        lldb_private::Error error (strm.GetFile().Open(path, lldb_private::File::eOpenOptionWrite | lldb_private::File::eOpenOptionCanCreate));
+        StreamFile strm;
+        Error error (strm.GetFile().Open(path, File::eOpenOptionWrite | File::eOpenOptionCanCreate));
         if (error.Success())
             ((ProcessGDBRemote *)p)->GetGDBRemote().DumpHistory (strm);
     }
 }
 
-#define DEBUGSERVER_BASENAME    "debugserver"
-using namespace lldb;
-using namespace lldb_private;
-
-
 namespace {
 
     static PropertyDefinition
     g_properties[] =
     {
         { "packet-timeout" , OptionValue::eTypeUInt64 , true , 1, NULL, NULL, "Specify the default packet timeout in seconds." },
         { "target-definition-file" , OptionValue::eTypeFileSpec , true, 0 , NULL, NULL, "The file that provides the description for remote target registers." },
         {  NULL            , OptionValue::eTypeInvalid, false, 0, NULL, NULL, NULL  }
if (!rand_initialized)
 
         rand_initialized = true;
         srand(seed);
     }
     return (rand() % (HIGH_PORT - LOW_PORT)) + LOW_PORT;
 }
 #endif
 
-lldb_private::ConstString
+ConstString
 ProcessGDBRemote::GetPluginNameStatic()
 {
     static ConstString g_name("gdb-remote");
     return g_name;
 }
 
 const char *
 ProcessGDBRemote::GetPluginDescriptionStatic()
#endif
     StopAsyncThread ();
     KillDebugserverProcess ();
     return error;
 }
 
 void
 ProcessGDBRemote::SetLastStopPacket (const StringExtractorGDBRemote &response)
 {
-    lldb_private::Mutex::Locker locker (m_last_stop_packet_mutex);
+    Mutex::Locker locker (m_last_stop_packet_mutex);
     const bool did_exec = response.GetStringRef().find(";reason:exec;") != std::string::npos;
     if (did_exec)
     {
         Log *log (ProcessGDBRemoteLog::GetLogIfAllCategoriesSet(GDBR_LOG_PROCESS));
         if (log)
             log->Printf ("ProcessGDBRemote::SetLastStopPacket () - detected exec");
 
         m_thread_list_real.Clear();
else
         error.SetErrorStringWithFormat("failed to send packet: '%s'", packet.GetString().c_str());
     }
     return 0;
 }
 
 lldb::addr_t
 ProcessGDBRemote::DoAllocateMemory (size_t size, uint32_t permissions, Error &error)
 {
-    lldb_private::Log *log (lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_PROCESS|LIBLLDB_LOG_EXPRESSIONS));
+    Log *log (GetLogIfAnyCategoriesSet (LIBLLDB_LOG_PROCESS|LIBLLDB_LOG_EXPRESSIONS));
     addr_t allocated_addr = LLDB_INVALID_ADDRESS;
     
     LazyBool supported = m_gdb_comm.SupportsAllocDeallocMemory();
     switch (supported)
     {
         case eLazyBoolCalculate:
         case eLazyBoolYes:
             allocated_addr = m_gdb_comm.AllocateMemory (size, permissions);
if (g_initialized == false)
         PluginManager::RegisterPlugin (GetPluginNameStatic(),
                                        GetPluginDescriptionStatic(),
                                        CreateInstance,
                                        DebuggerInitialize);
     }
 }
 
 void
-ProcessGDBRemote::DebuggerInitialize (lldb_private::Debugger &debugger)
+ProcessGDBRemote::DebuggerInitialize (Debugger &debugger)
 {
     if (!PluginManager::GetSettingForProcessPlugin(debugger, PluginProperties::GetSettingName()))
     {
         const bool is_global_setting = true;
         PluginManager::CreateSettingForProcessPlugin (debugger,
                                                       GetGlobalPluginProperties()->GetValueProperties(),
                                                       ConstString ("Properties for the gdb-remote process plug-in."),
                                                       is_global_setting);

 //        // FIXME: Implement talking to the remote debugserver.
 //        return 0;
 //    }
 //
 //}
 //
 bool
 ProcessGDBRemote::NewThreadNotifyBreakpointHit (void *baton,
-                             lldb_private::StoppointCallbackContext *context,
+                             StoppointCallbackContext *context,
                              lldb::user_id_t break_id,
                              lldb::user_id_t break_loc_id)
 {
     // I don't think I have to do anything here, just make sure I notice the new thread when it starts to 
     // run so I can stop it if that's what I want to do.
-    Log *log (lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_STEP));
+    Log *log (GetLogIfAllCategoriesSet (LIBLLDB_LOG_STEP));
     if (log)
         log->Printf("Hit New Thread Notification breakpoint.");
     return false;
 }
 
 
 bool
 ProcessGDBRemote::StartNoticingNewThreads()
 {
-    Log *log (lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_STEP));
+    Log *log (GetLogIfAllCategoriesSet (LIBLLDB_LOG_STEP));
     if (m_thread_create_bp_sp)
     {
         if (log && log->GetVerbose())
             log->Printf("Enabled noticing new thread breakpoint.");
         m_thread_create_bp_sp->SetEnabled(true);
     }
     else
     {
else
         }
     }
     return m_thread_create_bp_sp.get() != NULL;
 }
 
 bool
 ProcessGDBRemote::StopNoticingNewThreads()
 {   
-    Log *log (lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_STEP));
+    Log *log (GetLogIfAllCategoriesSet (LIBLLDB_LOG_STEP));
     if (log && log->GetVerbose())
         log->Printf ("Disabling new thread notification breakpoint.");
 
     if (m_thread_create_bp_sp)
         m_thread_create_bp_sp->SetEnabled(false);
 
     return true;
 }
     
-lldb_private::DynamicLoader *
+DynamicLoader *
 ProcessGDBRemote::GetDynamicLoader ()
 {
     if (m_dyld_ap.get() == NULL)
         m_dyld_ap.reset (DynamicLoader::FindPlugin(this, NULL));
     return m_dyld_ap.get();
 }
 
 Error

lldb/trunk/source/Plugins/Process/gdb-remote/ProcessGDBRemoteLog.h

 #define GDBR_LOG_BREAKPOINTS              (1u << 7)
 #define GDBR_LOG_WATCHPOINTS              (1u << 8)
 #define GDBR_LOG_STEP                     (1u << 9)
 #define GDBR_LOG_COMM                     (1u << 10)
 #define GDBR_LOG_ASYNC                    (1u << 11)
 #define GDBR_LOG_ALL                      (UINT32_MAX)
 #define GDBR_LOG_DEFAULT                  GDBR_LOG_PACKETS
 
+namespace lldb_private {
+namespace process_gdb_remote {
+
 class ProcessGDBRemoteLog
 {
 public:
     static void
     Initialize();
 
-    static lldb_private::Log *
+    static Log *
     GetLogIfAllCategoriesSet(uint32_t mask = 0);
     
-    static lldb_private::Log *
+    static Log *
     GetLogIfAnyCategoryIsSet (uint32_t mask);
 
     static void
-    DisableLog (const char **categories, lldb_private::Stream *feedback_strm);
+    DisableLog (const char **categories, Stream *feedback_strm);
 
-    static lldb_private::Log *
-    EnableLog (lldb::StreamSP &log_stream_sp, uint32_t log_options, const char **categories, lldb_private::Stream *feedback_strm);
+    static Log *
+    EnableLog (lldb::StreamSP &log_stream_sp, uint32_t log_options, const char **categories, Stream *feedback_strm);
 
     static void
-    ListLogCategories (lldb_private::Stream *strm);
+    ListLogCategories (Stream *strm);
 
     static void
     LogIf (uint32_t mask, const char *format, ...);
 };
 
+} // namespace process_gdb_remote
+} // namespace lldb_private
+
 #endif  // liblldb_ProcessGDBRemoteLog_h_

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

 
 #include "lldb/Interpreter/Args.h"
 #include "lldb/Core/StreamFile.h"
 
 #include "ProcessGDBRemote.h"
 
 using namespace lldb;
 using namespace lldb_private;
+using namespace lldb_private::process_gdb_remote;
 
 
 // We want to avoid global constructors where code needs to be run so here we
 // control access to our static g_log_sp by hiding it in a singleton function
 // that will construct the static g_lob_sp the first time this function is 
 // called.
 static bool g_log_enabled = false;
 static Log * g_log = NULL;

lldb/trunk/source/Plugins/Process/gdb-remote/ThreadGDBRemote.h

 
 #include <string>
 
 #include "lldb/Core/StructuredData.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Thread.h"
 
 class StringExtractor;
+
+namespace lldb_private {
+namespace process_gdb_remote {
+
 class ProcessGDBRemote;
 
-class ThreadGDBRemote : public lldb_private::Thread
+class ThreadGDBRemote : public Thread
 {
 public:
-    ThreadGDBRemote (lldb_private::Process &process, lldb::tid_t tid);
+    ThreadGDBRemote (Process &process, lldb::tid_t tid);
 
     virtual
     ~ThreadGDBRemote ();
 
     void
     WillResume (lldb::StateType resume_state) override;
 
     void
public:
 
     lldb::addr_t
     GetQueueLibdispatchQueueAddress () override;
 
     lldb::RegisterContextSP
     GetRegisterContext () override;
 
     lldb::RegisterContextSP
-    CreateRegisterContextForFrame (lldb_private::StackFrame *frame) override;
+    CreateRegisterContextForFrame (StackFrame *frame) override;
 
     void
-    Dump (lldb_private::Log *log, uint32_t index);
+    Dump (Log *log, uint32_t index);
 
     static bool
     ThreadIDIsValid (lldb::tid_t thread);
 
     bool
     ShouldStop (bool &step_more);
 
     const char *
public:
     }
 
     void
     SetThreadDispatchQAddr (lldb::addr_t thread_dispatch_qaddr)
     {
         m_thread_dispatch_qaddr = thread_dispatch_qaddr;
     }
 
-    lldb_private::StructuredData::ObjectSP
+    StructuredData::ObjectSP
     FetchThreadExtendedInfo () override;
 
 protected:
     
     friend class ProcessGDBRemote;
 
     bool
     PrivateSetRegisterValue (uint32_t reg, 
protected:
     // Member variables.
     //------------------------------------------------------------------
 
     void
     SetStopInfoFromPacket (StringExtractor &stop_packet, uint32_t stop_id);
 
     bool
     CalculateStopInfo () override;
-
-
 };
 
+} // namespace process_gdb_remote
+} // namespace lldb_private
+
 #endif  // liblldb_ThreadGDBRemote_h_

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

 #include "lldb/Target/Unwind.h"
 
 #include "ProcessGDBRemote.h"
 #include "ProcessGDBRemoteLog.h"
 #include "Utility/StringExtractorGDBRemote.h"
 
 using namespace lldb;
 using namespace lldb_private;
+using namespace lldb_private::process_gdb_remote;
 
 //----------------------------------------------------------------------
 // Thread Registers
 //----------------------------------------------------------------------
 
 ThreadGDBRemote::ThreadGDBRemote (Process &process, lldb::tid_t tid) :
     Thread(process, tid),
     m_thread_name (),
ThreadGDBRemote::GetQueueLibdispatchQueueAddress ()
     return dispatch_queue_t_addr;
 }
 
 StructuredData::ObjectSP
 ThreadGDBRemote::FetchThreadExtendedInfo ()
 {
     StructuredData::ObjectSP object_sp;
     const lldb::user_id_t tid = GetProtocolID();
-    Log *log(lldb_private::GetLogIfAnyCategoriesSet (GDBR_LOG_THREAD));
+    Log *log(GetLogIfAnyCategoriesSet (GDBR_LOG_THREAD));
     if (log)
         log->Printf ("Fetching extended information for thread %4.4" PRIx64, tid);
     ProcessSP process_sp (GetProcess());
     if (process_sp)
     {
         ProcessGDBRemote *gdb_process = static_cast<ProcessGDBRemote *>(process_sp.get());
         object_sp = gdb_process->GetExtendedInfoForThread (tid);
     }
     return object_sp;
 }
 
 void
 ThreadGDBRemote::WillResume (StateType resume_state)
 {
     int signo = GetResumeSignal();
     const lldb::user_id_t tid = GetProtocolID();
-    Log *log(lldb_private::GetLogIfAnyCategoriesSet (GDBR_LOG_THREAD));
+    Log *log(GetLogIfAnyCategoriesSet (GDBR_LOG_THREAD));
     if (log)
         log->Printf ("Resuming thread: %4.4" PRIx64 " with state: %s.", tid, StateAsCString(resume_state));
 
     ProcessSP process_sp (GetProcess());
     if (process_sp)
     {
         ProcessGDBRemote *gdb_process = static_cast<ProcessGDBRemote *>(process_sp.get());
         switch (resume_state)

lldb/trunk/tools/lldb-server/lldb-gdbserver.cpp

 #endif
 
 #ifndef LLGS_VERSION_STR
 #define LLGS_VERSION_STR "local_build"
 #endif
 
 using namespace lldb;
 using namespace lldb_private;
+using namespace lldb_private::process_gdb_remote;
 
 // lldb-gdbserver state
 
 namespace
 {
 HostThread s_listen_thread;
     std::unique_ptr<ConnectionFileDescriptor> s_listen_connection_up;
     std::string s_listen_url;

lldb/trunk/tools/lldb-server/lldb-platform.cpp

 #include "lldb/Host/Socket.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Interpreter/CommandReturnObject.h"
 #include "Plugins/Process/gdb-remote/GDBRemoteCommunicationServerPlatform.h"
 #include "Plugins/Process/gdb-remote/ProcessGDBRemoteLog.h"
 
 using namespace lldb;
 using namespace lldb_private;
+using namespace lldb_private::process_gdb_remote;
 
 //----------------------------------------------------------------------
 // option descriptors for getopt_long_only()
 //----------------------------------------------------------------------
 
 static int g_debug = 0;
 static int g_verbose = 0;
 static int g_server = 0;