Add jThreadsInfo support to lldb-server

[labath]

Summary

This commit adds initial support for the jThreadsInfo packet to lldb-server. The current
implementation does not expedite inferior memory. It also does not send over all GPR, but only
the most important ones (PC, SP, FP, RA), as for some reasons writing the registers is incredibly
slow in lldb-server (I intend to investigate this further). Nevertheless, this implementation
speeds up stepping of a heavily multi-threaded inferior significantly (about 50%).

I have also added a description of the new packet to our protocol documentation (mostly taken
from Greg's earlier commit message).

[labath]

• Rename a function to reflect it is not (yet) sending out all GPRs

[tberghammer]

Generally looks good, but please clarify the format of the jThreads packet

docs/lldb-gdb-remote.txt

1555–1575

What are the format of the register numbers? In the stop replay packets the register number is 2 hex digit, but here it looks like as it is decimal. If they are different then please emphasize it (until we can make it uniform)

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

470–472

The register numbers have uint32_t types

473

(nit): make_shared

506

(nit): make_shared

2717

(nit): make_shared

2761

(nit): make_shared

[labath]

• Address review comments

docs/lldb-gdb-remote.txt

1555–1575

I have added wording to confirm that they are decimal. This is not consistent with the stop-reply packet, but it is consistent with (most of) our other uses of json, where we write the numbers in decimal format. (JSON does not support hex notation, and the quotes are there because dictionary keys must be strings.) Not ideal, but that's what it is...

[tberghammer]

Looks good

docs/lldb-gdb-remote.txt

1555–1575

I would prefer to use hex numbers to be consistent with the stop reply packet but that change is out of scope for this change. The missing support for hex isn't an issue here because of the quotes.

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

499–501

(nit): You can use std::to_string(regindex)

[jasonmolenda]

docs/lldb-gdb-remote.txt

1555–1575

I agree with Tamas, the number-base assumptions in gdb-remote numbers are a nightmare; at this point even decimal can be misconstrued as hex. I'd rather we just make it explicitly hex -- so instead of "14":, "0xe":.

I'm not a huge fan of sending back the registers as a series of bytes in target-native-endian order like this,

+ "5":"d8f8bf5fff7f0000",

I'd push for sending this back as a native JSON number object, so "0x5":140734799804632 but this would cause problems if we try to transfer a 16-byte (or larger) vector register value - lldb's JSON parser is only designed to handle 64-bit integer values, as are most others I would expect - so maybe we have to live with this. I'd argue for transposing to big-endian order but when we send the expedited memory contents we need to send those in target native endian order.

tl;dr: At least let's make the register numbers base 16 and prefixed with "0x".

[jasonmolenda]

docs/lldb-gdb-remote.txt

1555–1575

Thinking about the value part of the register set, we can allow for both types of returns. e.g. both of these could be allowed:

"0xe":"d8f8bf5fff7f0000"
"0xe":140734799804632

If the value is a string, it is a series of hex bytes in target-native-endian order. If the value is an integer, it is an integer.

Once these are in a StructuredData object, lldb can detect whether the value is a string or integer and decode as appropriate.

debugserver could return integers for 64-bits-and-less register values, strings of raw bytes for vector regs.

[labath]

docs/lldb-gdb-remote.txt

1555–1575

I agree with Tamas, the number-base assumptions in gdb-remote numbers are a nightmare; at this point even decimal can be misconstrued as hex. I'd rather we just make it explicitly hex -- so instead of "14":, "0xe":.

I understand the sentiment. We could potentially implement it this way. How do you think this should be handled from a protocol specification language standpoint? I am asking because including a specific base prefix can lead people to believe they can pass any base number they want (decimal, octal?). Or should we say the number MUST be hex and MUST have 0x prefix?

I'd push for sending this back as a native JSON number object, so "0x5":140734799804632 but this would cause problems if we try to transfer a 16-byte (or larger) vector register value - lldb's JSON parser is only designed to handle 64-bit integer values, as are most others I would expect - so maybe we have to live with this. I'd argue for transposing to big-endian order but when we send the expedited memory contents we need to send those in target native endian order.

I would keep the register endianness as is, precisely because of vector registers. Since they contain multiple values, the whole register does not have a specific endianness, only the individual values do. If you now go around reversing the register byte-by-byte, you will produce something very odd. And reversing the individual parts sounds very fragile.

Also, I think the memory read is a completely separate issue. I think of the memory reads as a sequence of bytes -- it doesn't have endianness in the same way that an char[] doesn't have endianness until you know what is actually stored in there.

If the value is a string, it is a series of hex bytes in target-native-endian order. If the value is an integer, it is an integer.

I think increasing the number of formats will only add more confusion here. Sticking with one format, whatever it may be, is a much better option in my view.

[tberghammer]

docs/lldb-gdb-remote.txt

1555–1575

My primary opinion is we should keep the format as consistent with the stop reply packet as possible so both information can be treated just as a list of "key:value" pairs with the same list of keys. From the readers perspective it isn't trivial to understand but I prefer consistency over local readability.

I don't like the idea of sending the register values as a number because if somebody just reads the packet then a decimal number usually don't mean anything and it isn't easier to parse it in the code. For me it is quite natural that we send the register values as hex data without the "0x" prefix but probably because we do it in LLDB quite a lot.

If we are changing the format of this packet I would like to see 2 more changes.

• Instead of a list of thread infos send back an object where the keys are the thread ids (as string) and the value is the current data content (without thread id)
• Move out the "memory" section from the thread specific object to the top level scope (e.g. to the same level where we have the tids as keys if we make the other change) because that info is valid at process level. It might also help in decreasing the amount of memory we are transferring with eliminating some redundancy.

[ovyalov]

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

470

s/constexpr/const for compatibility with Visual Studio?

471

What do you think about having #ifdef/#else branching to cover both of them - full set of registers and pruned?
I'd rather keep new functionality and optimizations in separate CLs - for example, if later, down the road we'll realize that have to send a full set of registers then only a CL that enables pruned set of registers should be reverted.

521

No need to have 'break' here.

[labath]

docs/lldb-gdb-remote.txt

1555–1575

The two changes seem reasonable, and in fact I was considering making them along with some other changes, but I would not want to make them a part of this patch. I propose to keep the packet as is, and I will float an email to lldb-dev later with more thoughts.

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

470

I was not aware of this limitation. Will do.

471

Sure, sounds reasonable. I'll put the full register set in this patch, and I will submit a new one with the reduced set shortly.

[labath]

• Address review comments
• Send full register set.

[clayborg]

Very nice. Glad to see it speeds things up as well!

[ovyalov]

LGTM

[tberghammer]

docs/lldb-gdb-remote.txt

1555–1575

I agree that it shouldn't be part of this patch

docs/lldb-gdb-remote.txt

 // be returned in a couple hundred kilobytes in JSON format from the remote
 // debugserver.
 //
 //
 // PRIORITY TO IMPLEMENT
 //  Low.  If this packet is absent, lldb will read the Mach-O headers/load
 //  commands out of memory.
 //----------------------------------------------------------------------
+
+//----------------------------------------------------------------------
+// "jThreadsInfo"
+//
+// BRIEF
+//  Ask for the server for thread stop information of all threads.
+//
+// PRIORITY TO IMPLEMENT
+//  Low. This is a performance optimization, which speeds up debugging by avoiding
+//  multiple round-trips for retrieving thread information. The information from this
+//  packet can be retrieved using a combination of qThreadStopInfo and m packets.
+//----------------------------------------------------------------------
+
+The data in this packet is very similar to the stop reply packets, but is packaged in
+JSON and uses JSON arrays where applicable. The JSON output looks like:
+    [
+      { "tid":1580681,
+        "metype":6,
+        "medata":[2,0],
+        "reason":"exception",
+        "qaddr":140735118423168,
+        "registers": {
+          "0":"8000000000000000",
+          "1":"0000000000000000",
+          "2":"20fabf5fff7f0000",
+          "3":"e8f8bf5fff7f0000",
+          "4":"0100000000000000",
+          "5":"d8f8bf5fff7f0000",
+          "6":"b0f8bf5fff7f0000",
+          "7":"20f4bf5fff7f0000",
+          "8":"8000000000000000",
+          "9":"61a8db78a61500db",
+          "10":"3200000000000000",
+          "11":"4602000000000000",
+          "12":"0000000000000000",
+          "13":"0000000000000000",
+          "14":"0000000000000000",
+          "15":"0000000000000000",
+          "16":"960b000001000000",
+          "17":"0202000000000000",
+          "18":"2b00000000000000",
+          "19":"0000000000000000",
+          "20":"0000000000000000"
+        },
+        "memory":[
+          {"address":140734799804592,"bytes":"c8f8bf5fff7f0000c9a59e8cff7f0000"},
+          {"address":140734799804616,"bytes":"00000000000000000100000000000000"}
+        ]
+      }
+    ]
+
+It contains an array of dictionaries with all of the key value pairs that are
+normally in the stop reply packet, including the expedited registers. The registers are
+passed as hex-encoded JSON string in debuggee-endian byte order. Notice that
+is also contains expedited memory in the "memory" key.  This allows the server to
+expedite memory that the client is likely to use (e.g., areas around the
+stack pointer, which are needed for computing backtraces) and it reduces the packet
+count.
+
+On MacOSX with debugserver, we expedite the frame pointer backchain for a thread
+(up to 256 entries) by reading 2 pointers worth of bytes at the frame pointer (for
+the previous FP and PC), and follow the backchain. Most backtraces on MacOSX and
+iOS now don't require us to read any memory!

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

protected:
 
     PacketResult
     Handle_D (StringExtractorGDBRemote &packet);
 
     PacketResult
     Handle_qThreadStopInfo (StringExtractorGDBRemote &packet);
 
     PacketResult
+    Handle_jThreadsInfo (StringExtractorGDBRemote &packet);
+
+    PacketResult
     Handle_qWatchpointSupportInfo (StringExtractorGDBRemote &packet);
 
     PacketResult
     Handle_qFileLoadAddress (StringExtractorGDBRemote &packet);
 
     void
     SetCurrentThreadID (lldb::tid_t tid);
 

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

 #include "lldb/Host/StringConvert.h"
 #include "lldb/Host/TimeValue.h"
 #include "lldb/Target/FileAction.h"
 #include "lldb/Target/MemoryRegionInfo.h"
 #include "lldb/Target/Platform.h"
 #include "lldb/Host/common/NativeRegisterContext.h"
 #include "lldb/Host/common/NativeProcessProtocol.h"
 #include "lldb/Host/common/NativeThreadProtocol.h"
+#include "lldb/Utility/JSON.h"
 
 // Project includes
 #include "Utility/StringExtractorGDBRemote.h"
 #include "Utility/UriParser.h"
 #include "ProcessGDBRemote.h"
 #include "ProcessGDBRemoteLog.h"
 
 using namespace lldb;
GDBRemoteCommunicationServerLLGS::RegisterPacketHandlers()
     RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_QSetDisableASLR,
                                   &GDBRemoteCommunicationServerLLGS::Handle_QSetDisableASLR);
     RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_QSetWorkingDir,
                                   &GDBRemoteCommunicationServerLLGS::Handle_QSetWorkingDir);
     RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_qsThreadInfo,
                                   &GDBRemoteCommunicationServerLLGS::Handle_qsThreadInfo);
     RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_qThreadStopInfo,
                                   &GDBRemoteCommunicationServerLLGS::Handle_qThreadStopInfo);
+    RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_jThreadsInfo,
+                                  &GDBRemoteCommunicationServerLLGS::Handle_jThreadsInfo);
     RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_qWatchpointSupportInfo,
                                   &GDBRemoteCommunicationServerLLGS::Handle_qWatchpointSupportInfo);
     RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_qXfer_auxv_read,
                                   &GDBRemoteCommunicationServerLLGS::Handle_qXfer_auxv_read);
     RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_s,
                                   &GDBRemoteCommunicationServerLLGS::Handle_s);
     RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_stop_reason,
                                   &GDBRemoteCommunicationServerLLGS::Handle_stop_reason); // ?
else
         if (reg_info.byte_size > 0)
         {
             std::basic_string<uint8_t> zeros(reg_info.byte_size, '\0');
             AppendHexValue (response, zeros.data(), zeros.size(), false);
         }
     }
 }
 
+static JSONObject::SP
+GetGPRAsJSON(NativeThreadProtocol &thread)
+{
+    Log *log (GetLogIfAnyCategoriesSet (LIBLLDB_LOG_THREAD));
+
+    NativeRegisterContextSP reg_ctx_sp = thread.GetRegisterContext ();
+    if (! reg_ctx_sp)
+        return nullptr;
+
+    static constexpr int k_expedited_registers[] = {
+        LLDB_REGNUM_GENERIC_PC, LLDB_REGNUM_GENERIC_SP, LLDB_REGNUM_GENERIC_FP, LLDB_REGNUM_GENERIC_RA
+    };
+    JSONObject::SP register_object_sp (new JSONObject);
+    for (int regnum: k_expedited_registers)
+    {
+        const uint32_t regindex =
+            reg_ctx_sp->ConvertRegisterKindToRegisterNumber(eRegisterKindGeneric, regnum);
+        if (regindex == LLDB_INVALID_REGNUM)
+            continue; // The target does not support the given register.
+
+        const RegisterInfo *const reg_info_p = reg_ctx_sp->GetRegisterInfoAtIndex(regindex);
+        if (reg_info_p == nullptr)
+        {
+            if (log)
+                log->Printf("%s failed to get register info for register index %" PRIu32,
+                        __FUNCTION__, regindex);
+            continue;
+        }
+
+        RegisterValue reg_value;
+        Error error = reg_ctx_sp->ReadRegister(reg_info_p, reg_value);
+        if (error.Fail())
+        {
+            if (log)
+                log->Printf("%s failed to read register '%s' index %" PRIu32 ": %s", __FUNCTION__, reg_info_p->name ? reg_info_p->name : "<unnamed-register>", regnum, error.AsCString ());
+            continue;
+        }
+
+        StreamString stream;
+        stream.Printf("%d", regindex);
+        std::string reg_num_str = stream.GetString();
+
+        stream.Clear();
+        WriteRegisterValueInHexFixedWidth(stream, reg_ctx_sp, *reg_info_p, &reg_value);
+
+        register_object_sp->SetObject(reg_num_str, JSONString::SP(new JSONString(stream.GetString())));
+    }
+
+    return register_object_sp;
+}
+
+static const char *
+GetStopReasonString(StopReason stop_reason)
+{
+    switch (stop_reason)
+    {
+    case eStopReasonTrace:
+        return "trace";
+    case eStopReasonBreakpoint:
+        return "breakpoint";
+        break;
+    case eStopReasonWatchpoint:
+        return "watchpoint";
+    case eStopReasonSignal:
+        return "signal";
+    case eStopReasonException:
+        return "exception";
+    case eStopReasonExec:
+        return "exec";
+    case eStopReasonInstrumentation:
+    case eStopReasonInvalid:
+    case eStopReasonPlanComplete:
+    case eStopReasonThreadExiting:
+    case eStopReasonNone:
+        break; // ignored
+    }
+    return nullptr;
+}
+
 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 (reg_ctx_sp)
                             log->Printf ("GDBRemoteCommunicationServerLLGS::%s failed to read register '%s' index %" PRIu32 ": %s", __FUNCTION__, reg_info_p->name ? reg_info_p->name : "<unnamed-register>", *reg_num_p, error.AsCString ());
 
                     }
                 }
             }
         }
     }
 
-    const char* reason_str = nullptr;
-    switch (tid_stop_info.reason)
-    {
-    case eStopReasonTrace:
-        reason_str = "trace";
-        break;
-    case eStopReasonBreakpoint:
-        reason_str = "breakpoint";
-        break;
-    case eStopReasonWatchpoint:
-        reason_str = "watchpoint";
-        break;
-    case eStopReasonSignal:
-        reason_str = "signal";
-        break;
-    case eStopReasonException:
-        reason_str = "exception";
-        break;
-    case eStopReasonExec:
-        reason_str = "exec";
-        break;
-    case eStopReasonInstrumentation:
-    case eStopReasonInvalid:
-    case eStopReasonPlanComplete:
-    case eStopReasonThreadExiting:
-    case eStopReasonNone:
-        break;
-    }
+    const char* reason_str = GetStopReasonString(tid_stop_info.reason);
     if (reason_str != nullptr)
     {
         response.Printf ("reason:%s;", reason_str);
     }
 
     if (!description.empty())
     {
         // Description may contains special chars, send as hex bytes.
if (tid == LLDB_INVALID_THREAD_ID)
         if (log)
             log->Printf ("GDBRemoteCommunicationServerLLGS::%s failed, could not parse thread id from request \"%s\"", __FUNCTION__, packet.GetStringRef ().c_str ());
         return SendErrorResponse (0x15);
     }
     return SendStopReplyPacketForThread (tid);
 }
 
 GDBRemoteCommunication::PacketResult
+GDBRemoteCommunicationServerLLGS::Handle_jThreadsInfo (StringExtractorGDBRemote &)
+{
+    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 (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)
+    {
+
+        JSONObject::SP thread_obj_sp (new 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 = GetGPRAsJSON(*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 (new 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);
+    }
+    // TODO: Expedite interesting regions of inferior memory
+
+    StreamString response;
+    threads_array.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)
 {
     // Fail if we don't have a current process.
     if (!m_debugged_process_sp ||
             m_debugged_process_sp->GetID () == LLDB_INVALID_PROCESS_ID)
         return SendErrorResponse (68);
 
     packet.SetFilePos(strlen("qWatchpointSupportInfo"));

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

 
 Error
 ProcessGDBRemote::WillResume ()
 {
     m_continue_c_tids.clear();
     m_continue_C_tids.clear();
     m_continue_s_tids.clear();
     m_continue_S_tids.clear();
+    m_threads_info_sp.reset();
     return Error();
 }
 
 Error
 ProcessGDBRemote::DoResume ()
 {
     Error error;
     Log *log (ProcessGDBRemoteLog::GetLogIfAllCategoriesSet (GDBR_LOG_PROCESS));
ProcessGDBRemote::SetThreadStopInfo (StructuredData::Dictionary *thread_dict)
     static ConstString g_key_queue_name("qname");
     static ConstString g_key_queue_kind("qkind");
     static ConstString g_key_queue_serial("qserial");
     static ConstString g_key_registers("registers");
     static ConstString g_key_memory("memory");
     static ConstString g_key_address("address");
     static ConstString g_key_bytes("bytes");
     static ConstString g_key_description("description");
+    static ConstString g_key_signal("signal");
 
     // Stop with signal and thread info
     lldb::tid_t tid = LLDB_INVALID_THREAD_ID;
     uint8_t signo = 0;
     std::string value;
     std::string thread_name;
     std::string reason;
     std::string description;
thread_dict->ForEach([this,
                             }
                         }
                     }
                     return true; // Keep iterating through all array items
                 });
             }
 
         }
+        else if (key == g_key_signal)
+            signo = object->GetIntegerValue(LLDB_INVALID_SIGNAL_NUMBER);
         return true; // Keep iterating through all dictionary key/value pairs
     });
 
     SetThreadStopInfo (tid,
                        expedited_register_map,
                        signo,
                        thread_name,
                        reason,

source/Utility/StringExtractorGDBRemote.h

enum ServerPacketType
         eServerPacketType_QSaveRegisterState,
         eServerPacketType_QSetLogging,
         eServerPacketType_QSetMaxPacketSize,
         eServerPacketType_QSetMaxPayloadSize,
         eServerPacketType_QSetEnableAsyncProfiling,
         eServerPacketType_QSyncThreadState,
         eServerPacketType_QThreadSuffixSupported,
 
+        eServerPacketType_jThreadsInfo,
         eServerPacketType_qsThreadInfo,
         eServerPacketType_qfThreadInfo,
         eServerPacketType_qGetPid,
         eServerPacketType_qGetProfileData,
         eServerPacketType_qGDBServerVersion,
         eServerPacketType_qMemoryRegionInfo,
         eServerPacketType_qMemoryRegionInfoSupported,
         eServerPacketType_qProcessInfo,

source/Utility/StringExtractorGDBRemote.cpp

case 'q':
 
         case 'X':
             if (PACKET_STARTS_WITH ("qXfer:auxv:read::"))       return eServerPacketType_qXfer_auxv_read;
             break;
         }
         break;
 
     case 'j':
-        if (PACKET_MATCHES("jSignalInfo")) return eServerPacketType_jSignalsInfo;
+        if (PACKET_MATCHES("jSignalInfo"))                      return eServerPacketType_jSignalsInfo;
+        if (PACKET_MATCHES("jThreadsInfo"))                     return eServerPacketType_jThreadsInfo;
+
 
     case 'v':
             if (PACKET_STARTS_WITH("vFile:"))
             {
                 if (PACKET_STARTS_WITH("vFile:open:"))          return eServerPacketType_vFile_open;
                 else if (PACKET_STARTS_WITH("vFile:close:"))    return eServerPacketType_vFile_close;
                 else if (PACKET_STARTS_WITH("vFile:pread"))     return eServerPacketType_vFile_pread;
                 else if (PACKET_STARTS_WITH("vFile:pwrite"))    return eServerPacketType_vFile_pwrite;

test/functionalities/thread/concurrent_events/TestConcurrentEvents.py

def do_thread_actions(self,
 
             num_threads = self.inferior_process.GetNumThreads()
             self.assertEqual(1, num_threads, "Expecting 1 thread but seeing %d. Details:%s" % (num_threads,
                                                                                              "\n\t".join(self.describe_threads())))
             self.runCmd("continue")
 
             # The inferior process should have exited without crashing
             self.assertEqual(0, self.crash_count, "Unexpected thread(s) in crashed state")
-            self.assertTrue(self.inferior_process.GetState() == lldb.eStateExited, PROCESS_EXITED)
+            self.assertEqual(self.inferior_process.GetState(), lldb.eStateExited, PROCESS_EXITED)
 
             # Verify the number of actions took place matches expected numbers
             expected_breakpoint_threads = num_delay_breakpoint_threads + num_breakpoint_threads
             breakpoint_hit_count = self.thread_breakpoint.GetHitCount() if expected_breakpoint_threads > 0 else 0
             self.assertEqual(expected_breakpoint_threads, breakpoint_hit_count,
                 "Expected %d breakpoint hits, but got %d" % (expected_breakpoint_threads, breakpoint_hit_count))
 
             expected_signal_threads = num_delay_signal_threads + num_signal_threads