Magic-Mirror/llvm-capstone
1
0
Fork 0
mirror of https://github.com/capstone-engine/llvm-capstone.git synced 2025-02-23 20:01:24 +00:00
Code Issues Actions 3 Packages Projects Releases Wiki Activity

No functionality changes, mostly cleanup.

Browse Source 
Cleaned up the Mutex::Locker and the ReadWriteLock classes a bit.

Also cleaned up the GDBRemoteCommunication class to not have so many packet functions. Used the "NoLock" versions of send/receive packet functions when possible for a bit of performance.

llvm-svn: 154458
This commit is contained in:
Greg Clayton 2012-04-11 00:24:49 +00:00
parent ad66de155b
commit 37a0a24a5f
22 changed files with 151 additions and 145 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
lldb/include/lldb/Host/Mutex.h
View File

@ -105,7 +105,7 @@ public:
/// non-NULL.
//--------------------------------------------------------------
void
Reset(pthread_mutex_t *mutex = NULL);
Lock (pthread_mutex_t *mutex);
//--------------------------------------------------------------
/// Change the contained mutex only if the mutex can be locked.
@ -125,6 +125,9 @@ public:
bool
TryLock (pthread_mutex_t *mutex);
void
Unlock ();
protected:
//--------------------------------------------------------------
/// Member variables

38
lldb/include/lldb/Host/ReadWriteLock.h
View File

@ -91,6 +91,13 @@ public:
{
}
ReadLocker (ReadWriteLock &lock) :
m_lock (NULL)
{
Lock(&lock);
}
ReadLocker (ReadWriteLock *lock) :
m_lock (NULL)
{
@ -164,11 +171,17 @@ public:
m_lock (NULL)
{
}
WriteLocker (ReadWriteLock *lock) :
m_lock (lock)
WriteLocker (ReadWriteLock &lock) :
m_lock (NULL)
{
Lock();
Lock(&lock);
}
WriteLocker (ReadWriteLock *lock) :
m_lock (NULL)
{
Lock(lock);
}
~WriteLocker()
@ -177,17 +190,30 @@ public:
}
void
Lock ()
Lock (ReadWriteLock *lock)
{
if (m_lock)
m_lock->WriteLock();
{
if (m_lock == lock)
return; // We already have this lock locked
else
Unlock();
}
if (lock)
{
lock->WriteLock();
m_lock = lock;
}
}
void
Unlock ()
{
if (m_lock)
{
m_lock->WriteUnlock();
m_lock = NULL;
}
}
protected:

6
lldb/source/API/SBCommandInterpreter.cpp
View File

@ -93,7 +93,7 @@ SBCommandInterpreter::HandleCommand (const char *command_line, SBCommandReturnOb
TargetSP target_sp(m_opaque_ptr->GetDebugger().GetSelectedTarget());
Mutex::Locker api_locker;
if (target_sp)
api_locker.Reset(target_sp->GetAPIMutex().GetMutex());
api_locker.Lock(target_sp->GetAPIMutex().GetMutex());
m_opaque_ptr->HandleCommand (command_line, add_to_history, result.ref());
}
else
@ -238,7 +238,7 @@ SBCommandInterpreter::SourceInitFileInHomeDirectory (SBCommandReturnObject &resu
TargetSP target_sp(m_opaque_ptr->GetDebugger().GetSelectedTarget());
Mutex::Locker api_locker;
if (target_sp)
api_locker.Reset(target_sp->GetAPIMutex().GetMutex());
api_locker.Lock(target_sp->GetAPIMutex().GetMutex());
m_opaque_ptr->SourceInitFile (false, result.ref());
}
else
@ -263,7 +263,7 @@ SBCommandInterpreter::SourceInitFileInCurrentWorkingDirectory (SBCommandReturnOb
TargetSP target_sp(m_opaque_ptr->GetDebugger().GetSelectedTarget());
Mutex::Locker api_locker;
if (target_sp)
api_locker.Reset(target_sp->GetAPIMutex().GetMutex());
api_locker.Lock(target_sp->GetAPIMutex().GetMutex());
m_opaque_ptr->SourceInitFile (true, result.ref());
}
else

4
lldb/source/API/SBDebugger.cpp
View File

@ -308,7 +308,7 @@ SBDebugger::HandleCommand (const char *command)
TargetSP target_sp (m_opaque_sp->GetSelectedTarget());
Mutex::Locker api_locker;
if (target_sp)
api_locker.Reset(target_sp->GetAPIMutex().GetMutex());
api_locker.Lock(target_sp->GetAPIMutex().GetMutex());
SBCommandInterpreter sb_interpreter(GetCommandInterpreter ());
SBCommandReturnObject result;
@ -830,7 +830,7 @@ SBDebugger::PushInputReader (SBInputReader &reader)
TargetSP target_sp (m_opaque_sp->GetSelectedTarget());
Mutex::Locker api_locker;
if (target_sp)
api_locker.Reset(target_sp->GetAPIMutex().GetMutex());
api_locker.Lock(target_sp->GetAPIMutex().GetMutex());
InputReaderSP reader_sp(*reader);
m_opaque_sp->PushInputReader (reader_sp);
}

2
lldb/source/API/SBFunction.cpp
View File

@ -130,7 +130,7 @@ SBFunction::GetInstructions (SBTarget target)
TargetSP target_sp (target.GetSP());
if (target_sp)
{
api_locker.Reset (target_sp->GetAPIMutex().GetMutex());
api_locker.Lock (target_sp->GetAPIMutex().GetMutex());
target_sp->CalculateExecutionContext (exe_ctx);
exe_ctx.SetProcessSP(target_sp->GetProcessSP());
}

6
lldb/source/API/SBInstruction.cpp
View File

@ -78,7 +78,7 @@ SBInstruction::GetMnemonic(SBTarget target)
TargetSP target_sp (target.GetSP());
if (target_sp)
{
api_locker.Reset (target_sp->GetAPIMutex().GetMutex());
api_locker.Lock (target_sp->GetAPIMutex().GetMutex());
target_sp->CalculateExecutionContext (exe_ctx);
exe_ctx.SetProcessSP(target_sp->GetProcessSP());
}
@ -97,7 +97,7 @@ SBInstruction::GetOperands(SBTarget target)
TargetSP target_sp (target.GetSP());
if (target_sp)
{
api_locker.Reset (target_sp->GetAPIMutex().GetMutex());
api_locker.Lock (target_sp->GetAPIMutex().GetMutex());
target_sp->CalculateExecutionContext (exe_ctx);
exe_ctx.SetProcessSP(target_sp->GetProcessSP());
}
@ -116,7 +116,7 @@ SBInstruction::GetComment(SBTarget target)
TargetSP target_sp (target.GetSP());
if (target_sp)
{
api_locker.Reset (target_sp->GetAPIMutex().GetMutex());
api_locker.Lock (target_sp->GetAPIMutex().GetMutex());
target_sp->CalculateExecutionContext (exe_ctx);
exe_ctx.SetProcessSP(target_sp->GetProcessSP());
}

2
lldb/source/API/SBSymbol.cpp
View File

@ -126,7 +126,7 @@ SBSymbol::GetInstructions (SBTarget target)
TargetSP target_sp (target.GetSP());
if (target_sp)
{
api_locker.Reset (target_sp->GetAPIMutex().GetMutex());
api_locker.Lock (target_sp->GetAPIMutex().GetMutex());
target_sp->CalculateExecutionContext (exe_ctx);
}
if (m_opaque_ptr->ValueIsAddress())

2
lldb/source/Breakpoint/BreakpointList.cpp
View File

@ -223,5 +223,5 @@ BreakpointList::ClearAllBreakpointSites ()
void
BreakpointList::GetListMutex (Mutex::Locker &locker)
{
return locker.Reset (m_mutex.GetMutex());
return locker.Lock (m_mutex.GetMutex());
}

2
lldb/source/Breakpoint/WatchpointList.cpp
View File

@ -273,5 +273,5 @@ WatchpointList::RemoveAll ()
void
WatchpointList::GetListMutex (Mutex::Locker &locker)
{
return locker.Reset (m_mutex.GetMutex());
return locker.Lock (m_mutex.GetMutex());
}

2
lldb/source/Commands/CommandObjectTarget.cpp
View File

@ -2839,7 +2839,7 @@ public:
if (use_global_module_list)
{
locker.Reset (Module::GetAllocationModuleCollectionMutex()->GetMutex());
locker.Lock (Module::GetAllocationModuleCollectionMutex()->GetMutex());
num_modules = Module::GetNumberAllocatedModules();
}
else

2
lldb/source/Core/Listener.cpp
View File

@ -303,7 +303,7 @@ Listener::FindNextEventInternal
// Unlock the event queue here. We've removed this event and are about to return
// it so it should be okay to get the next event off the queue here - and it might
// be useful to do that in the "DoOnRemoval".
lock.Reset();
lock.Unlock();
event_sp->DoOnRemoval();
return true;
}

2
lldb/source/Core/ModuleList.cpp
View File

@ -118,7 +118,7 @@ ModuleList::RemoveOrphans (bool mandatory)
if (mandatory)
{
locker.Reset (m_modules_mutex.GetMutex());
locker.Lock (m_modules_mutex.GetMutex());
}
else
{

42
lldb/source/Host/common/Mutex.cpp
View File

@ -50,10 +50,9 @@ Mutex::Locker::Locker () :
// mutex owned by "m" and locks it.
//----------------------------------------------------------------------
Mutex::Locker::Locker (Mutex& m) :
m_mutex_ptr(m.GetMutex())
m_mutex_ptr(NULL)
{
if (m_mutex_ptr)
Mutex::Lock (m_mutex_ptr);
Lock (m.GetMutex());
}
//----------------------------------------------------------------------
@ -63,10 +62,10 @@ Mutex::Locker::Locker (Mutex& m) :
// mutex owned by "m" and locks it.
//----------------------------------------------------------------------
Mutex::Locker::Locker (Mutex* m) :
m_mutex_ptr(m ? m->GetMutex() : NULL)
m_mutex_ptr(NULL)
{
if (m_mutex_ptr)
Mutex::Lock (m_mutex_ptr);
if (m)
Lock (m->GetMutex());
}
//----------------------------------------------------------------------
@ -75,10 +74,10 @@ Mutex::Locker::Locker (Mutex* m) :
// This will create a scoped mutex locking object that locks "mutex"
//----------------------------------------------------------------------
Mutex::Locker::Locker (pthread_mutex_t *mutex_ptr) :
m_mutex_ptr(mutex_ptr)
m_mutex_ptr (NULL)
{
if (m_mutex_ptr)
Mutex::Lock (m_mutex_ptr);
Lock (m_mutex_ptr);
}
//----------------------------------------------------------------------
@ -88,7 +87,7 @@ Mutex::Locker::Locker (pthread_mutex_t *mutex_ptr) :
//----------------------------------------------------------------------
Mutex::Locker::~Locker ()
{
Reset();
Unlock();
}
//----------------------------------------------------------------------
@ -96,18 +95,29 @@ Mutex::Locker::~Locker ()
// mutex) and lock the new "mutex" object if it is non-NULL.
//----------------------------------------------------------------------
void
Mutex::Locker::Reset (pthread_mutex_t *mutex_ptr)
Mutex::Locker::Lock (pthread_mutex_t *mutex_ptr)
{
// We already have this mutex locked or both are NULL...
if (m_mutex_ptr == mutex_ptr)
return;
if (m_mutex_ptr)
Mutex::Unlock (m_mutex_ptr);
Unlock ();
m_mutex_ptr = mutex_ptr;
if (m_mutex_ptr)
if (mutex_ptr)
{
m_mutex_ptr = mutex_ptr;
Mutex::Lock (m_mutex_ptr);
}
}
void
Mutex::Locker::Unlock ()
{
if (m_mutex_ptr)
{
Mutex::Unlock (m_mutex_ptr);
m_mutex_ptr = NULL;
}
}
bool
@ -115,9 +125,9 @@ Mutex::Locker::TryLock (pthread_mutex_t *mutex_ptr)
{
// We already have this mutex locked!
if (m_mutex_ptr == mutex_ptr)
return true;
return m_mutex_ptr != NULL;
Reset ();
Unlock ();
if (mutex_ptr)
{

2
lldb/source/Plugins/Process/MacOSX-Kernel/CommunicationKDP.cpp
View File

@ -151,7 +151,7 @@ CommunicationKDP::SendRequestPacketNoLock (const PacketStreamType &request_packe
}
bool
CommunicationKDP::TryLockSequenceMutex (Mutex::Locker& locker)
CommunicationKDP::GetSequenceMutex (Mutex::Locker& locker)
{
return locker.TryLock (m_sequence_mutex.GetMutex());
}

2
lldb/source/Plugins/Process/MacOSX-Kernel/CommunicationKDP.h
View File

@ -102,7 +102,7 @@ public:
uint32_t usec);
bool
TryLockSequenceMutex(lldb_private::Mutex::Locker& locker);
GetSequenceMutex(lldb_private::Mutex::Locker& locker);
bool
CheckForPacket (const uint8_t *src,

33
lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunication.cpp
View File

@ -157,21 +157,6 @@ GDBRemoteCommunication::SendNack ()
return bytes_written;
}
size_t
GDBRemoteCommunication::SendPacket (lldb_private::StreamString &payload)
{
Mutex::Locker locker(m_sequence_mutex);
const std::string &p (payload.GetString());
return SendPacketNoLock (p.c_str(), p.size());
}
size_t
GDBRemoteCommunication::SendPacket (const char *payload)
{
Mutex::Locker locker(m_sequence_mutex);
return SendPacketNoLock (payload, ::strlen (payload));
}
size_t
GDBRemoteCommunication::SendPacket (const char *payload, size_t payload_length)
{
@ -234,15 +219,20 @@ char
GDBRemoteCommunication::GetAck ()
{
StringExtractorGDBRemote packet;
if (WaitForPacketWithTimeoutMicroSeconds (packet, GetPacketTimeoutInMicroSeconds ()) == 1)
if (WaitForPacketWithTimeoutMicroSecondsNoLock (packet, GetPacketTimeoutInMicroSeconds ()) == 1)
return packet.GetChar();
return 0;
}
bool
GDBRemoteCommunication::TryLockSequenceMutex (Mutex::Locker& locker)
GDBRemoteCommunication::GetSequenceMutex (Mutex::Locker& locker, uint32_t usec_timeout)
{
return locker.TryLock (m_sequence_mutex.GetMutex());
if (usec_timeout == 0)
return locker.TryLock (m_sequence_mutex.GetMutex());
// Wait for the lock
locker.Lock (m_sequence_mutex.GetMutex());
return true;
}
@ -252,13 +242,6 @@ GDBRemoteCommunication::WaitForNotRunningPrivate (const TimeValue *timeout_ptr)
return m_private_is_running.WaitForValueEqualTo (false, timeout_ptr, NULL);
}
size_t
GDBRemoteCommunication::WaitForPacketWithTimeoutMicroSeconds (StringExtractorGDBRemote &packet, uint32_t timeout_usec)
{
Mutex::Locker locker(m_sequence_mutex);
return WaitForPacketWithTimeoutMicroSecondsNoLock (packet, timeout_usec);
}
size_t
GDBRemoteCommunication::WaitForPacketWithTimeoutMicroSecondsNoLock (StringExtractorGDBRemote &packet, uint32_t timeout_usec)
{

21
lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunication.h
View File

@ -45,21 +45,6 @@ public:
virtual
~GDBRemoteCommunication();
size_t
SendPacket (const char *payload);
size_t
SendPacket (const char *payload,
size_t payload_length);
size_t
SendPacket (lldb_private::StreamString &response);
// Wait for a packet within 'nsec' seconds
size_t
WaitForPacketWithTimeoutMicroSeconds (StringExtractorGDBRemote &response,
uint32_t usec);
char
GetAck ();
@ -74,7 +59,7 @@ public:
size_t payload_length);
bool
TryLockSequenceMutex(lldb_private::Mutex::Locker& locker);
GetSequenceMutex (lldb_private::Mutex::Locker& locker, uint32_t usec_timeout);
bool
CheckForPacket (const uint8_t *src,
@ -259,6 +244,10 @@ protected:
mutable bool m_dumped_to_log;
};
size_t
SendPacket (const char *payload,
size_t payload_length);
size_t
SendPacketNoLock (const char *payload,
size_t payload_length);

68
lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.cpp
View File

@ -259,7 +259,7 @@ GDBRemoteCommunicationClient::SendPacketAndWaitForResponse
Mutex::Locker locker;
LogSP log (ProcessGDBRemoteLog::GetLogIfAllCategoriesSet (GDBR_LOG_PROCESS));
size_t response_len = 0;
if (TryLockSequenceMutex (locker))
if (GetSequenceMutex (locker, 0))
{
if (SendPacketNoLock (payload, payload_length))
response_len = WaitForPacketWithTimeoutMicroSecondsNoLock (response, GetPacketTimeoutInMicroSeconds ());
@ -361,30 +361,6 @@ GDBRemoteCommunicationClient::SendPacketAndWaitForResponse
return response_len;
}
//template<typename _Tp>
//class ScopedValueChanger
//{
//public:
// // Take a value reference and the value to assign it to when this class
// // instance goes out of scope.
// ScopedValueChanger (_Tp &value_ref, _Tp value) :
// m_value_ref (value_ref),
// m_value (value)
// {
// }
//
// // This object is going out of scope, change the value pointed to by
// // m_value_ref to the value we got during construction which was stored in
// // m_value;
// ~ScopedValueChanger ()
// {
// m_value_ref = m_value;
// }
//protected:
// _Tp &m_value_ref; // A reference to the value we will change when this object destructs
// _Tp m_value; // The value to assign to m_value_ref when this goes out of scope.
//};
StateType
GDBRemoteCommunicationClient::SendContinuePacketAndWaitForResponse
(
@ -415,7 +391,7 @@ GDBRemoteCommunicationClient::SendContinuePacketAndWaitForResponse
{
if (log)
log->Printf ("GDBRemoteCommunicationClient::%s () sending continue packet: %s", __FUNCTION__, continue_packet.c_str());
if (SendPacket(continue_packet.c_str(), continue_packet.size()) == 0)
if (SendPacketNoLock(continue_packet.c_str(), continue_packet.size()) == 0)
state = eStateInvalid;
m_private_is_running.SetValue (true, eBroadcastAlways);
@ -426,7 +402,7 @@ GDBRemoteCommunicationClient::SendContinuePacketAndWaitForResponse
if (log)
log->Printf ("GDBRemoteCommunicationClient::%s () WaitForPacket(%s)", __FUNCTION__, continue_packet.c_str());
if (WaitForPacketWithTimeoutMicroSeconds (response, UINT32_MAX))
if (WaitForPacketWithTimeoutMicroSecondsNoLock(response, UINT32_MAX))
{
if (response.Empty())
state = eStateInvalid;
@ -647,7 +623,7 @@ GDBRemoteCommunicationClient::SendAsyncSignal (int signo)
return false;
}
// This function takes a mutex locker as a parameter in case the TryLockSequenceMutex
// This function takes a mutex locker as a parameter in case the GetSequenceMutex
// actually succeeds. If it doesn't succeed in acquiring the sequence mutex
// (the expected result), then it will send the halt packet. If it does succeed
// then the caller that requested the interrupt will want to keep the sequence
@ -672,7 +648,12 @@ GDBRemoteCommunicationClient::SendInterrupt
if (IsRunning())
{
// Only send an interrupt if our debugserver is running...
if (TryLockSequenceMutex (locker) == false)
if (GetSequenceMutex (locker, 0))
{
if (log)
log->Printf ("SendInterrupt () - got sequence mutex without having to interrupt");
}
else
{
// Someone has the mutex locked waiting for a response or for the
// inferior to stop, so send the interrupt on the down low...
@ -718,11 +699,6 @@ GDBRemoteCommunicationClient::SendInterrupt
}
return false;
}
else
{
if (log)
log->Printf ("SendInterrupt () - got sequence mutex without having to interrupt");
}
}
else
{
@ -1174,6 +1150,12 @@ GDBRemoteCommunicationClient::DeallocateMemory (addr_t addr)
return false;
}
bool
GDBRemoteCommunicationClient::Detach ()
{
return SendPacket ("D", 1) > 0;
}
Error
GDBRemoteCommunicationClient::GetMemoryRegionInfo (lldb::addr_t addr,
lldb_private::MemoryRegionInfo &region_info)
@ -1861,7 +1843,7 @@ GDBRemoteCommunicationClient::GetCurrentThreadIDs (std::vector<lldb::tid_t> &thr
Mutex::Locker locker;
thread_ids.clear();
if (TryLockSequenceMutex (locker))
if (GetSequenceMutex (locker, 0))
{
sequence_mutex_unavailable = false;
StringExtractorGDBRemote response;
@ -1894,3 +1876,19 @@ GDBRemoteCommunicationClient::GetCurrentThreadIDs (std::vector<lldb::tid_t> &thr
}
return thread_ids.size();
}
lldb::addr_t
GDBRemoteCommunicationClient::GetShlibInfoAddr()
{
if (!IsRunning())
{
StringExtractorGDBRemote response;
if (SendPacketAndWaitForResponse("qShlibInfoAddr", ::strlen ("qShlibInfoAddr"), response, false))
{
if (response.IsNormalResponse())
return response.GetHexMaxU64(false, LLDB_INVALID_ADDRESS);
}
}
return LLDB_INVALID_ADDRESS;
}

6
lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.h
View File

@ -199,6 +199,9 @@ public:
bool
DeallocateMemory (lldb::addr_t addr);
bool
Detach ();
lldb_private::Error
GetMemoryRegionInfo (lldb::addr_t addr,
lldb_private::MemoryRegionInfo &range_info);
@ -232,6 +235,9 @@ public:
bool
GetHostname (std::string &s);
lldb::addr_t
GetShlibInfoAddr();
bool
GetSupportsThreadSuffix ();

26
lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServer.cpp
View File

@ -85,7 +85,7 @@ GDBRemoteCommunicationServer::GetPacketAndSendResponse (uint32_t timeout_usec,
bool &quit)
{
StringExtractorGDBRemote packet;
if (WaitForPacketWithTimeoutMicroSeconds(packet, timeout_usec))
if (WaitForPacketWithTimeoutMicroSecondsNoLock (packet, timeout_usec))
{
const StringExtractorGDBRemote::ServerPacketType packet_type = packet.GetServerPacketType ();
switch (packet_type)
@ -178,7 +178,7 @@ size_t
GDBRemoteCommunicationServer::SendUnimplementedResponse (const char *)
{
// TODO: Log the packet we aren't handling...
return SendPacket ("");
return SendPacketNoLock ("", 0);
}
size_t
@ -187,14 +187,14 @@ GDBRemoteCommunicationServer::SendErrorResponse (uint8_t err)
char packet[16];
int packet_len = ::snprintf (packet, sizeof(packet), "E%2.2x", err);
assert (packet_len < sizeof(packet));
return SendPacket (packet, packet_len);
return SendPacketNoLock (packet, packet_len);
}
size_t
GDBRemoteCommunicationServer::SendOKResponse ()
{
return SendPacket ("OK");
return SendPacketNoLock ("OK", 2);
}
bool
@ -269,7 +269,7 @@ GDBRemoteCommunicationServer::Handle_qHostInfo (StringExtractorGDBRemote &packet
response.PutChar(';');
}
return SendPacket (response) > 0;
return SendPacketNoLock (response.GetData(), response.GetSize()) > 0;
}
static void
@ -308,7 +308,7 @@ GDBRemoteCommunicationServer::Handle_qProcessInfoPID (StringExtractorGDBRemote &
{
StreamString response;
CreateProcessInfoResponse (proc_info, response);
return SendPacket (response);
return SendPacketNoLock (response.GetData(), response.GetSize());
}
}
return SendErrorResponse (1);
@ -423,7 +423,7 @@ GDBRemoteCommunicationServer::Handle_qsProcessInfo (StringExtractorGDBRemote &pa
StreamString response;
CreateProcessInfoResponse (m_proc_infos.GetProcessInfoAtIndex(m_proc_infos_index), response);
++m_proc_infos_index;
return SendPacket (response);
return SendPacketNoLock (response.GetData(), response.GetSize());
}
return SendErrorResponse (4);
}
@ -441,7 +441,7 @@ GDBRemoteCommunicationServer::Handle_qUserName (StringExtractorGDBRemote &packet
{
StreamString response;
response.PutCStringAsRawHex8 (name.c_str());
return SendPacket (response);
return SendPacketNoLock (response.GetData(), response.GetSize());
}
}
return SendErrorResponse (5);
@ -461,7 +461,7 @@ GDBRemoteCommunicationServer::Handle_qGroupName (StringExtractorGDBRemote &packe
{
StreamString response;
response.PutCStringAsRawHex8 (name.c_str());
return SendPacket (response);
return SendPacketNoLock (response.GetData(), response.GetSize());
}
}
return SendErrorResponse (6);
@ -498,7 +498,7 @@ GDBRemoteCommunicationServer::Handle_qSpeedTest (StringExtractorGDBRemote &packe
bytes_left = 0;
}
}
return SendPacket (response);
return SendPacketNoLock (response.GetData(), response.GetSize());
}
}
return SendErrorResponse (7);
@ -657,7 +657,7 @@ GDBRemoteCommunicationServer::Handle_qC (StringExtractorGDBRemote &packet)
m_process_launch_info.Clear();
}
}
return SendPacket (response);
return SendPacketNoLock (response.GetData(), response.GetSize());
}
bool
@ -710,7 +710,7 @@ GDBRemoteCommunicationServer::Handle_qLaunchGDBServer (StringExtractorGDBRemote
const int response_len = ::snprintf (response, sizeof(response), "pid:%llu;port:%u;", debugserver_pid, port);
assert (response_len < sizeof(response));
//m_port_to_pid_map[port] = debugserver_launch_info.GetProcessID();
success = SendPacket (response, response_len) > 0;
success = SendPacketNoLock (response, response_len) > 0;
}
}
::unlink (unix_socket_name);
@ -736,7 +736,7 @@ GDBRemoteCommunicationServer::Handle_qLaunchSuccess (StringExtractorGDBRemote &p
StreamString response;
response.PutChar('E');
response.PutCString(m_process_launch_error.AsCString("<unknown error>"));
return SendPacket (response);
return SendPacketNoLock (response.GetData(), response.GetSize());
}
bool

8
lldb/source/Plugins/Process/gdb-remote/GDBRemoteRegisterContext.cpp
View File

@ -181,7 +181,7 @@ GDBRemoteRegisterContext::ReadRegisterBytes (const RegisterInfo *reg_info, DataE
if (!m_reg_valid[reg])
{
Mutex::Locker locker;
if (gdb_comm.TryLockSequenceMutex (locker))
if (gdb_comm.GetSequenceMutex (locker, 0))
{
const bool thread_suffix_supported = gdb_comm.GetThreadSuffixSupported();
ProcessSP process_sp (m_thread.GetProcess());
@ -331,7 +331,7 @@ GDBRemoteRegisterContext::WriteRegisterBytes (const lldb_private::RegisterInfo *
m_reg_data.GetByteOrder())) // dst byte order
{
Mutex::Locker locker;
if (gdb_comm.TryLockSequenceMutex (locker))
if (gdb_comm.GetSequenceMutex (locker, 0))
{
const bool thread_suffix_supported = gdb_comm.GetThreadSuffixSupported();
ProcessSP process_sp (m_thread.GetProcess());
@ -440,7 +440,7 @@ GDBRemoteRegisterContext::ReadAllRegisterValues (lldb::DataBufferSP &data_sp)
StringExtractorGDBRemote response;
Mutex::Locker locker;
if (gdb_comm.TryLockSequenceMutex (locker))
if (gdb_comm.GetSequenceMutex (locker, 0))
{
char packet[32];
const bool thread_suffix_supported = gdb_comm.GetThreadSuffixSupported();
@ -496,7 +496,7 @@ GDBRemoteRegisterContext::WriteAllRegisterValues (const lldb::DataBufferSP &data
StringExtractorGDBRemote response;
Mutex::Locker locker;
if (gdb_comm.TryLockSequenceMutex (locker))
if (gdb_comm.GetSequenceMutex (locker, 0))
{
const bool thread_suffix_supported = gdb_comm.GetThreadSuffixSupported();
ProcessSP process_sp (m_thread.GetProcess());

15
lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp
View File

@ -1621,10 +1621,10 @@ ProcessGDBRemote::DoDetach()
m_thread_list.DiscardThreadPlans();
size_t response_size = m_gdb_comm.SendPacket ("D", 1);
bool success = m_gdb_comm.Detach ();
if (log)
{
if (response_size)
if (success)
log->PutCString ("ProcessGDBRemote::DoDetach() detach packet sent successfully");
else
log->PutCString ("ProcessGDBRemote::DoDetach() detach packet send failed");
@ -1691,16 +1691,7 @@ ProcessGDBRemote::IsAlive ()
addr_t
ProcessGDBRemote::GetImageInfoAddress()
{
if (!m_gdb_comm.IsRunning())
{
StringExtractorGDBRemote response;
if (m_gdb_comm.SendPacketAndWaitForResponse("qShlibInfoAddr", ::strlen ("qShlibInfoAddr"), response, false))
{
if (response.IsNormalResponse())
return response.GetHexMaxU64(false, LLDB_INVALID_ADDRESS);
}
}
return LLDB_INVALID_ADDRESS;
return m_gdb_comm.GetShlibInfoAddr();
}
//------------------------------------------------------------------