Abtracted the old "lldb_private::Thread::StopInfo" into an abtract class.

This will allow debugger plug-ins to make any instance of "lldb_private::StopInfo"
that can completely describe any stop reason. It also provides a framework for
doing intelligent things with the stop info at important times in the lifetime
of the inferior. 

Examples include the signal stop info in StopInfoUnixSignal. It will check with
the process to see that the current action is for the signal. These actions
include wether to stop for the signal, wether the notify that the signal was
hit, and wether to pass the signal along to the inferior process. The 
StopInfoUnixSignal class overrides the "ShouldStop()" method of StopInfo and
this allows the stop info to determine if it should stop at the signal or 
continue the process. 


StopInfo subclasses must override the following functions:

    virtual lldb::StopReason
    GetStopReason () const = 0;

    virtual const char *
    GetDescription () = 0;


StopInfo subclasses can override the following functions:


    // If the subclass returns "false", the inferior will resume. The default
    // version of this function returns "true" which means the default stop
    // info will stop the process. The breakpoint subclass will check if
    // the breakpoint wants us to stop by calling any installed callback on
    // the breakpoint, and also checking if the breakpoint is for the current
    // thread. Signals will check if they should stop based off of the 
    // UnixSignal settings in the process.
    virtual bool
    ShouldStop (Event *event_ptr);

    // Sublasses can state if they want to notify the debugger when "ShouldStop"
    // returns false. This would be handy for breakpoints where you want to
    // log information and continue and is also used by the signal stop info
    // to notify that a signal was received (after it checks with the process
    // signal settings).
    virtual bool
    ShouldNotify (Event *event_ptr)
    {
        return false;
    }

    // Allow subclasses to do something intelligent right before we resume.
    // The signal class will figure out if the signal should be propagated
    // to the inferior process and pass that along to the debugger plug-ins.
    virtual void
    WillResume (lldb::StateType resume_state)
    {
        // By default, don't do anything
    }


The support the Mach exceptions was moved into the lldb/source/Plugins/Process/Utility
folder and now doesn't polute the lldb_private::Thread class with platform
specific code.

llvm-svn: 110184

9 files changed, 461 insertions, 121 deletions

diff --git a/lldb/source/Plugins/Process/MacOSX-User/source/MacOSX/MachException.cpp b/lldb/source/Plugins/Process/MacOSX-User/source/MacOSX/MachException.cpp
index d32ed5cd4cf..cfea47518ca 100644
--- a/lldb/source/Plugins/Process/MacOSX-User/source/MacOSX/MachException.cpp
+++ b/lldb/source/Plugins/Process/MacOSX-User/source/MacOSX/MachException.cpp
@@ -13,6 +13,7 @@
 
 #include "lldb/Core/StreamString.h"
 #include "lldb/Host/Host.h"
+#include "StopInfoMachException.h"
 
 #include "MachException.h"
 #include "ProcessMacOSXLog.h"
@@ -198,22 +199,16 @@ MachException::Message::PutToLog(Log *log) const
     }
 }
 
-bool
-MachException::Data::GetStopInfo(Thread::StopInfo *stop_info) const
+lldb::StopInfoSP
+MachException::Data::GetStopInfo (lldb_private::Thread &thread) const
 {
-    // Zero out the structure.
-    stop_info->Clear();
-
-    // Make sure we have a valid exception before we return anything valid
-    if (exc_type == 0)
-        return true;
-    // We always stop with a mach exceptions
+    
     const size_t exc_data_count = exc_data.size();
-    stop_info->SetStopReasonWithMachException (exc_type, 
-                                               exc_data_count, 
-                                               exc_data_count ? &exc_data[0] : NULL);
-
-    return true;
+    return StopInfoMachException::CreateStopReasonWithMachException (thread, 
+                                                                     exc_type,
+                                                                     exc_data_count,
+                                                                     exc_data_count >= 1 ? exc_data[0] : 0,
+                                                                     exc_data_count >= 2 ? exc_data[1] : 0);
 }
 
 
diff --git a/lldb/source/Plugins/Process/MacOSX-User/source/MacOSX/MachException.h b/lldb/source/Plugins/Process/MacOSX-User/source/MacOSX/MachException.h
index 886cbabc20c..761f433405b 100644
--- a/lldb/source/Plugins/Process/MacOSX-User/source/MacOSX/MachException.h
+++ b/lldb/source/Plugins/Process/MacOSX-User/source/MacOSX/MachException.h
@@ -98,7 +98,7 @@ public:
         }
         void PutToLog(lldb_private::Log *log) const;
         void DumpStopReason() const;
-        bool GetStopInfo(lldb_private::Thread::StopInfo *stop_info) const;
+        lldb::StopInfoSP GetStopInfo (lldb_private::Thread &thread) const;
     };
 
     struct Message
diff --git a/lldb/source/Plugins/Process/MacOSX-User/source/ThreadMacOSX.cpp b/lldb/source/Plugins/Process/MacOSX-User/source/ThreadMacOSX.cpp
index 826407662ad..974421074a9 100644
--- a/lldb/source/Plugins/Process/MacOSX-User/source/ThreadMacOSX.cpp
+++ b/lldb/source/Plugins/Process/MacOSX-User/source/ThreadMacOSX.cpp
@@ -13,6 +13,7 @@
 #include "lldb/Core/ArchSpec.h"
 #include "lldb/Core/DataExtractor.h"
 #include "lldb/Target/Process.h"
+#include "lldb/Target/StopInfo.h"
 #include "lldb/Target/Target.h"
 
 #include "ProcessMacOSX.h"
@@ -63,70 +64,12 @@ ThreadMacOSX::~ThreadMacOSX ()
 #endif
 
 
-bool
-ThreadMacOSX::GetRawStopReason (Thread::StopInfo *stop_info )
+StopInfoSP
+ThreadMacOSX::GetPrivateStopReason ()
 {
-    stop_info->SetThread(this);
-
-    bool success = GetStopException().GetStopInfo(stop_info);
-
-
-#if defined (MACH_SOFTWARE_BREAKPOINT_DATA_0) || defined (MACH_TRAP_DATA_0)
-    if (stop_info->GetStopReason() == eStopReasonException)
-    {
-        if (stop_info->GetExceptionType() == EXC_BREAKPOINT && stop_info->GetExceptionDataCount() == 2)
-        {
-            const lldb::addr_t data_0 = stop_info->GetExceptionDataAtIndex(0);
-#if defined (MACH_SOFTWARE_BREAKPOINT_DATA_0)
-            if (data_0 == MACH_SOFTWARE_BREAKPOINT_DATA_0)
-            {
-                lldb::addr_t pc = GetRegisterContext()->GetPC();
-                lldb::BreakpointSiteSP bp_site_sp = m_process.GetBreakpointSiteList().FindByAddress(pc);
-                if (bp_site_sp)
-                {
-                    if (bp_site_sp->ValidForThisThread (this))
-                    {
-                        stop_info->Clear ();
-                        stop_info->SetStopReasonWithBreakpointSiteID (GetID());
-                    }
-                    else
-                    {
-                        stop_info->Clear ();
-                        stop_info->SetStopReasonToNone();
-                    }
-                    return success;
-                }
-            }
-#endif
-#if defined (MACH_TRAP_DATA_0)
-            if (data_0 == MACH_TRAP_DATA_0)
-            {
-                stop_info->Clear ();
-                stop_info->SetStopReasonToTrace ();
-                return success;
-            }
-#endif
-        }
-    }
-#endif
-
-    if (stop_info->GetStopReason() == eStopReasonException)
-    {
-        if (stop_info->GetExceptionType() == EXC_SOFTWARE &&
-            stop_info->GetExceptionDataCount() == 2 &&
-            stop_info->GetExceptionDataAtIndex(0) == EXC_SOFT_SIGNAL)
-        {
-            int signo = stop_info->GetExceptionDataAtIndex(1);
-            stop_info->Clear ();
-            stop_info->SetStopReasonWithSignal (signo);
-        }
-    }
-    else
-    {
-        stop_info->SetStopReasonToNone();
-    }
-
-    return success;
+    if (m_actual_stop_info_sp.get() == NULL || m_actual_stop_info_sp->IsValid() == false)
+        m_actual_stop_info_sp = GetStopException().GetStopInfo(*this);
+    return m_actual_stop_info_sp;
 }
 
 const char *
diff --git a/lldb/source/Plugins/Process/MacOSX-User/source/ThreadMacOSX.h b/lldb/source/Plugins/Process/MacOSX-User/source/ThreadMacOSX.h
index 0039f3639f1..2e57ca93112 100644
--- a/lldb/source/Plugins/Process/MacOSX-User/source/ThreadMacOSX.h
+++ b/lldb/source/Plugins/Process/MacOSX-User/source/ThreadMacOSX.h
@@ -126,8 +126,8 @@ public:
     size_t
     GetStackFrameData (std::vector<std::pair<lldb::addr_t, lldb::addr_t> >& fp_pc_pairs);
 
-    virtual bool
-    GetRawStopReason (lldb_private::Thread::StopInfo *stop_info);
+    virtual lldb::StopInfoSP
+    GetPrivateStopReason ();
 
 protected:
     bool
diff --git a/lldb/source/Plugins/Process/Utility/StopInfoMachException.cpp b/lldb/source/Plugins/Process/Utility/StopInfoMachException.cpp
new file mode 100644
index 00000000000..c7e85f736c7
--- /dev/null
+++ b/lldb/source/Plugins/Process/Utility/StopInfoMachException.cpp
@@ -0,0 +1,344 @@
+//===-- StopInfoMachException.cpp -------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "StopInfoMachException.h"
+
+// C Includes
+// C++ Includes
+// Other libraries and framework includes
+// Project includes
+#include "lldb/Core/ArchSpec.h"
+#include "lldb/Core/StreamString.h"
+#include "lldb/Target/Process.h"
+#include "lldb/Target/RegisterContext.h"
+#include "lldb/Target/Target.h"
+#include "lldb/Target/Thread.h"
+#include "lldb/Target/ThreadPlan.h"
+#include "lldb/Target/UnixSignals.h"
+
+using namespace lldb;
+using namespace lldb_private;
+    
+const char *
+StopInfoMachException::GetDescription ()
+{
+    if (m_description.empty() && m_value != 0)
+    {
+        ArchSpec::CPU cpu = m_thread.GetProcess().GetTarget().GetArchitecture().GetGenericCPUType();
+
+        const char *exc_desc = NULL;
+        const char *code_label = "code";
+        const char *code_desc = NULL;
+        const char *subcode_label = "subcode";
+        const char *subcode_desc = NULL;
+        switch (m_value)
+        {
+        case 1: // EXC_BAD_ACCESS
+            exc_desc = "EXC_BAD_ACCESS";
+            subcode_label = "address";
+            switch (cpu)
+            {                        
+            case ArchSpec::eCPU_arm:
+                switch (m_exc_code)
+                {
+                case 0x101: code_desc = "EXC_ARM_DA_ALIGN"; break;
+                case 0x102: code_desc = "EXC_ARM_DA_DEBUG"; break;
+                }
+                break;
+
+            case ArchSpec::eCPU_ppc:
+            case ArchSpec::eCPU_ppc64:
+                switch (m_exc_code)
+                {
+                case 0x101: code_desc = "EXC_PPC_VM_PROT_READ"; break;
+                case 0x102: code_desc = "EXC_PPC_BADSPACE";     break;
+                case 0x103: code_desc = "EXC_PPC_UNALIGNED";    break;
+                }
+                break;
+
+            default:
+                break;
+            }
+            break;
+
+        case 2: // EXC_BAD_INSTRUCTION
+            exc_desc = "EXC_BAD_INSTRUCTION";
+            switch (cpu)
+            {
+            case ArchSpec::eCPU_i386:
+            case ArchSpec::eCPU_x86_64:
+                if (m_exc_code == 1)
+                    code_desc = "EXC_I386_INVOP";
+                break;
+
+            case ArchSpec::eCPU_ppc:
+            case ArchSpec::eCPU_ppc64:
+                switch (m_exc_code)
+                {
+                case 1: code_desc = "EXC_PPC_INVALID_SYSCALL"; break; 
+                case 2: code_desc = "EXC_PPC_UNIPL_INST"; break; 
+                case 3: code_desc = "EXC_PPC_PRIVINST"; break; 
+                case 4: code_desc = "EXC_PPC_PRIVREG"; break; 
+                case 5: code_desc = "EXC_PPC_TRACE"; break; 
+                case 6: code_desc = "EXC_PPC_PERFMON"; break; 
+                }
+                break;
+
+            case ArchSpec::eCPU_arm:
+                if (m_exc_code == 1)
+                    code_desc = "EXC_ARM_UNDEFINED";
+                break;
+
+            default:
+                break;
+            }
+            break;
+
+        case 3: // EXC_ARITHMETIC
+            exc_desc = "EXC_ARITHMETIC";
+            switch (cpu)
+            {
+            case ArchSpec::eCPU_i386:
+            case ArchSpec::eCPU_x86_64:
+                switch (m_exc_code)
+                {
+                case 1: code_desc = "EXC_I386_DIV"; break;
+                case 2: code_desc = "EXC_I386_INTO"; break;
+                case 3: code_desc = "EXC_I386_NOEXT"; break;
+                case 4: code_desc = "EXC_I386_EXTOVR"; break;
+                case 5: code_desc = "EXC_I386_EXTERR"; break;
+                case 6: code_desc = "EXC_I386_EMERR"; break;
+                case 7: code_desc = "EXC_I386_BOUND"; break;
+                case 8: code_desc = "EXC_I386_SSEEXTERR"; break;
+                }
+                break;
+
+            case ArchSpec::eCPU_ppc:
+            case ArchSpec::eCPU_ppc64:
+                switch (m_exc_code)
+                {
+                case 1: code_desc = "EXC_PPC_OVERFLOW"; break;
+                case 2: code_desc = "EXC_PPC_ZERO_DIVIDE"; break;
+                case 3: code_desc = "EXC_PPC_FLT_INEXACT"; break;
+                case 4: code_desc = "EXC_PPC_FLT_ZERO_DIVIDE"; break;
+                case 5: code_desc = "EXC_PPC_FLT_UNDERFLOW"; break;
+                case 6: code_desc = "EXC_PPC_FLT_OVERFLOW"; break;
+                case 7: code_desc = "EXC_PPC_FLT_NOT_A_NUMBER"; break;
+                }
+                break;
+
+            default:
+                break;
+            }
+            break;
+
+        case 4: // EXC_EMULATION
+            exc_desc = "EXC_EMULATION";
+            break;
+
+
+        case 5: // EXC_SOFTWARE
+            exc_desc = "EXC_SOFTWARE";
+            if (m_exc_code == 0x10003)
+            {
+                subcode_desc = "EXC_SOFT_SIGNAL";
+                subcode_label = "signo";
+            }
+            break;
+        
+        case 6: // EXC_BREAKPOINT
+            {
+                exc_desc = "EXC_BREAKPOINT";
+                switch (cpu)
+                {
+                case ArchSpec::eCPU_i386:
+                case ArchSpec::eCPU_x86_64:
+                    switch (m_exc_code)
+                    {
+                    case 1: subcode_desc = "EXC_I386_SGL"; break;
+                    case 2: subcode_desc = "EXC_I386_BPT"; break;
+                    }
+                    break;
+
+                case ArchSpec::eCPU_ppc:
+                case ArchSpec::eCPU_ppc64:
+                    switch (m_exc_code)
+                    {
+                    case 1: subcode_desc = "EXC_PPC_BREAKPOINT"; break;
+                    }
+                    break;
+                
+                case ArchSpec::eCPU_arm:
+                    switch (m_exc_code)
+                    {
+                    case 1: subcode_desc = "EXC_ARM_BREAKPOINT"; break;
+                    }
+                    break;
+
+                default:
+                    break;
+                }
+            }
+            break;
+
+        case 7:
+            exc_desc = "EXC_SYSCALL";
+            break;
+
+        case 8:
+            exc_desc = "EXC_MACH_SYSCALL";
+            break;
+
+        case 9:
+            exc_desc = "EXC_RPC_ALERT";
+            break;
+
+        case 10:
+            exc_desc = "EXC_CRASH";
+            break;
+        }
+        
+        StreamString strm;
+
+        if (exc_desc)
+            strm.PutCString(exc_desc);
+        else
+            strm.Printf("EXC_??? (%llu)", m_value);
+
+        if (m_exc_data_count >= 1)
+        {
+            if (code_desc)
+                strm.Printf(" (%s=%s", code_label, code_desc);
+            else
+                strm.Printf(" (%s=%llu", code_label, m_exc_code);
+        }
+
+        if (m_exc_data_count >= 2)
+        {
+            if (subcode_desc)
+                strm.Printf(", %s=%s", subcode_label, subcode_desc);
+            else
+                strm.Printf(", %s=0x%llx", subcode_label, m_exc_subcode);
+        }
+        
+        if (m_exc_data_count > 0)
+            strm.PutChar(')');
+        
+        m_description.swap (strm.GetString());
+    }
+    return m_description.c_str();
+}
+
+
+StopInfoSP
+StopInfoMachException::CreateStopReasonWithMachException 
+(
+    Thread &thread,
+    uint32_t exc_type, 
+    uint32_t exc_data_count,
+    uint64_t exc_code,
+    uint64_t exc_sub_code
+)
+{
+    if (exc_type != 0)
+    {
+        ArchSpec::CPU cpu = thread.GetProcess().GetTarget().GetArchitecture().GetGenericCPUType();
+
+        switch (exc_type)
+        {
+        case 1: // EXC_BAD_ACCESS
+            break;
+
+        case 2: // EXC_BAD_INSTRUCTION
+            switch (cpu)
+            {
+            case ArchSpec::eCPU_ppc:
+            case ArchSpec::eCPU_ppc64:
+                switch (exc_code)
+                {
+                case 1: // EXC_PPC_INVALID_SYSCALL
+                case 2: // EXC_PPC_UNIPL_INST
+                case 3: // EXC_PPC_PRIVINST
+                case 4: // EXC_PPC_PRIVREG
+                    break;
+                case 5: // EXC_PPC_TRACE
+                    return StopInfo::CreateStopReasonToTrace (thread);
+                case 6: // EXC_PPC_PERFMON
+                    break;
+                }
+                break;
+
+            default:
+                break;
+            }
+            break;
+
+        case 3: // EXC_ARITHMETIC
+        case 4: // EXC_EMULATION
+            break;
+
+        case 5: // EXC_SOFTWARE
+            if (exc_code == 0x10003) // EXC_SOFT_SIGNAL
+                return StopInfo::CreateStopReasonWithSignal (thread, exc_sub_code);
+            break;
+        
+        case 6: // EXC_BREAKPOINT
+            {
+                bool is_software_breakpoint = false;
+                switch (cpu)
+                {
+                case ArchSpec::eCPU_i386:
+                case ArchSpec::eCPU_x86_64:
+                    if (exc_code == 1) // EXC_I386_SGL
+                    {
+                        return StopInfo::CreateStopReasonToTrace(thread);
+                    }
+                    else if (exc_code == 2) // EXC_I386_BPT
+                    {
+                        is_software_breakpoint = true;
+                    }
+                    break;
+
+                case ArchSpec::eCPU_ppc:
+                case ArchSpec::eCPU_ppc64:
+                    is_software_breakpoint = exc_code == 1; // EXC_PPC_BREAKPOINT
+                    break;
+                
+                case ArchSpec::eCPU_arm:
+                    is_software_breakpoint = exc_code == 1; // EXC_ARM_BREAKPOINT
+                    break;
+
+                default:
+                    break;
+                }
+
+                if (is_software_breakpoint)
+                {
+                    addr_t pc = thread.GetRegisterContext()->GetPC();
+                    lldb::BreakpointSiteSP bp_site_sp = thread.GetProcess().GetBreakpointSiteList().FindByAddress(pc);
+                    if (bp_site_sp)
+                    {
+                        if (bp_site_sp->ValidForThisThread (&thread))
+                            return StopInfo::CreateStopReasonWithBreakpointSiteID (thread, bp_site_sp->GetID());
+                    }
+                }
+            }
+            break;
+
+        case 7:     // EXC_SYSCALL
+        case 8:     // EXC_MACH_SYSCALL
+        case 9:     // EXC_RPC_ALERT
+        case 10:    // EXC_CRASH
+            break;
+        }
+        
+        return StopInfoSP(new StopInfoMachException (thread, exc_type, exc_data_count, exc_code, exc_sub_code));
+    }
+    return StopInfoSP();
+}
diff --git a/lldb/source/Plugins/Process/Utility/StopInfoMachException.h b/lldb/source/Plugins/Process/Utility/StopInfoMachException.h
new file mode 100644
index 00000000000..f9036a47169
--- /dev/null
+++ b/lldb/source/Plugins/Process/Utility/StopInfoMachException.h
@@ -0,0 +1,75 @@
+//===-- StopInfoMachException.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_StopInfoMachException_h_
+#define liblldb_StopInfoMachException_h_
+
+// C Includes
+// C++ Includes
+#include <string>
+
+// Other libraries and framework includes
+// Project includes
+#include "lldb/Target/StopInfo.h"
+
+namespace lldb_private {
+
+class StopInfoMachException : public StopInfo
+{
+public:
+    //------------------------------------------------------------------
+    // Constructors and Destructors
+    //------------------------------------------------------------------
+    StopInfoMachException (Thread &thread, 
+                           uint32_t exc_type, 
+                           uint32_t exc_data_count,
+                           uint64_t exc_code, 
+                           uint64_t exc_subcode) :
+        StopInfo (thread, exc_type),
+        m_exc_data_count (exc_data_count),
+        m_exc_code (exc_code),
+        m_exc_subcode (exc_subcode)
+    {
+    }
+
+    virtual ~StopInfoMachException()
+    {
+    }
+
+
+    virtual lldb::StopReason
+    GetStopReason () const
+    {
+        return lldb::eStopReasonException;
+    }
+
+    virtual const char *
+    GetDescription ();
+
+    // Since some mach exceptions will be reported as breakpoints, signals,
+    // or trace, we use this static accessor which will translate the mach
+    // exception into the correct StopInfo.
+    static lldb::StopInfoSP
+    CreateStopReasonWithMachException (Thread &thread, 
+                                       uint32_t exc_type, 
+                                       uint32_t exc_data_count,
+                                       uint64_t exc_code, 
+                                       uint64_t exc_subcode);
+    
+protected:
+    uint32_t m_exc_data_count;
+    uint64_t m_exc_code;
+    uint64_t m_exc_subcode;
+    std::string m_description;
+};
+
+
+} // namespace lldb_private
+
+#endif  // liblldb_StopInfoMachException_h_
diff --git a/lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp b/lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp
index 2bb7a1033a4..759f20dafb4 100644
--- a/lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp
+++ b/lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp
@@ -46,6 +46,8 @@
 #include "ProcessGDBRemoteLog.h"
 #include "ThreadGDBRemote.h"
 #include "MacOSXLibunwindCallbacks.h"
+#include "StopInfoMachException.h"
+
 
 
 #define DEBUGSERVER_BASENAME    "debugserver"
@@ -1021,21 +1023,24 @@ ProcessGDBRemote::SetThreadStopInfo (StringExtractor& stop_packet)
 
                 gdb_thread->SetThreadDispatchQAddr (thread_dispatch_qaddr);
                 gdb_thread->SetName (thread_name.empty() ? thread_name.c_str() : NULL);
-                Thread::StopInfo& stop_info = gdb_thread->GetStopInfoRef();
-                gdb_thread->SetStopInfoStopID (GetStopID());
                 if (exc_type != 0)
                 {
-                    stop_info.SetStopReasonWithMachException (exc_type, 
-                                                              exc_data.size(), 
-                                                              &exc_data[0]);
+                    const size_t exc_data_count = exc_data.size();
+
+                    gdb_thread->SetStopInfo (StopInfoMachException::CreateStopReasonWithMachException (*thread_sp,
+                                                                                                       exc_type, 
+                                                                                                       exc_data_count,
+                                                                                                       exc_data_count >= 1 ? exc_data[0] : 0,
+                                                                                                       exc_data_count >= 2 ? exc_data[1] : 0));
                 }
                 else if (signo)
                 {
-                    stop_info.SetStopReasonWithSignal (signo);
+                    gdb_thread->SetStopInfo (StopInfo::CreateStopReasonWithSignal (*thread_sp, signo));
                 }
                 else
                 {
-                    stop_info.SetStopReasonToNone ();
+                    StopInfoSP invalid_stop_info_sp;
+                    gdb_thread->SetStopInfo (invalid_stop_info_sp);
                 }
             }
             return eStateStopped;
diff --git a/lldb/source/Plugins/Process/gdb-remote/ThreadGDBRemote.cpp b/lldb/source/Plugins/Process/gdb-remote/ThreadGDBRemote.cpp
index 4eae1e6d41b..6f7cf7bc4fd 100644
--- a/lldb/source/Plugins/Process/gdb-remote/ThreadGDBRemote.cpp
+++ b/lldb/source/Plugins/Process/gdb-remote/ThreadGDBRemote.cpp
@@ -15,6 +15,7 @@
 #include "lldb/Core/StreamString.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/RegisterContext.h"
+#include "lldb/Target/StopInfo.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Unwind.h"
 #include "lldb/Breakpoint/WatchpointLocation.h"
@@ -35,8 +36,6 @@ using namespace lldb_private;
 
 ThreadGDBRemote::ThreadGDBRemote (ProcessGDBRemote &process, lldb::tid_t tid) :
     Thread(process, tid),
-    m_stop_info_stop_id (0),
-    m_stop_info (this),
     m_thread_name (),
     m_dispatch_queue_name (),
     m_thread_dispatch_qaddr (LLDB_INVALID_ADDRESS),
@@ -83,7 +82,7 @@ ThreadGDBRemote::WillResume (StateType resume_state)
     // TODO: cache for next time in case we can match things up??
     ClearStackFrames();
     int signo = GetResumeSignal();
-    m_stop_info.Clear();
+
     switch (resume_state)
     {
     case eStateSuspended:
@@ -269,11 +268,13 @@ ThreadGDBRemote::RestoreSaveFrameZero (const RegisterCheckpoint &checkpoint)
     return false;
 }
 
-bool
-ThreadGDBRemote::GetRawStopReason (StopInfo *stop_info)
+lldb::StopInfoSP
+ThreadGDBRemote::GetPrivateStopReason ()
 {
-    if (m_stop_info_stop_id != m_process.GetStopID())
+    if (m_actual_stop_info_sp.get() == NULL || m_actual_stop_info_sp->IsValid() == false)
     {
+        m_actual_stop_info_sp.reset();
+
         char packet[256];
         ::snprintf(packet, sizeof(packet), "qThreadStopInfo%x", GetID());
         StringExtractorGDBRemote stop_packet;
@@ -281,18 +282,9 @@ ThreadGDBRemote::GetRawStopReason (StopInfo *stop_info)
         {
             std::string copy(stop_packet.GetStringRef());
             GetGDBProcess().SetThreadStopInfo (stop_packet);
-            // The process should have set the stop info stop ID and also
-            // filled this thread in with valid stop info
-            if (m_stop_info_stop_id != m_process.GetStopID())
-            {
-                //ProcessGDBRemoteLog::LogIf(GDBR_LOG_THREAD, "warning: qThreadStopInfo problem: '%s' => '%s'", packet, stop_packet.GetStringRef().c_str());
-                printf("warning: qThreadStopInfo problem: '%s' => '%s'\n\torig '%s'\n", packet, stop_packet.GetStringRef().c_str(), copy.c_str()); /// REMOVE THIS
-                return false;
-            }
         }
     }
-    *stop_info = m_stop_info;
-    return true;
+    return m_actual_stop_info_sp;
 }
 
 
diff --git a/lldb/source/Plugins/Process/gdb-remote/ThreadGDBRemote.h b/lldb/source/Plugins/Process/gdb-remote/ThreadGDBRemote.h
index d40c2e1f6ab..01c37d8b5df 100644
--- a/lldb/source/Plugins/Process/gdb-remote/ThreadGDBRemote.h
+++ b/lldb/source/Plugins/Process/gdb-remote/ThreadGDBRemote.h
@@ -87,22 +87,10 @@ public:
     const char *
     GetBasicInfoAsString ();
 
-    lldb_private::Thread::StopInfo &
-    GetStopInfoRef ()
-    {
-        return m_stop_info;
-    }
-
-    uint32_t
-    GetStopInfoStopID()
-    {
-        return m_stop_info_stop_id;
-    }
-
     void
-    SetStopInfoStopID (uint32_t stop_id)
+    SetStopInfo (const lldb::StopInfoSP &stop_info)
     {
-        m_stop_info_stop_id = stop_id;
+        m_actual_stop_info_sp = stop_info;
     }
 
     void
@@ -130,8 +118,6 @@ protected:
     //------------------------------------------------------------------
     // Member variables.
     //------------------------------------------------------------------
-    uint32_t m_stop_info_stop_id;
-    lldb_private::Thread::StopInfo m_stop_info;
     std::string m_thread_name;
     std::string m_dispatch_queue_name;
     lldb::addr_t m_thread_dispatch_qaddr;
@@ -146,8 +132,8 @@ protected:
     void
     SetStopInfoFromPacket (StringExtractor &stop_packet, uint32_t stop_id);
 
-    virtual bool
-    GetRawStopReason (StopInfo *stop_info);
+    virtual lldb::StopInfoSP
+    GetPrivateStopReason ();
 
 
 };