ffb2d44ab9
We have been working on reducing the packet count that is sent between LLDB and the debugserver on MacOSX and iOS. Our approach to this was to reduce the packets required when debugging multiple threads. We currently make one qThreadStopInfoXXXX call (where XXXX is the thread ID in hex) per thread except the thread that stopped with a stop reply packet. In order to implement multiple thread infos in a single reply, we need to use structured data, which means JSON. The new jThreadsInfo packet will attempt to retrieve all thread infos in a single packet. The data is very similar to the stop reply packets, but 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 dicitionaries with all of the key value pairs that are normally in the stop reply packet. Including the expedited registers. Notice that is also contains expedited memory in the "memory" key. Any values in this memory will get included in a new L1 cache in lldb_private::Process where if a memory read request is made and that memory request fits into one of the L1 memory cache blocks, it will use that memory data. If a memory request fails in the L1 cache, it will fall back to the L2 cache which is the same block sized caching we were using before these changes. This allows a process to expedite memory that you are likely to use and it reduces 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!
We will try these packets out and if successful, we should port these to lldb-server in the near future.
<rdar://problem/21494354>
llvm-svn: 240354
672 lines
21 KiB
C++
672 lines
21 KiB
C++
//===-- GDBRemoteCommunicationClient.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_GDBRemoteCommunicationClient_h_
|
|
#define liblldb_GDBRemoteCommunicationClient_h_
|
|
|
|
// C Includes
|
|
// C++ Includes
|
|
#include <vector>
|
|
|
|
// Other libraries and framework includes
|
|
// Project includes
|
|
#include "lldb/Core/ArchSpec.h"
|
|
#include "lldb/Core/StructuredData.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 (Error *error_ptr);
|
|
|
|
PacketResult
|
|
SendPacketAndWaitForResponse (const char *send_payload,
|
|
StringExtractorGDBRemote &response,
|
|
bool send_async);
|
|
|
|
PacketResult
|
|
SendPacketAndWaitForResponse (const char *send_payload,
|
|
size_t send_length,
|
|
StringExtractorGDBRemote &response,
|
|
bool send_async);
|
|
|
|
// For packets which specify a range of output to be returned,
|
|
// return all of the output via a series of request packets of the form
|
|
// <prefix>0,<size>
|
|
// <prefix><size>,<size>
|
|
// <prefix><size>*2,<size>
|
|
// <prefix><size>*3,<size>
|
|
// ...
|
|
// until a "$l..." packet is received, indicating the end.
|
|
// (size is in hex; this format is used by a standard gdbserver to
|
|
// return the given portion of the output specified by <prefix>;
|
|
// for example, "qXfer:libraries-svr4:read::fff,1000" means
|
|
// "return a chunk of the xml description file for shared
|
|
// library load addresses, where the chunk starts at offset 0xfff
|
|
// and continues for 0x1000 bytes").
|
|
// Concatenate the resulting server response packets together and
|
|
// return in response_string. If any packet fails, the return value
|
|
// indicates that failure and the returned string value is undefined.
|
|
PacketResult
|
|
SendPacketsAndConcatenateResponses (const char *send_payload_prefix,
|
|
std::string &response_string);
|
|
|
|
lldb::StateType
|
|
SendContinuePacketAndWaitForResponse (ProcessGDBRemote *process,
|
|
const char *packet_payload,
|
|
size_t packet_length,
|
|
StringExtractorGDBRemote &response);
|
|
|
|
bool
|
|
GetThreadSuffixSupported () override;
|
|
|
|
// This packet is usually sent first and the boolean return value
|
|
// indicates if the packet was send and any response was received
|
|
// even in the response is UNIMPLEMENTED. If the packet failed to
|
|
// get a response, then false is returned. This quickly tells us
|
|
// if we were able to connect and communicate with the remote GDB
|
|
// server
|
|
bool
|
|
QueryNoAckModeSupported ();
|
|
|
|
void
|
|
GetListThreadsInStopReplySupported ();
|
|
|
|
bool
|
|
SendAsyncSignal (int signo);
|
|
|
|
bool
|
|
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);
|
|
|
|
uint16_t
|
|
LaunchGDBserverAndGetPort (lldb::pid_t &pid, const char *remote_accept_hostname);
|
|
|
|
bool
|
|
KillSpawnedProcess (lldb::pid_t pid);
|
|
|
|
//------------------------------------------------------------------
|
|
/// Sends a GDB remote protocol 'A' packet that delivers program
|
|
/// arguments to the remote server.
|
|
///
|
|
/// @param[in] argv
|
|
/// A NULL terminated array of const C strings to use as the
|
|
/// arguments.
|
|
///
|
|
/// @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 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.
|
|
///
|
|
/// @param[in] name_equal_value
|
|
/// A NULL terminated C string that contains a single environment
|
|
/// in the format "NAME=VALUE".
|
|
///
|
|
/// @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
|
|
SendEnvironmentPacket (char const *name_equal_value);
|
|
|
|
int
|
|
SendLaunchArchPacket (const char *arch);
|
|
|
|
int
|
|
SendLaunchEventDataPacket (const char *data, bool *was_supported = NULL);
|
|
|
|
//------------------------------------------------------------------
|
|
/// Sends a "vAttach:PID" where PID is in hex.
|
|
///
|
|
/// @param[in] pid
|
|
/// A process ID for the remote gdb server to attach to.
|
|
///
|
|
/// @param[out] response
|
|
/// The response received from the gdb server. If the return
|
|
/// value is zero, \a response will contain a stop reply
|
|
/// packet.
|
|
///
|
|
/// @return
|
|
/// Zero if the attach was successful, or an error indicating
|
|
/// an error code.
|
|
//------------------------------------------------------------------
|
|
int
|
|
SendAttach (lldb::pid_t pid,
|
|
StringExtractorGDBRemote& response);
|
|
|
|
|
|
//------------------------------------------------------------------
|
|
/// Sends a GDB remote protocol 'I' packet that delivers stdin
|
|
/// data to the remote process.
|
|
///
|
|
/// @param[in] data
|
|
/// A pointer to stdin data.
|
|
///
|
|
/// @param[in] data_len
|
|
/// The number of bytes available at \a data.
|
|
///
|
|
/// @return
|
|
/// Zero if the attach was successful, or an error indicating
|
|
/// an error code.
|
|
//------------------------------------------------------------------
|
|
int
|
|
SendStdinNotification(const char* data, size_t data_len);
|
|
|
|
//------------------------------------------------------------------
|
|
/// Sets the path to use for stdin/out/err for a process
|
|
/// that will be launched with the 'A' packet.
|
|
///
|
|
/// @param[in] path
|
|
/// The path to use for stdin/out/err
|
|
///
|
|
/// @return
|
|
/// Zero if the for success, or an error code for failure.
|
|
//------------------------------------------------------------------
|
|
int
|
|
SetSTDIN(const FileSpec &file_spec);
|
|
int
|
|
SetSTDOUT(const FileSpec &file_spec);
|
|
int
|
|
SetSTDERR(const FileSpec &file_spec);
|
|
|
|
//------------------------------------------------------------------
|
|
/// Sets the disable ASLR flag to \a enable for a process that will
|
|
/// be launched with the 'A' packet.
|
|
///
|
|
/// @param[in] enable
|
|
/// A boolean value indicating whether to disable ASLR or not.
|
|
///
|
|
/// @return
|
|
/// Zero if the for success, or an error code for failure.
|
|
//------------------------------------------------------------------
|
|
int
|
|
SetDisableASLR (bool enable);
|
|
|
|
//------------------------------------------------------------------
|
|
/// Sets the DetachOnError flag to \a enable for the process controlled by the stub.
|
|
///
|
|
/// @param[in] enable
|
|
/// A boolean value indicating whether to detach on error or not.
|
|
///
|
|
/// @return
|
|
/// Zero if the for success, or an error code for failure.
|
|
//------------------------------------------------------------------
|
|
int
|
|
SetDetachOnError (bool enable);
|
|
|
|
//------------------------------------------------------------------
|
|
/// Sets the working directory to \a path for a process that will
|
|
/// be launched with the 'A' packet for non platform based
|
|
/// connections. If this packet is sent to a GDB server that
|
|
/// implements the platform, it will change the current working
|
|
/// directory for the platform process.
|
|
///
|
|
/// @param[in] working_dir
|
|
/// The path to a directory to use when launching our process
|
|
///
|
|
/// @return
|
|
/// Zero if the for success, or an error code for failure.
|
|
//------------------------------------------------------------------
|
|
int
|
|
SetWorkingDir(const FileSpec &working_dir);
|
|
|
|
//------------------------------------------------------------------
|
|
/// Gets the current working directory of a remote platform GDB
|
|
/// server.
|
|
///
|
|
/// @param[out] working_dir
|
|
/// The current working directory on the remote platform.
|
|
///
|
|
/// @return
|
|
/// Boolean for success
|
|
//------------------------------------------------------------------
|
|
bool
|
|
GetWorkingDir(FileSpec &working_dir);
|
|
|
|
lldb::addr_t
|
|
AllocateMemory (size_t size, uint32_t permissions);
|
|
|
|
bool
|
|
DeallocateMemory (lldb::addr_t addr);
|
|
|
|
Error
|
|
Detach (bool keep_stopped);
|
|
|
|
Error
|
|
GetMemoryRegionInfo (lldb::addr_t addr, MemoryRegionInfo &range_info);
|
|
|
|
Error
|
|
GetWatchpointSupportInfo (uint32_t &num);
|
|
|
|
Error
|
|
GetWatchpointSupportInfo (uint32_t &num, bool& after);
|
|
|
|
Error
|
|
GetWatchpointsTriggerAfterInstruction (bool &after);
|
|
|
|
const ArchSpec &
|
|
GetHostArchitecture ();
|
|
|
|
uint32_t
|
|
GetHostDefaultPacketTimeout();
|
|
|
|
const ArchSpec &
|
|
GetProcessArchitecture ();
|
|
|
|
void
|
|
GetRemoteQSupported();
|
|
|
|
bool
|
|
GetVContSupported (char flavor);
|
|
|
|
bool
|
|
GetpPacketSupported (lldb::tid_t tid);
|
|
|
|
bool
|
|
GetxPacketSupported ();
|
|
|
|
bool
|
|
GetVAttachOrWaitSupported ();
|
|
|
|
bool
|
|
GetSyncThreadStateSupported();
|
|
|
|
void
|
|
ResetDiscoverableSettings();
|
|
|
|
bool
|
|
GetHostInfo (bool force = false);
|
|
|
|
bool
|
|
GetDefaultThreadId (lldb::tid_t &tid);
|
|
|
|
bool
|
|
GetOSVersion (uint32_t &major,
|
|
uint32_t &minor,
|
|
uint32_t &update);
|
|
|
|
bool
|
|
GetOSBuildString (std::string &s);
|
|
|
|
bool
|
|
GetOSKernelDescription (std::string &s);
|
|
|
|
ArchSpec
|
|
GetSystemArchitecture ();
|
|
|
|
bool
|
|
GetHostname (std::string &s);
|
|
|
|
lldb::addr_t
|
|
GetShlibInfoAddr();
|
|
|
|
bool
|
|
GetSupportsThreadSuffix ();
|
|
|
|
bool
|
|
GetProcessInfo (lldb::pid_t pid, ProcessInstanceInfo &process_info);
|
|
|
|
uint32_t
|
|
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
|
|
HasFullVContSupport ()
|
|
{
|
|
return GetVContSupported ('A');
|
|
}
|
|
|
|
bool
|
|
HasAnyVContSupport ()
|
|
{
|
|
return GetVContSupported ('a');
|
|
}
|
|
|
|
bool
|
|
GetStopReply (StringExtractorGDBRemote &response);
|
|
|
|
bool
|
|
GetThreadStopInfo (lldb::tid_t tid,
|
|
StringExtractorGDBRemote &response);
|
|
|
|
bool
|
|
SupportsGDBStoppointPacket (GDBStoppointType type)
|
|
{
|
|
switch (type)
|
|
{
|
|
case eBreakpointSoftware: return m_supports_z0;
|
|
case eBreakpointHardware: return m_supports_z1;
|
|
case eWatchpointWrite: return m_supports_z2;
|
|
case eWatchpointRead: return m_supports_z3;
|
|
case eWatchpointReadWrite: return m_supports_z4;
|
|
default: return false;
|
|
}
|
|
}
|
|
uint8_t
|
|
SendGDBStoppointTypePacket (GDBStoppointType type, // Type of breakpoint or watchpoint
|
|
bool insert, // Insert or remove?
|
|
lldb::addr_t addr, // Address of breakpoint or watchpoint
|
|
uint32_t length); // Byte Size of breakpoint or watchpoint
|
|
|
|
bool
|
|
SetNonStopMode (const bool enable);
|
|
|
|
void
|
|
TestPacketSpeed (const uint32_t num_packets, uint32_t max_send, uint32_t max_recv, bool json, Stream &strm);
|
|
|
|
// This packet is for testing the speed of the interface only. Both
|
|
// the client and server need to support it, but this allows us to
|
|
// measure the packet speed without any other work being done on the
|
|
// other end and avoids any of that work affecting the packet send
|
|
// and response times.
|
|
bool
|
|
SendSpeedTestPacket (uint32_t send_size,
|
|
uint32_t recv_size);
|
|
|
|
bool
|
|
SetCurrentThread (uint64_t tid);
|
|
|
|
bool
|
|
SetCurrentThreadForRun (uint64_t tid);
|
|
|
|
bool
|
|
GetQXferAuxvReadSupported ();
|
|
|
|
bool
|
|
GetQXferLibrariesReadSupported ();
|
|
|
|
bool
|
|
GetQXferLibrariesSVR4ReadSupported ();
|
|
|
|
uint64_t
|
|
GetRemoteMaxPacketSize();
|
|
|
|
bool
|
|
GetEchoSupported ();
|
|
|
|
bool
|
|
GetAugmentedLibrariesSVR4ReadSupported ();
|
|
|
|
bool
|
|
GetQXferFeaturesReadSupported ();
|
|
|
|
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 FileSpec& file_spec, uint32_t flags, mode_t mode, Error &error);
|
|
|
|
bool
|
|
CloseFile (lldb::user_id_t fd, Error &error);
|
|
|
|
lldb::user_id_t
|
|
GetFileSize (const FileSpec& file_spec);
|
|
|
|
Error
|
|
GetFilePermissions(const FileSpec &file_spec, uint32_t &file_permissions);
|
|
|
|
Error
|
|
SetFilePermissions(const FileSpec &file_spec, uint32_t file_permissions);
|
|
|
|
uint64_t
|
|
ReadFile (lldb::user_id_t fd,
|
|
uint64_t offset,
|
|
void *dst,
|
|
uint64_t dst_len,
|
|
Error &error);
|
|
|
|
uint64_t
|
|
WriteFile (lldb::user_id_t fd,
|
|
uint64_t offset,
|
|
const void* src,
|
|
uint64_t src_len,
|
|
Error &error);
|
|
|
|
Error
|
|
CreateSymlink(const FileSpec &src,
|
|
const FileSpec &dst);
|
|
|
|
Error
|
|
Unlink(const FileSpec &file_spec);
|
|
|
|
Error
|
|
MakeDirectory(const FileSpec &file_spec, uint32_t mode);
|
|
|
|
bool
|
|
GetFileExists (const FileSpec& file_spec);
|
|
|
|
Error
|
|
RunShellCommand(const char *command, // Shouldn't be NULL
|
|
const FileSpec &working_dir, // Pass empty FileSpec 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 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,
|
|
StringExtractorGDBRemote &response);
|
|
|
|
bool
|
|
ReadAllRegisters (lldb::tid_t tid,
|
|
StringExtractorGDBRemote &response);
|
|
|
|
bool
|
|
SaveRegisterState (lldb::tid_t tid, uint32_t &save_id);
|
|
|
|
bool
|
|
RestoreRegisterState (lldb::tid_t tid, uint32_t save_id);
|
|
|
|
const char *
|
|
GetGDBServerProgramName();
|
|
|
|
uint32_t
|
|
GetGDBServerProgramVersion();
|
|
|
|
bool
|
|
AvoidGPackets(ProcessGDBRemote *process);
|
|
|
|
StructuredData::ObjectSP
|
|
GetThreadsInfo();
|
|
|
|
bool
|
|
GetThreadExtendedInfoSupported();
|
|
|
|
bool
|
|
GetModuleInfo (const FileSpec& module_file_spec,
|
|
const ArchSpec& arch_spec,
|
|
ModuleSpec &module_spec);
|
|
|
|
bool
|
|
ReadExtFeature (const lldb_private::ConstString object,
|
|
const lldb_private::ConstString annex,
|
|
std::string & out,
|
|
lldb_private::Error & err);
|
|
|
|
protected:
|
|
|
|
PacketResult
|
|
SendPacketAndWaitForResponseNoLock (const char *payload,
|
|
size_t payload_length,
|
|
StringExtractorGDBRemote &response);
|
|
|
|
bool
|
|
GetCurrentProcessInfo (bool allow_lazy_pid = true);
|
|
|
|
bool
|
|
GetGDBServerVersion();
|
|
|
|
// Given the list of compression types that the remote debug stub can support,
|
|
// possibly enable compression if we find an encoding we can handle.
|
|
void
|
|
MaybeEnableCompression (std::vector<std::string> supported_compressions);
|
|
|
|
//------------------------------------------------------------------
|
|
// Classes that inherit from GDBRemoteCommunicationClient can see and modify these
|
|
//------------------------------------------------------------------
|
|
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_qXfer_features_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,
|
|
m_supports_jThreadsInfo: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.
|
|
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;
|
|
|
|
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,
|
|
ProcessInstanceInfo &process_info);
|
|
private:
|
|
//------------------------------------------------------------------
|
|
// For GDBRemoteCommunicationClient only
|
|
//------------------------------------------------------------------
|
|
DISALLOW_COPY_AND_ASSIGN (GDBRemoteCommunicationClient);
|
|
};
|
|
|
|
} // namespace process_gdb_remote
|
|
} // namespace lldb_private
|
|
|
|
#endif // liblldb_GDBRemoteCommunicationClient_h_
|