Handle old style 'S' packet correctly

[bhushan]

Summary

This patch fixes couple of issues described below:

1. A thread tries to lock a mutex which is already locked. This happens in ProcessGDBRemote.cpp

ProcessGDBRemote::RefreshStateAfterStop ()

• • locks m_last_stop_packet_mutex
  • access packet stack to get the stop info and
  • call SetThreadStopInfo(stop_info)
• calls UpdateThreadIDList() to get the thread list if the response is old style 'S' packet which does not provide the thread information.

		  This causes a problem because UpdateThreadIDList() again tries to aquire a lock on m_last_stop_packet_mutex (which is already locked).

This patch fixes this issue by changing the Type of m_last_stop_packet_mutex to eMutexTypeRecursive so that the same thread can enter the mutex recursively.

2. The old style 'S' packet isn't handled correctly.

This patch fixes this issue by updating a thread list before the stop packet is parsed so that it can get a valid thread id and allows to set the stop info correctly.

[clayborg]

Looks good.

[bhushan]

Closed by Commit rL243091

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

 //----------------------------------------------------------------------
 // ProcessGDBRemote constructor
 //----------------------------------------------------------------------
 ProcessGDBRemote::ProcessGDBRemote(Target& target, Listener &listener) :
     Process (target, listener),
     m_flags (0),
     m_gdb_comm (),
     m_debugserver_pid (LLDB_INVALID_PROCESS_ID),
-    m_last_stop_packet_mutex (Mutex::eMutexTypeNormal),
+    m_last_stop_packet_mutex (Mutex::eMutexTypeRecursive),
     m_register_info (),
     m_async_broadcaster (NULL, "lldb.process.gdb-remote.async-broadcaster"),
     m_async_thread_state_mutex(Mutex::eMutexTypeRecursive),
     m_thread_ids (),
     m_jstopinfo_sp (),
     m_jthreadsinfo_sp (),
     m_continue_c_tids (),
     m_continue_C_tids (),
case 'S':
                 else if (key.size() == 2 && ::isxdigit(key[0]) && ::isxdigit(key[1]))
                 {
                     uint32_t reg = StringConvert::ToUInt32 (key.c_str(), UINT32_MAX, 16);
                     if (reg != UINT32_MAX)
                         expedited_register_map[reg] = std::move(value);
                 }
             }
 
+            if (tid == LLDB_INVALID_THREAD_ID)
+            {
+                // A thread id may be invalid if the response is old style 'S' packet which does not provide the 
+                // thread information. So update the thread list and choose the first one.
+                UpdateThreadIDList ();
+
+                tid = m_thread_ids.front ();
+            }
+
             ThreadSP thread_sp = SetThreadStopInfo (tid,
                                                     expedited_register_map,
                                                     signo,
                                                     thread_name,
                                                     reason,
                                                     description,
                                                     exc_type,
                                                     exc_data,
                                                     thread_dispatch_qaddr,
                                                     queue_vars_valid,
                                                     queue_name,
                                                     queue_kind,
                                                     queue_serial);
 
-            // If the response is old style 'S' packet which does not provide us with thread information
-            // then update the thread list and choose the first one.
-            if (!thread_sp)
-            {
-                UpdateThreadIDList ();
-
-                if (!m_thread_ids.empty ())
-                {
-                    Mutex::Locker locker (m_thread_list_real.GetMutex ());
-                    thread_sp = m_thread_list_real.FindThreadByProtocolID (m_thread_ids.front (), false);
-                }
-            }
-
             return eStateStopped;
         }
         break;
 
     case 'W':
     case 'X':
         // process exited
         return eStateExited;