Add jstopinfo support to llgs

[labath]

Summary

This adds support for jstopinfo field of stop-reply packets. This field enables us to avoid
querying full thread stop data on most stops (see r242593 for more details).

[clayborg]

Looks good.

[ovyalov]

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

720

Nit: if (thread_index > 0)? In this case no to acquire NativeProcessProtocol::m_threads_mutex

723

Could you check for threads_info_sp != nullptr?

source/Plugins/Process/Linux/NativeProcessLinux.cpp

if (is_from_llgs && (info->si_code == SI_TKILL) && (signo == SIGSTOP))
                 // they are just used to stop other threads when one thread (the one with the
                 // *real* stop reason) hits a breakpoint (watchpoint, etc...). However, in the
                 // case of an asynchronous Interrupt(), this *is* the real stop reason, so we
                 // leave the signal intact if this is the thread that was chosen as the
                 // triggering thread.
                 if (m_pending_notification_up && m_pending_notification_up->triggering_tid == pid)
                     linux_thread_sp->SetStoppedBySignal(SIGSTOP, info);
                 else
-                    linux_thread_sp->SetStoppedBySignal(0);
+                    linux_thread_sp->SetStoppedWithNoReason();
 
                 SetCurrentThreadID (thread_sp->GetID ());
                 ThreadDidStop (thread_sp->GetID (), true);
             }
             else
             {
                 if (log)
                 {

source/Plugins/Process/Linux/NativeThreadLinux.h

private:
 
         bool
         IsStoppedAtWatchpoint ();
 
         void
         SetStoppedByTrace ();
 
         void
-        SetCrashedWithException (const siginfo_t& info);
-
-        void
-        SetSuspended ();
+        SetStoppedWithNoReason ();
 
         void
         SetExited ();
 
         Error
         RequestStop ();
 
         typedef std::function<Error (lldb::tid_t tid, bool supress_signal)> ResumeThreadFunction;

source/Plugins/Process/Linux/NativeThreadLinux.cpp

NativeThreadLinux::SetStoppedByTrace ()
     MaybeLogStateChange (new_state);
     m_state = new_state;
 
     m_stop_info.reason = StopReason::eStopReasonTrace;
     m_stop_info.details.signal.signo = SIGTRAP;
 }
 
 void
-NativeThreadLinux::SetSuspended ()
+NativeThreadLinux::SetStoppedWithNoReason ()
 {
-    const StateType new_state = StateType::eStateSuspended;
+    const StateType new_state = StateType::eStateStopped;
     MaybeLogStateChange (new_state);
     m_state = new_state;
 
-    // FIXME what makes sense here? Do we need a suspended StopReason?
     m_stop_info.reason = StopReason::eStopReasonNone;
+    m_stop_info.details.signal.signo = 0;
 }
 
 void
 NativeThreadLinux::SetExited ()
 {
     const StateType new_state = StateType::eStateExited;
     MaybeLogStateChange (new_state);
     m_state = new_state;

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

GetStopReasonString(StopReason stop_reason)
     case eStopReasonPlanComplete:
     case eStopReasonThreadExiting:
     case eStopReasonNone:
         break; // ignored
     }
     return nullptr;
 }
 
+static JSONArray::SP
+GetJSONThreadsInfo(NativeProcessProtocol &process, bool threads_with_valid_stop_info_only)
+{
+    Log *log (GetLogIfAnyCategoriesSet (LIBLLDB_LOG_PROCESS | LIBLLDB_LOG_THREAD));
+
+    JSONArray::SP threads_array_sp = std::make_shared<JSONArray>();
+
+    // Ensure we can get info on the given thread.
+    uint32_t thread_idx = 0;
+    for ( NativeThreadProtocolSP thread_sp;
+          (thread_sp = process.GetThreadAtIndex(thread_idx)) != nullptr;
+          ++thread_idx)
+    {
+
+        lldb::tid_t tid = thread_sp->GetID();
+
+        // Grab the reason this thread stopped.
+        struct ThreadStopInfo tid_stop_info;
+        std::string description;
+        if (!thread_sp->GetStopReason (tid_stop_info, description))
+            return nullptr;
+
+        const int signum = tid_stop_info.details.signal.signo;
+        if (log)
+        {
+            log->Printf ("GDBRemoteCommunicationServerLLGS::%s pid %" PRIu64 " tid %" PRIu64 " got signal signo = %d, reason = %d, exc_type = %" PRIu64,
+                    __FUNCTION__,
+                    process.GetID (),
+                    tid,
+                    signum,
+                    tid_stop_info.reason,
+                    tid_stop_info.details.exception.type);
+        }
+
+        if (threads_with_valid_stop_info_only && tid_stop_info.reason == eStopReasonNone)
+            continue; // No stop reason, skip this thread completely.
+
+        JSONObject::SP thread_obj_sp = std::make_shared<JSONObject>();
+        threads_array_sp->AppendObject(thread_obj_sp);
+
+        thread_obj_sp->SetObject("tid", std::make_shared<JSONNumber>(tid));
+        if (signum != 0)
+            thread_obj_sp->SetObject("signal", std::make_shared<JSONNumber>(uint64_t(signum)));
+
+        const std::string thread_name = thread_sp->GetName ();
+        if (! thread_name.empty())
+            thread_obj_sp->SetObject("name", std::make_shared<JSONString>(thread_name));
+
+        if (const char *stop_reason_str = GetStopReasonString(tid_stop_info.reason))
+            thread_obj_sp->SetObject("reason", std::make_shared<JSONString>(stop_reason_str));
+
+        if (! description.empty())
+            thread_obj_sp->SetObject("description", std::make_shared<JSONString>(description));
+
+        if ((tid_stop_info.reason == eStopReasonException) && tid_stop_info.details.exception.type)
+        {
+            thread_obj_sp->SetObject("metype",
+                    std::make_shared<JSONNumber>(tid_stop_info.details.exception.type));
+
+            JSONArray::SP medata_array_sp = std::make_shared<JSONArray>();
+            for (uint32_t i = 0; i < tid_stop_info.details.exception.data_count; ++i)
+            {
+                medata_array_sp->AppendObject(std::make_shared<JSONNumber>(
+                            tid_stop_info.details.exception.data[i]));
+            }
+            thread_obj_sp->SetObject("medata", medata_array_sp);
+        }
+
+        if (threads_with_valid_stop_info_only)
+            continue; // Only send the abridged stop info.
+
+        if (JSONObject::SP registers_sp = GetRegistersAsJSON(*thread_sp))
+            thread_obj_sp->SetObject("registers", registers_sp);
+
+        // TODO: Expedite interesting regions of inferior memory
+    }
+
+    return threads_array_sp;
+}
+
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServerLLGS::SendStopReplyPacketForThread (lldb::tid_t tid)
 {
     Log *log (GetLogIfAnyCategoriesSet (LIBLLDB_LOG_PROCESS | LIBLLDB_LOG_THREAD));
 
     // Ensure we have a debugged process.
     if (!m_debugged_process_sp || (m_debugged_process_sp->GetID () == LLDB_INVALID_PROCESS_ID))
         return SendErrorResponse (50);
if (m_list_threads_in_stop_reply)
         NativeThreadProtocolSP listed_thread_sp;
         for (listed_thread_sp = m_debugged_process_sp->GetThreadAtIndex (thread_index); listed_thread_sp; ++thread_index, listed_thread_sp = m_debugged_process_sp->GetThreadAtIndex (thread_index))
         {
             if (thread_index > 0)
                 response.PutChar (',');
             response.Printf ("%" PRIx64, listed_thread_sp->GetID ());
         }
         response.PutChar (';');
+
+        // Include JSON info that describes the stop reason for any threads
+        // that actually have stop reasons. We use the new "jstopinfo" key
+        // whose values is hex ascii JSON that contains the thread IDs
+        // thread stop info only for threads that have stop reasons. Only send
+        // this if we have more than one thread otherwise this packet has all
+        // the info it needs.
+        if (m_debugged_process_sp->GetThreadAtIndex(1))
+        {
+            const bool threads_with_valid_stop_info_only = true;
+            JSONArray::SP threads_info_sp = GetJSONThreadsInfo(*m_debugged_process_sp,
+                                                               threads_with_valid_stop_info_only);
+            response.PutCString("jstopinfo:");
+            StreamString unescaped_response;
+            threads_info_sp->Write(unescaped_response);
+            response.PutCStringAsRawHex8(unescaped_response.GetData());
+            response.PutChar(';');
+        }
     }
 
     //
     // Expedite registers.
     //
 
     // Grab the register context.
     NativeRegisterContextSP reg_ctx_sp = thread_sp->GetRegisterContext ();
GDBRemoteCommunicationServerLLGS::Handle_jThreadsInfo (StringExtractorGDBRemote &)
     // Ensure we have a debugged process.
     if (!m_debugged_process_sp || (m_debugged_process_sp->GetID () == LLDB_INVALID_PROCESS_ID))
         return SendErrorResponse (50);
 
     if (log)
         log->Printf ("GDBRemoteCommunicationServerLLGS::%s preparing packet for pid %" PRIu64,
                 __FUNCTION__, m_debugged_process_sp->GetID());
 
-    JSONArray threads_array;
 
-    // Ensure we can get info on the given thread.
-    uint32_t thread_idx = 0;
-    for ( NativeThreadProtocolSP thread_sp;
-          (thread_sp = m_debugged_process_sp->GetThreadAtIndex(thread_idx)) != nullptr;
-          ++thread_idx)
+    StreamString response;
+    const bool threads_with_valid_stop_info_only = false;
+    JSONArray::SP threads_array_sp = GetJSONThreadsInfo(*m_debugged_process_sp,
+                                                        threads_with_valid_stop_info_only);
+    if (! threads_array_sp)
     {
-
-        JSONObject::SP thread_obj_sp = std::make_shared<JSONObject>();
-
-        lldb::tid_t tid = thread_sp->GetID();
-
-        // Grab the reason this thread stopped.
-        struct ThreadStopInfo tid_stop_info;
-        std::string description;
-        if (!thread_sp->GetStopReason (tid_stop_info, description))
-            return SendErrorResponse (52);
-
-        const int signum = tid_stop_info.details.signal.signo;
         if (log)
-        {
-            log->Printf ("GDBRemoteCommunicationServerLLGS::%s pid %" PRIu64 " tid %" PRIu64 " got signal signo = %d, reason = %d, exc_type = %" PRIu64,
-                    __FUNCTION__,
-                    m_debugged_process_sp->GetID (),
-                    tid,
-                    signum,
-                    tid_stop_info.reason,
-                    tid_stop_info.details.exception.type);
-        }
-
-        thread_obj_sp->SetObject("tid", std::make_shared<JSONNumber>(tid));
-        if (signum != LLDB_INVALID_SIGNAL_NUMBER)
-            thread_obj_sp->SetObject("signal", std::make_shared<JSONNumber>(uint64_t(signum)));
-
-        const std::string thread_name = thread_sp->GetName ();
-        if (! thread_name.empty())
-            thread_obj_sp->SetObject("name", std::make_shared<JSONString>(thread_name));
-
-        if (JSONObject::SP registers_sp = GetRegistersAsJSON(*thread_sp))
-            thread_obj_sp->SetObject("registers", registers_sp);
-
-        if (const char *stop_reason_str = GetStopReasonString(tid_stop_info.reason))
-            thread_obj_sp->SetObject("reason", std::make_shared<JSONString>(stop_reason_str));
-
-        if (! description.empty())
-            thread_obj_sp->SetObject("description", std::make_shared<JSONString>(description));
-
-        if ((tid_stop_info.reason == eStopReasonException) && tid_stop_info.details.exception.type)
-        {
-            thread_obj_sp->SetObject("metype",
-                    std::make_shared<JSONNumber>(tid_stop_info.details.exception.type));
-
-            JSONArray::SP medata_array_sp = std::make_shared<JSONArray>();
-            for (uint32_t i = 0; i < tid_stop_info.details.exception.data_count; ++i)
-            {
-                medata_array_sp->AppendObject(std::make_shared<JSONNumber>(
-                            tid_stop_info.details.exception.data[i]));
-            }
-            thread_obj_sp->SetObject("medata", medata_array_sp);
-        }
-
-        threads_array.AppendObject(thread_obj_sp);
+            log->Printf ("GDBRemoteCommunicationServerLLGS::%s failed to prepare a packet for pid %" PRIu64,
+                    __FUNCTION__, m_debugged_process_sp->GetID());
+        return SendErrorResponse(52);
     }
-    // TODO: Expedite interesting regions of inferior memory
 
-    StreamString response;
-    threads_array.Write(response);
+    threads_array_sp->Write(response);
     StreamGDBRemote escaped_response;
     escaped_response.PutEscapedBytes(response.GetData(), response.GetSize());
     return SendPacketNoLock (escaped_response.GetData(), escaped_response.GetSize());
 }
 
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServerLLGS::Handle_qWatchpointSupportInfo (StringExtractorGDBRemote &packet)
 {