maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity

lldb::SBTarget and lldb::SBProcess are now thread hardened. They both still 

contain shared pointers to the lldb_private::Target and lldb_private::Process
objects respectively as we won't want the target or process just going away.

Also cleaned up the lldb::SBModule to remove dangerous pointer accessors.

For any code the public API files, we should always be grabbing shared 
pointers to any objects for the current class, and any other classes prior
to running code with them.

llvm-svn: 149238
This commit is contained in:
Greg Clayton 2012-01-30 09:04:36 +00:00
parent 2962e7b656
commit acdbe81637
7 changed files with 447 additions and 389 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

28
lldb/include/lldb/API/SBModule.h
View File

@ -188,31 +188,11 @@ private:
explicit SBModule (const lldb::ModuleSP& module_sp);
void
SetModule (const lldb::ModuleSP& module_sp);
#ifndef SWIG
lldb::ModuleSP &
operator *();
lldb_private::Module *
operator ->();
const lldb_private::Module *
operator ->() const;
lldb_private::Module *
get();
const lldb_private::Module *
get() const;
const lldb::ModuleSP &
get_sp() const;
ModuleSP
GetSP () const;
#endif
void
SetSP (const ModuleSP &module_sp);
lldb::ModuleSP m_opaque_sp;
};

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

@ -300,9 +300,7 @@ SBAddress::GetModule ()
SBModule sb_module;
if (m_opaque_ap.get())
{
Module *module = m_opaque_ap->GetModule();
if (module)
*sb_module = module->shared_from_this();
sb_module.SetSP (m_opaque_ap->GetModuleSP());
}
return sb_module;
}

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

@ -222,17 +222,19 @@ SBModule
SBFrame::GetModule () const
{
SBModule sb_module;
ModuleSP module_sp;
StackFrameSP frame_sp(GetFrameSP());
if (frame_sp)
{
Mutex::Locker api_locker (frame_sp->GetThread().GetProcess().GetTarget().GetAPIMutex());
*sb_module = frame_sp->GetSymbolContext (eSymbolContextModule).module_sp;
module_sp = frame_sp->GetSymbolContext (eSymbolContextModule).module_sp;
sb_module.SetSP (module_sp);
}
LogSP log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
if (log)
log->Printf ("SBFrame(%p)::GetModule () => SBModule(%p)",
frame_sp.get(), sb_module.get());
frame_sp.get(), module_sp.get());
return sb_module;
}

37
lldb/source/API/SBModule.cpp
View File

@ -193,49 +193,18 @@ SBModule::operator != (const SBModule &rhs) const
return false;
}
lldb::ModuleSP &
SBModule::operator *()
{
return m_opaque_sp;
}
lldb_private::Module *
SBModule::operator ->()
{
return m_opaque_sp.get();
}
const lldb_private::Module *
SBModule::operator ->() const
{
return m_opaque_sp.get();
}
lldb_private::Module *
SBModule::get()
{
return m_opaque_sp.get();
}
const lldb_private::Module *
SBModule::get() const
{
return m_opaque_sp.get();
}
const lldb::ModuleSP &
SBModule::get_sp() const
ModuleSP
SBModule::GetSP () const
{
return m_opaque_sp;
}
void
SBModule::SetModule (const lldb::ModuleSP& module_sp)
SBModule::SetSP (const ModuleSP &module_sp)
{
m_opaque_sp = module_sp;
}
SBAddress
SBModule::ResolveFileAddress (lldb::addr_t vm_addr)
{

301
lldb/source/API/SBProcess.cpp
View File

@ -125,10 +125,11 @@ SBProcess::RemoteLaunch (char const **argv,
error.get());
}
if (m_opaque_sp)
ProcessSP process_sp(GetSP());
if (process_sp)
{
Mutex::Locker api_locker (m_opaque_sp->GetTarget().GetAPIMutex());
if (m_opaque_sp->GetState() == eStateConnected)
Mutex::Locker api_locker (process_sp->GetTarget().GetAPIMutex());
if (process_sp->GetState() == eStateConnected)
{
if (stop_at_entry)
launch_flags |= eLaunchFlagStopAtEntry;
@ -137,14 +138,14 @@ SBProcess::RemoteLaunch (char const **argv,
stderr_path,
working_directory,
launch_flags);
Module *exe_module = m_opaque_sp->GetTarget().GetExecutableModulePointer();
Module *exe_module = process_sp->GetTarget().GetExecutableModulePointer();
if (exe_module)
launch_info.SetExecutableFile(exe_module->GetFileSpec(), true);
if (argv)
launch_info.GetArguments().AppendArguments (argv);
if (envp)
launch_info.GetEnvironmentEntries ().SetArguments (envp);
error.SetError (m_opaque_sp->Launch (launch_info));
error.SetError (process_sp->Launch (launch_info));
}
else
{
@ -159,7 +160,7 @@ SBProcess::RemoteLaunch (char const **argv,
if (log) {
SBStream sstr;
error.GetDescription (sstr);
log->Printf ("SBProcess(%p)::RemoteLaunch (...) => SBError (%p): %s", m_opaque_sp.get(), error.get(), sstr.GetData());
log->Printf ("SBProcess(%p)::RemoteLaunch (...) => SBError (%p): %s", process_sp.get(), error.get(), sstr.GetData());
}
return error.Success();
@ -168,14 +169,15 @@ SBProcess::RemoteLaunch (char const **argv,
bool
SBProcess::RemoteAttachToProcessWithID (lldb::pid_t pid, lldb::SBError& error)
{
if (m_opaque_sp)
ProcessSP process_sp(GetSP());
if (process_sp)
{
Mutex::Locker api_locker (m_opaque_sp->GetTarget().GetAPIMutex());
if (m_opaque_sp->GetState() == eStateConnected)
Mutex::Locker api_locker (process_sp->GetTarget().GetAPIMutex());
if (process_sp->GetState() == eStateConnected)
{
ProcessAttachInfo attach_info;
attach_info.SetProcessID (pid);
error.SetError (m_opaque_sp->Attach (attach_info));
error.SetError (process_sp->Attach (attach_info));
}
else
{
@ -191,7 +193,7 @@ SBProcess::RemoteAttachToProcessWithID (lldb::pid_t pid, lldb::SBError& error)
if (log) {
SBStream sstr;
error.GetDescription (sstr);
log->Printf ("SBProcess(%p)::RemoteAttachToProcessWithID (%llu) => SBError (%p): %s", m_opaque_sp.get(), pid, error.get(), sstr.GetData());
log->Printf ("SBProcess(%p)::RemoteAttachToProcessWithID (%llu) => SBError (%p): %s", process_sp.get(), pid, error.get(), sstr.GetData());
}
return error.Success();
@ -204,15 +206,16 @@ SBProcess::GetNumThreads ()
LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
uint32_t num_threads = 0;
if (m_opaque_sp)
ProcessSP process_sp(GetSP());
if (process_sp)
{
Mutex::Locker api_locker (m_opaque_sp->GetTarget().GetAPIMutex());
Mutex::Locker api_locker (process_sp->GetTarget().GetAPIMutex());
const bool can_update = true;
num_threads = m_opaque_sp->GetThreadList().GetSize(can_update);
num_threads = process_sp->GetThreadList().GetSize(can_update);
}
if (log)
log->Printf ("SBProcess(%p)::GetNumThreads () => %d", m_opaque_sp.get(), num_threads);
log->Printf ("SBProcess(%p)::GetNumThreads () => %d", process_sp.get(), num_threads);
return num_threads;
}
@ -224,16 +227,17 @@ SBProcess::GetSelectedThread () const
SBThread sb_thread;
ThreadSP thread_sp;
if (m_opaque_sp)
ProcessSP process_sp(GetSP());
if (process_sp)
{
Mutex::Locker api_locker (m_opaque_sp->GetTarget().GetAPIMutex());
thread_sp = m_opaque_sp->GetThreadList().GetSelectedThread();
Mutex::Locker api_locker (process_sp->GetTarget().GetAPIMutex());
thread_sp = process_sp->GetThreadList().GetSelectedThread();
sb_thread.SetThread (thread_sp);
}
if (log)
{
log->Printf ("SBProcess(%p)::GetSelectedThread () => SBThread(%p)", m_opaque_sp.get(), thread_sp.get());
log->Printf ("SBProcess(%p)::GetSelectedThread () => SBThread(%p)", process_sp.get(), thread_sp.get());
}
return sb_thread;
@ -246,14 +250,15 @@ SBProcess::GetTarget() const
SBTarget sb_target;
TargetSP target_sp;
if (m_opaque_sp)
ProcessSP process_sp(GetSP());
if (process_sp)
{
target_sp = m_opaque_sp->GetTarget().shared_from_this();
target_sp = process_sp->GetTarget().shared_from_this();
sb_target.SetSP (target_sp);
}
if (log)
log->Printf ("SBProcess(%p)::GetTarget () => SBTarget(%p)", m_opaque_sp.get(), target_sp.get());
log->Printf ("SBProcess(%p)::GetTarget () => SBTarget(%p)", process_sp.get(), target_sp.get());
return sb_target;
}
@ -265,15 +270,16 @@ SBProcess::PutSTDIN (const char *src, size_t src_len)
LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
size_t ret_val = 0;
if (m_opaque_sp)
ProcessSP process_sp(GetSP());
if (process_sp)
{
Error error;
ret_val = m_opaque_sp->PutSTDIN (src, src_len, error);
ret_val = process_sp->PutSTDIN (src, src_len, error);
}
if (log)
log->Printf ("SBProcess(%p)::PutSTDIN (src=\"%s\", src_len=%d) => %lu",
m_opaque_sp.get(),
process_sp.get(),
src,
(uint32_t) src_len,
ret_val);
@ -285,16 +291,17 @@ size_t
SBProcess::GetSTDOUT (char *dst, size_t dst_len) const
{
size_t bytes_read = 0;
if (m_opaque_sp)
ProcessSP process_sp(GetSP());
if (process_sp)
{
Error error;
bytes_read = m_opaque_sp->GetSTDOUT (dst, dst_len, error);
bytes_read = process_sp->GetSTDOUT (dst, dst_len, error);
}
LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
if (log)
log->Printf ("SBProcess(%p)::GetSTDOUT (dst=\"%.*s\", dst_len=%zu) => %zu",
m_opaque_sp.get(), (int) bytes_read, dst, dst_len, bytes_read);
process_sp.get(), (int) bytes_read, dst, dst_len, bytes_read);
return bytes_read;
}
@ -303,16 +310,17 @@ size_t
SBProcess::GetSTDERR (char *dst, size_t dst_len) const
{
size_t bytes_read = 0;
if (m_opaque_sp)
ProcessSP process_sp(GetSP());
if (process_sp)
{
Error error;
bytes_read = m_opaque_sp->GetSTDERR (dst, dst_len, error);
bytes_read = process_sp->GetSTDERR (dst, dst_len, error);
}
LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
if (log)
log->Printf ("SBProcess(%p)::GetSTDERR (dst=\"%.*s\", dst_len=%zu) => %zu",
m_opaque_sp.get(), (int) bytes_read, dst, dst_len, bytes_read);
process_sp.get(), (int) bytes_read, dst, dst_len, bytes_read);
return bytes_read;
}
@ -323,14 +331,15 @@ SBProcess::ReportEventState (const SBEvent &event, FILE *out) const
if (out == NULL)
return;
if (m_opaque_sp)
ProcessSP process_sp(GetSP());
if (process_sp)
{
const StateType event_state = SBProcess::GetStateFromEvent (event);
char message[1024];
int message_len = ::snprintf (message,
sizeof (message),
"Process %llu %s\n",
m_opaque_sp->GetID(),
process_sp->GetID(),
SBDebugger::StateAsCString (event_state));
if (message_len > 0)
@ -341,14 +350,15 @@ SBProcess::ReportEventState (const SBEvent &event, FILE *out) const
void
SBProcess::AppendEventStateReport (const SBEvent &event, SBCommandReturnObject &result)
{
if (m_opaque_sp)
ProcessSP process_sp(GetSP());
if (process_sp)
{
const StateType event_state = SBProcess::GetStateFromEvent (event);
char message[1024];
::snprintf (message,
sizeof (message),
"Process %llu %s\n",
m_opaque_sp->GetID(),
process_sp->GetID(),
SBDebugger::StateAsCString (event_state));
result.AppendMessage (message);
@ -358,10 +368,11 @@ SBProcess::AppendEventStateReport (const SBEvent &event, SBCommandReturnObject &
bool
SBProcess::SetSelectedThread (const SBThread &thread)
{
if (m_opaque_sp)
ProcessSP process_sp(GetSP());
if (process_sp)
{
Mutex::Locker api_locker (m_opaque_sp->GetTarget().GetAPIMutex());
return m_opaque_sp->GetThreadList().SetSelectedThreadByID (thread.GetThreadID());
Mutex::Locker api_locker (process_sp->GetTarget().GetAPIMutex());
return process_sp->GetThreadList().SetSelectedThreadByID (thread.GetThreadID());
}
return false;
}
@ -372,15 +383,16 @@ SBProcess::SetSelectedThreadByID (uint32_t tid)
LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
bool ret_val = false;
if (m_opaque_sp)
ProcessSP process_sp(GetSP());
if (process_sp)
{
Mutex::Locker api_locker (m_opaque_sp->GetTarget().GetAPIMutex());
ret_val = m_opaque_sp->GetThreadList().SetSelectedThreadByID (tid);
Mutex::Locker api_locker (process_sp->GetTarget().GetAPIMutex());
ret_val = process_sp->GetThreadList().SetSelectedThreadByID (tid);
}
if (log)
log->Printf ("SBProcess(%p)::SetSelectedThreadByID (tid=0x%4.4x) => %s",
m_opaque_sp.get(), tid, (ret_val ? "true" : "false"));
process_sp.get(), tid, (ret_val ? "true" : "false"));
return ret_val;
}
@ -392,17 +404,18 @@ SBProcess::GetThreadAtIndex (size_t index)
SBThread sb_thread;
ThreadSP thread_sp;
if (m_opaque_sp)
ProcessSP process_sp(GetSP());
if (process_sp)
{
Mutex::Locker api_locker (m_opaque_sp->GetTarget().GetAPIMutex());
thread_sp = m_opaque_sp->GetThreadList().GetThreadAtIndex(index);
Mutex::Locker api_locker (process_sp->GetTarget().GetAPIMutex());
thread_sp = process_sp->GetThreadList().GetThreadAtIndex(index);
sb_thread.SetThread (thread_sp);
}
if (log)
{
log->Printf ("SBProcess(%p)::GetThreadAtIndex (index=%d) => SBThread(%p)",
m_opaque_sp.get(), (uint32_t) index, thread_sp.get());
process_sp.get(), (uint32_t) index, thread_sp.get());
}
return sb_thread;
@ -413,16 +426,17 @@ SBProcess::GetState ()
{
StateType ret_val = eStateInvalid;
if (m_opaque_sp)
ProcessSP process_sp(GetSP());
if (process_sp)
{
Mutex::Locker api_locker (m_opaque_sp->GetTarget().GetAPIMutex());
ret_val = m_opaque_sp->GetState();
Mutex::Locker api_locker (process_sp->GetTarget().GetAPIMutex());
ret_val = process_sp->GetState();
}
LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
if (log)
log->Printf ("SBProcess(%p)::GetState () => %s",
m_opaque_sp.get(),
process_sp.get(),
lldb_private::StateAsCString (ret_val));
return ret_val;
@ -433,15 +447,16 @@ int
SBProcess::GetExitStatus ()
{
int exit_status = 0;
if (m_opaque_sp)
ProcessSP process_sp(GetSP());
if (process_sp)
{
Mutex::Locker api_locker (m_opaque_sp->GetTarget().GetAPIMutex());
exit_status = m_opaque_sp->GetExitStatus ();
Mutex::Locker api_locker (process_sp->GetTarget().GetAPIMutex());
exit_status = process_sp->GetExitStatus ();
}
LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
if (log)
log->Printf ("SBProcess(%p)::GetExitStatus () => %i (0x%8.8x)",
m_opaque_sp.get(), exit_status, exit_status);
process_sp.get(), exit_status, exit_status);
return exit_status;
}
@ -450,15 +465,16 @@ const char *
SBProcess::GetExitDescription ()
{
const char *exit_desc = NULL;
if (m_opaque_sp)
ProcessSP process_sp(GetSP());
if (process_sp)
{
Mutex::Locker api_locker (m_opaque_sp->GetTarget().GetAPIMutex());
exit_desc = m_opaque_sp->GetExitDescription ();
Mutex::Locker api_locker (process_sp->GetTarget().GetAPIMutex());
exit_desc = process_sp->GetExitDescription ();
}
LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
if (log)
log->Printf ("SBProcess(%p)::GetExitDescription () => %s",
m_opaque_sp.get(), exit_desc);
process_sp.get(), exit_desc);
return exit_desc;
}
@ -466,12 +482,13 @@ lldb::pid_t
SBProcess::GetProcessID ()
{
lldb::pid_t ret_val = LLDB_INVALID_PROCESS_ID;
if (m_opaque_sp)
ret_val = m_opaque_sp->GetID();
ProcessSP process_sp(GetSP());
if (process_sp)
ret_val = process_sp->GetID();
LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
if (log)
log->Printf ("SBProcess(%p)::GetProcessID () => %llu", m_opaque_sp.get(), ret_val);
log->Printf ("SBProcess(%p)::GetProcessID () => %llu", process_sp.get(), ret_val);
return ret_val;
}
@ -480,12 +497,13 @@ ByteOrder
SBProcess::GetByteOrder () const
{
ByteOrder byteOrder = eByteOrderInvalid;
if (m_opaque_sp)
byteOrder = m_opaque_sp->GetTarget().GetArchitecture().GetByteOrder();
ProcessSP process_sp(GetSP());
if (process_sp)
byteOrder = process_sp->GetTarget().GetArchitecture().GetByteOrder();
LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
if (log)
log->Printf ("SBProcess(%p)::GetByteOrder () => %d", m_opaque_sp.get(), byteOrder);
log->Printf ("SBProcess(%p)::GetByteOrder () => %d", process_sp.get(), byteOrder);
return byteOrder;
}
@ -494,12 +512,13 @@ uint32_t
SBProcess::GetAddressByteSize () const
{
uint32_t size = 0;
if (m_opaque_sp)
size = m_opaque_sp->GetTarget().GetArchitecture().GetAddressByteSize();
ProcessSP process_sp(GetSP());
if (process_sp)
size = process_sp->GetTarget().GetArchitecture().GetAddressByteSize();
LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
if (log)
log->Printf ("SBProcess(%p)::GetAddressByteSize () => %d", m_opaque_sp.get(), size);
log->Printf ("SBProcess(%p)::GetAddressByteSize () => %d", process_sp.get(), size);
return size;
}
@ -508,22 +527,25 @@ SBError
SBProcess::Continue ()
{
LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
if (log)
log->Printf ("SBProcess(%p)::Continue ()...", m_opaque_sp.get());
SBError sb_error;
if (m_opaque_sp)
ProcessSP process_sp(GetSP());
if (log)
log->Printf ("SBProcess(%p)::Continue ()...", process_sp.get());
if (process_sp)
{
Mutex::Locker api_locker (m_opaque_sp->GetTarget().GetAPIMutex());
Mutex::Locker api_locker (process_sp->GetTarget().GetAPIMutex());
Error error (m_opaque_sp->Resume());
Error error (process_sp->Resume());
if (error.Success())
{
if (m_opaque_sp->GetTarget().GetDebugger().GetAsyncExecution () == false)
if (process_sp->GetTarget().GetDebugger().GetAsyncExecution () == false)
{
if (log)
log->Printf ("SBProcess(%p)::Continue () waiting for process to stop...", m_opaque_sp.get());
m_opaque_sp->WaitForProcessToStop (NULL);
log->Printf ("SBProcess(%p)::Continue () waiting for process to stop...", process_sp.get());
process_sp->WaitForProcessToStop (NULL);
}
}
sb_error.SetError(error);
@ -535,7 +557,7 @@ SBProcess::Continue ()
{
SBStream sstr;
sb_error.GetDescription (sstr);
log->Printf ("SBProcess(%p)::Continue () => SBError (%p): %s", m_opaque_sp.get(), sb_error.get(), sstr.GetData());
log->Printf ("SBProcess(%p)::Continue () => SBError (%p): %s", process_sp.get(), sb_error.get(), sstr.GetData());
}
return sb_error;
@ -546,10 +568,11 @@ SBError
SBProcess::Destroy ()
{
SBError sb_error;
if (m_opaque_sp)
ProcessSP process_sp(GetSP());
if (process_sp)
{
Mutex::Locker api_locker (m_opaque_sp->GetTarget().GetAPIMutex());
sb_error.SetError(m_opaque_sp->Destroy());
Mutex::Locker api_locker (process_sp->GetTarget().GetAPIMutex());
sb_error.SetError(process_sp->Destroy());
}
else
sb_error.SetErrorString ("SBProcess is invalid");
@ -560,7 +583,7 @@ SBProcess::Destroy ()
SBStream sstr;
sb_error.GetDescription (sstr);
log->Printf ("SBProcess(%p)::Destroy () => SBError (%p): %s",
m_opaque_sp.get(),
process_sp.get(),
sb_error.get(),
sstr.GetData());
}
@ -573,10 +596,11 @@ SBError
SBProcess::Stop ()
{
SBError sb_error;
if (m_opaque_sp)
ProcessSP process_sp(GetSP());
if (process_sp)
{
Mutex::Locker api_locker (m_opaque_sp->GetTarget().GetAPIMutex());
sb_error.SetError (m_opaque_sp->Halt());
Mutex::Locker api_locker (process_sp->GetTarget().GetAPIMutex());
sb_error.SetError (process_sp->Halt());
}
else
sb_error.SetErrorString ("SBProcess is invalid");
@ -587,7 +611,7 @@ SBProcess::Stop ()
SBStream sstr;
sb_error.GetDescription (sstr);
log->Printf ("SBProcess(%p)::Stop () => SBError (%p): %s",
m_opaque_sp.get(),
process_sp.get(),
sb_error.get(),
sstr.GetData());
}
@ -599,10 +623,11 @@ SBError
SBProcess::Kill ()
{
SBError sb_error;
if (m_opaque_sp)
ProcessSP process_sp(GetSP());
if (process_sp)
{
Mutex::Locker api_locker (m_opaque_sp->GetTarget().GetAPIMutex());
sb_error.SetError (m_opaque_sp->Destroy());
Mutex::Locker api_locker (process_sp->GetTarget().GetAPIMutex());
sb_error.SetError (process_sp->Destroy());
}
else
sb_error.SetErrorString ("SBProcess is invalid");
@ -613,7 +638,7 @@ SBProcess::Kill ()
SBStream sstr;
sb_error.GetDescription (sstr);
log->Printf ("SBProcess(%p)::Kill () => SBError (%p): %s",
m_opaque_sp.get(),
process_sp.get(),
sb_error.get(),
sstr.GetData());
}
@ -625,10 +650,11 @@ SBError
SBProcess::Detach ()
{
SBError sb_error;
if (m_opaque_sp)
ProcessSP process_sp(GetSP());
if (process_sp)
{
Mutex::Locker api_locker (m_opaque_sp->GetTarget().GetAPIMutex());
sb_error.SetError (m_opaque_sp->Detach());
Mutex::Locker api_locker (process_sp->GetTarget().GetAPIMutex());
sb_error.SetError (process_sp->Detach());
}
else
sb_error.SetErrorString ("SBProcess is invalid");
@ -640,10 +666,11 @@ SBError
SBProcess::Signal (int signo)
{
SBError sb_error;
if (m_opaque_sp)
ProcessSP process_sp(GetSP());
if (process_sp)
{
Mutex::Locker api_locker (m_opaque_sp->GetTarget().GetAPIMutex());
sb_error.SetError (m_opaque_sp->Signal (signo));
Mutex::Locker api_locker (process_sp->GetTarget().GetAPIMutex());
sb_error.SetError (process_sp->Signal (signo));
}
else
sb_error.SetErrorString ("SBProcess is invalid");
@ -653,7 +680,7 @@ SBProcess::Signal (int signo)
SBStream sstr;
sb_error.GetDescription (sstr);
log->Printf ("SBProcess(%p)::Signal (signo=%i) => SBError (%p): %s",
m_opaque_sp.get(),
process_sp.get(),
signo,
sb_error.get(),
sstr.GetData());
@ -666,10 +693,11 @@ SBProcess::GetThreadByID (tid_t tid)
{
SBThread sb_thread;
ThreadSP thread_sp;
if (m_opaque_sp)
ProcessSP process_sp(GetSP());
if (process_sp)
{
Mutex::Locker api_locker (m_opaque_sp->GetTarget().GetAPIMutex());
thread_sp = m_opaque_sp->GetThreadList().FindThreadByID (tid);
Mutex::Locker api_locker (process_sp->GetTarget().GetAPIMutex());
thread_sp = process_sp->GetThreadList().FindThreadByID (tid);
sb_thread.SetThread (thread_sp);
}
@ -677,7 +705,7 @@ SBProcess::GetThreadByID (tid_t tid)
if (log)
{
log->Printf ("SBProcess(%p)::GetThreadByID (tid=0x%4.4llx) => SBThread (%p)",
m_opaque_sp.get(),
process_sp.get(),
tid,
thread_sp.get());
}
@ -718,10 +746,12 @@ SBProcess::GetBroadcaster () const
{
LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
SBBroadcaster broadcaster(m_opaque_sp.get(), false);
ProcessSP process_sp(GetSP());
SBBroadcaster broadcaster(process_sp.get(), false);
if (log)
log->Printf ("SBProcess(%p)::GetBroadcaster () => SBBroadcaster (%p)", m_opaque_sp.get(),
log->Printf ("SBProcess(%p)::GetBroadcaster () => SBBroadcaster (%p)", process_sp.get(),
broadcaster.get());
return broadcaster;
@ -734,21 +764,23 @@ SBProcess::ReadMemory (addr_t addr, void *dst, size_t dst_len, SBError &sb_error
size_t bytes_read = 0;
ProcessSP process_sp(GetSP());
if (log)
{
log->Printf ("SBProcess(%p)::ReadMemory (addr=0x%llx, dst=%p, dst_len=%zu, SBError (%p))...",
m_opaque_sp.get(),
process_sp.get(),
addr,
dst,
dst_len,
sb_error.get());
}
if (m_opaque_sp)
if (process_sp)
{
Error error;
Mutex::Locker api_locker (m_opaque_sp->GetTarget().GetAPIMutex());
bytes_read = m_opaque_sp->ReadMemory (addr, dst, dst_len, error);
Mutex::Locker api_locker (process_sp->GetTarget().GetAPIMutex());
bytes_read = process_sp->ReadMemory (addr, dst, dst_len, error);
sb_error.SetError (error);
}
else
@ -761,7 +793,7 @@ SBProcess::ReadMemory (addr_t addr, void *dst, size_t dst_len, SBError &sb_error
SBStream sstr;
sb_error.GetDescription (sstr);
log->Printf ("SBProcess(%p)::ReadMemory (addr=0x%llx, dst=%p, dst_len=%zu, SBError (%p): %s) => %zu",
m_opaque_sp.get(),
process_sp.get(),
addr,
dst,
dst_len,
@ -777,11 +809,12 @@ size_t
SBProcess::ReadCStringFromMemory (addr_t addr, void *buf, size_t size, lldb::SBError &sb_error)
{
size_t bytes_read = 0;
if (m_opaque_sp)
ProcessSP process_sp(GetSP());
if (process_sp)
{
Error error;
Mutex::Locker api_locker (m_opaque_sp->GetTarget().GetAPIMutex());
bytes_read = m_opaque_sp->ReadCStringFromMemory (addr, (char *)buf, size, error);
Mutex::Locker api_locker (process_sp->GetTarget().GetAPIMutex());
bytes_read = process_sp->ReadCStringFromMemory (addr, (char *)buf, size, error);
sb_error.SetError (error);
}
else
@ -794,11 +827,12 @@ SBProcess::ReadCStringFromMemory (addr_t addr, void *buf, size_t size, lldb::SBE
uint64_t
SBProcess::ReadUnsignedFromMemory (addr_t addr, uint32_t byte_size, lldb::SBError &sb_error)
{
if (m_opaque_sp)
ProcessSP process_sp(GetSP());
if (process_sp)
{
Error error;
Mutex::Locker api_locker (m_opaque_sp->GetTarget().GetAPIMutex());
uint64_t value = m_opaque_sp->ReadUnsignedIntegerFromMemory (addr, byte_size, 0, error);
Mutex::Locker api_locker (process_sp->GetTarget().GetAPIMutex());
uint64_t value = process_sp->ReadUnsignedIntegerFromMemory (addr, byte_size, 0, error);
sb_error.SetError (error);
return value;
}
@ -813,11 +847,12 @@ lldb::addr_t
SBProcess::ReadPointerFromMemory (addr_t addr, lldb::SBError &sb_error)
{
lldb::addr_t ptr = LLDB_INVALID_ADDRESS;
if (m_opaque_sp)
ProcessSP process_sp(GetSP());
if (process_sp)
{
Error error;
Mutex::Locker api_locker (m_opaque_sp->GetTarget().GetAPIMutex());
ptr = m_opaque_sp->ReadPointerFromMemory (addr, error);
Mutex::Locker api_locker (process_sp->GetTarget().GetAPIMutex());
ptr = process_sp->ReadPointerFromMemory (addr, error);
sb_error.SetError (error);
}
else
@ -833,21 +868,24 @@ SBProcess::WriteMemory (addr_t addr, const void *src, size_t src_len, SBError &s
size_t bytes_written = 0;
LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
ProcessSP process_sp(GetSP());
if (log)
{
log->Printf ("SBProcess(%p)::WriteMemory (addr=0x%llx, src=%p, dst_len=%zu, SBError (%p))...",
m_opaque_sp.get(),
process_sp.get(),
addr,
src,
src_len,
sb_error.get());
}
if (m_opaque_sp)
if (process_sp)
{
Error error;
Mutex::Locker api_locker (m_opaque_sp->GetTarget().GetAPIMutex());
bytes_written = m_opaque_sp->WriteMemory (addr, src, src_len, error);
Mutex::Locker api_locker (process_sp->GetTarget().GetAPIMutex());
bytes_written = process_sp->WriteMemory (addr, src, src_len, error);
sb_error.SetError (error);
}
@ -856,7 +894,7 @@ SBProcess::WriteMemory (addr_t addr, const void *src, size_t src_len, SBError &s
SBStream sstr;
sb_error.GetDescription (sstr);
log->Printf ("SBProcess(%p)::WriteMemory (addr=0x%llx, src=%p, dst_len=%zu, SBError (%p): %s) => %zu",
m_opaque_sp.get(),
process_sp.get(),
addr,
src,
src_len,
@ -873,17 +911,18 @@ SBProcess::GetDescription (SBStream &description)
{
Stream &strm = description.ref();
if (m_opaque_sp)
ProcessSP process_sp(GetSP());
if (process_sp)
{
char path[PATH_MAX];
GetTarget().GetExecutable().GetPath (path, sizeof(path));
Module *exe_module = m_opaque_sp->GetTarget().GetExecutableModulePointer();
Module *exe_module = process_sp->GetTarget().GetExecutableModulePointer();
const char *exe_name = NULL;
if (exe_module)
exe_name = exe_module->GetFileSpec().GetFilename().AsCString();
strm.Printf ("SBProcess: pid = %llu, state = %s, threads = %d%s%s",
m_opaque_sp->GetID(),
process_sp->GetID(),
lldb_private::StateAsCString (GetState()),
GetNumThreads(),
exe_name ? ", executable = " : "",
@ -898,10 +937,11 @@ SBProcess::GetDescription (SBStream &description)
uint32_t
SBProcess::LoadImage (lldb::SBFileSpec &sb_image_spec, lldb::SBError &sb_error)
{
if (m_opaque_sp)
ProcessSP process_sp(GetSP());
if (process_sp)
{
Mutex::Locker api_locker (m_opaque_sp->GetTarget().GetAPIMutex());
return m_opaque_sp->LoadImage (*sb_image_spec, sb_error.ref());
Mutex::Locker api_locker (process_sp->GetTarget().GetAPIMutex());
return process_sp->LoadImage (*sb_image_spec, sb_error.ref());
}
return LLDB_INVALID_IMAGE_TOKEN;
}
@ -910,10 +950,11 @@ lldb::SBError
SBProcess::UnloadImage (uint32_t image_token)
{
lldb::SBError sb_error;
if (m_opaque_sp)
ProcessSP process_sp(GetSP());
if (process_sp)
{
Mutex::Locker api_locker (m_opaque_sp->GetTarget().GetAPIMutex());
sb_error.SetError (m_opaque_sp->UnloadImage (image_token));
Mutex::Locker api_locker (process_sp->GetTarget().GetAPIMutex());
sb_error.SetError (process_sp->UnloadImage (image_token));
}
else
sb_error.SetErrorString("invalid process");

10
lldb/source/API/SBSymbolContext.cpp
View File

@ -90,15 +90,19 @@ SBSymbolContext::GetModule ()
LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
SBModule sb_module;
ModuleSP module_sp;
if (m_opaque_ap.get())
sb_module.SetModule(m_opaque_ap->module_sp);
{
module_sp = m_opaque_ap->module_sp;
sb_module.SetSP (module_sp);
}
if (log)
{
SBStream sstr;
sb_module.GetDescription (sstr);
log->Printf ("SBSymbolContext(%p)::GetModule () => SBModule(%p): %s",
m_opaque_ap.get(), sb_module.get(), sstr.GetData());
m_opaque_ap.get(), module_sp.get(), sstr.GetData());
}
return sb_module;
@ -177,7 +181,7 @@ SBSymbolContext::GetSymbol ()
void
SBSymbolContext::SetModule (lldb::SBModule module)
{
ref().module_sp = module.get_sp();
ref().module_sp = module.GetSP();
}
void

450
lldb/source/API/SBTarget.cpp
View File

File diff suppressed because it is too large Load Diff