forked from OSchip/llvm-project
277 lines
9.0 KiB
C++
277 lines
9.0 KiB
C++
//===-- GDBRemoteCommunication.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_GDBRemoteCommunication_h_
|
|
#define liblldb_GDBRemoteCommunication_h_
|
|
|
|
// C Includes
|
|
// C++ Includes
|
|
#include <list>
|
|
#include <string>
|
|
|
|
// Other libraries and framework includes
|
|
// Project includes
|
|
#include "lldb/lldb-private.h"
|
|
#include "lldb/Core/ArchSpec.h"
|
|
#include "lldb/Core/Communication.h"
|
|
#include "lldb/Core/ConstString.h"
|
|
#include "lldb/Core/Error.h"
|
|
#include "lldb/Core/Listener.h"
|
|
#include "lldb/Host/Mutex.h"
|
|
#include "lldb/Host/Predicate.h"
|
|
|
|
#include "Utility/StringExtractorGDBRemote.h"
|
|
|
|
class ProcessGDBRemote;
|
|
|
|
class GDBRemoteCommunication :
|
|
public lldb_private::Communication
|
|
{
|
|
public:
|
|
enum
|
|
{
|
|
eBroadcastBitRunPacketSent = kLoUserBroadcastBit
|
|
};
|
|
//------------------------------------------------------------------
|
|
// Constructors and Destructors
|
|
//------------------------------------------------------------------
|
|
GDBRemoteCommunication();
|
|
|
|
virtual
|
|
~GDBRemoteCommunication();
|
|
|
|
size_t
|
|
SendPacket (const char *payload);
|
|
|
|
size_t
|
|
SendPacket (const char *payload,
|
|
size_t payload_length);
|
|
|
|
size_t
|
|
SendPacketAndWaitForResponse (const char *send_payload,
|
|
StringExtractorGDBRemote &response,
|
|
uint32_t timeout_seconds,
|
|
bool send_async);
|
|
|
|
size_t
|
|
SendPacketAndWaitForResponse (const char *send_payload,
|
|
size_t send_length,
|
|
StringExtractorGDBRemote &response,
|
|
uint32_t timeout_seconds,
|
|
bool send_async);
|
|
|
|
lldb::StateType
|
|
SendContinuePacketAndWaitForResponse (ProcessGDBRemote *process,
|
|
const char *packet_payload,
|
|
size_t packet_length,
|
|
StringExtractorGDBRemote &response);
|
|
|
|
// Wait for a packet within 'nsec' seconds
|
|
size_t
|
|
WaitForPacket (StringExtractorGDBRemote &response,
|
|
uint32_t nsec);
|
|
|
|
// Wait for a packet with an absolute timeout time. If 'timeout' is NULL
|
|
// wait indefinitely.
|
|
size_t
|
|
WaitForPacket (StringExtractorGDBRemote &response,
|
|
lldb_private::TimeValue* timeout);
|
|
|
|
char
|
|
GetAck (uint32_t timeout_seconds);
|
|
|
|
size_t
|
|
SendAck (char ack_char);
|
|
|
|
char
|
|
CalculcateChecksum (const char *payload,
|
|
size_t payload_length);
|
|
|
|
void
|
|
SetAckMode (bool enabled)
|
|
{
|
|
m_send_acks = enabled;
|
|
}
|
|
|
|
bool
|
|
SendAsyncSignal (int signo);
|
|
|
|
bool
|
|
SendInterrupt (lldb_private::Mutex::Locker &locker,
|
|
uint32_t seconds_to_wait_for_stop,
|
|
bool *timed_out = NULL);
|
|
|
|
bool
|
|
GetSequenceMutex(lldb_private::Mutex::Locker& locker);
|
|
|
|
//------------------------------------------------------------------
|
|
// Communication overrides
|
|
//------------------------------------------------------------------
|
|
virtual void
|
|
AppendBytesToCache (const uint8_t *src, size_t src_len, bool broadcast, lldb::ConnectionStatus status);
|
|
|
|
|
|
lldb::pid_t
|
|
GetCurrentProcessID (uint32_t timeout_seconds);
|
|
|
|
bool
|
|
GetLaunchSuccess (uint32_t timeout_seconds, std::string &error_str);
|
|
|
|
//------------------------------------------------------------------
|
|
/// 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.
|
|
///
|
|
/// @param[in] timeout_seconds
|
|
/// The number of seconds to wait for a response from the remote
|
|
/// server.
|
|
///
|
|
/// @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 (char const *argv[], uint32_t timeout_seconds);
|
|
|
|
//------------------------------------------------------------------
|
|
/// 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".
|
|
///
|
|
/// @param[in] timeout_seconds
|
|
/// The number of seconds to wait for a response from the remote
|
|
/// server.
|
|
///
|
|
/// @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,
|
|
uint32_t timeout_seconds);
|
|
|
|
//------------------------------------------------------------------
|
|
/// Sends a "vAttach:PID" where PID is in hex.
|
|
///
|
|
/// @param[in] pid
|
|
/// A process ID for the remote gdb server to attach to.
|
|
///
|
|
/// @param[in] timeout_seconds
|
|
/// The number of seconds to wait for a response from the remote
|
|
/// server.
|
|
///
|
|
/// @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,
|
|
uint32_t timeout_seconds,
|
|
StringExtractorGDBRemote& response);
|
|
|
|
|
|
lldb::addr_t
|
|
AllocateMemory (size_t size, uint32_t permissions, uint32_t timeout_seconds);
|
|
|
|
bool
|
|
DeallocateMemory (lldb::addr_t addr, uint32_t timeout_seconds);
|
|
|
|
bool
|
|
IsRunning() const
|
|
{
|
|
return m_is_running.GetValue();
|
|
}
|
|
|
|
bool
|
|
GetHostInfo (uint32_t timeout_seconds);
|
|
|
|
bool
|
|
HostInfoIsValid () const
|
|
{
|
|
return m_pointer_byte_size != 0;
|
|
}
|
|
|
|
const lldb_private::ArchSpec &
|
|
GetHostArchitecture ();
|
|
|
|
const lldb_private::ConstString &
|
|
GetOSString ();
|
|
|
|
const lldb_private::ConstString &
|
|
GetVendorString();
|
|
|
|
lldb::ByteOrder
|
|
GetByteOrder ();
|
|
|
|
uint32_t
|
|
GetAddressByteSize ();
|
|
|
|
protected:
|
|
typedef std::list<std::string> packet_collection;
|
|
|
|
size_t
|
|
SendPacketNoLock (const char *payload,
|
|
size_t payload_length);
|
|
|
|
size_t
|
|
WaitForPacketNoLock (StringExtractorGDBRemote &response,
|
|
lldb_private::TimeValue* timeout_time_ptr);
|
|
|
|
//------------------------------------------------------------------
|
|
// Classes that inherit from GDBRemoteCommunication can see and modify these
|
|
//------------------------------------------------------------------
|
|
bool m_send_acks;
|
|
lldb_private::Listener m_rx_packet_listener;
|
|
lldb_private::Mutex m_sequence_mutex; // Restrict access to sending/receiving packets to a single thread at a time
|
|
lldb_private::Predicate<bool> m_is_running;
|
|
|
|
// If we need to send a packet while the target is running, the m_async_XXX
|
|
// member variables take care of making this happen.
|
|
lldb_private::Mutex m_async_mutex;
|
|
lldb_private::Predicate<bool> m_async_packet_predicate;
|
|
std::string m_async_packet;
|
|
StringExtractorGDBRemote m_async_response;
|
|
uint32_t m_async_timeout;
|
|
int m_async_signal; // We were asked to deliver a signal to the inferior process.
|
|
|
|
lldb_private::ArchSpec m_arch; // Results from the qHostInfo call
|
|
uint32_t m_cpusubtype; // Results from the qHostInfo call
|
|
lldb_private::ConstString m_os; // Results from the qHostInfo call
|
|
lldb_private::ConstString m_vendor; // Results from the qHostInfo call
|
|
lldb::ByteOrder m_byte_order; // Results from the qHostInfo call
|
|
uint32_t m_pointer_byte_size; // Results from the qHostInfo call
|
|
|
|
|
|
private:
|
|
//------------------------------------------------------------------
|
|
// For GDBRemoteCommunication only
|
|
//------------------------------------------------------------------
|
|
DISALLOW_COPY_AND_ASSIGN (GDBRemoteCommunication);
|
|
};
|
|
|
|
#endif // liblldb_GDBRemoteCommunication_h_
|