Initial checkin of lldb code from internal Apple repo.
llvm-svn: 105619
This commit is contained in:
Chris Lattner
604
lldb/source/API/SBProcess.cpp
Normal file
604
lldb/source/API/SBProcess.cpp
Normal file
@@ -0,0 +1,604 @@
|
||||
//===-- SBProcess.cpp -------------------------------------------*- C++ -*-===//
|
||||
//
|
||||
// The LLVM Compiler Infrastructure
|
||||
//
|
||||
// This file is distributed under the University of Illinois Open Source
|
||||
// License. See LICENSE.TXT for details.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
#include "SBProcess.h"
|
||||
|
||||
#include "lldb/lldb-defines.h"
|
||||
#include "lldb/lldb-types.h"
|
||||
|
||||
#include "lldb/Core/Args.h"
|
||||
#include "lldb/Core/DataBufferHeap.h"
|
||||
#include "lldb/Core/DataExtractor.h"
|
||||
#include "lldb/Core/State.h"
|
||||
#include "lldb/Core/Stream.h"
|
||||
#include "lldb/Core/StreamFile.h"
|
||||
#include "lldb/Target/Process.h"
|
||||
#include "lldb/Target/Thread.h"
|
||||
#include "lldb/Target/RegisterContext.h"
|
||||
|
||||
// Project includes
|
||||
|
||||
#include "SBBroadcaster.h"
|
||||
#include "SBDebugger.h"
|
||||
#include "SBCommandReturnObject.h"
|
||||
#include "SBEvent.h"
|
||||
#include "SBThread.h"
|
||||
#include "SBStringList.h"
|
||||
|
||||
using namespace lldb;
|
||||
using namespace lldb_private;
|
||||
|
||||
|
||||
|
||||
SBProcess::SBProcess () :
|
||||
m_lldb_object_sp()
|
||||
{
|
||||
}
|
||||
|
||||
|
||||
//----------------------------------------------------------------------
|
||||
// SBProcess constructor
|
||||
//----------------------------------------------------------------------
|
||||
|
||||
SBProcess::SBProcess (const SBProcess& rhs) :
|
||||
m_lldb_object_sp (rhs.m_lldb_object_sp)
|
||||
{
|
||||
}
|
||||
|
||||
|
||||
SBProcess::SBProcess (const lldb::ProcessSP &process_sp) :
|
||||
m_lldb_object_sp (process_sp)
|
||||
{
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------
|
||||
// Destructor
|
||||
//----------------------------------------------------------------------
|
||||
SBProcess::~SBProcess()
|
||||
{
|
||||
}
|
||||
|
||||
void
|
||||
SBProcess::SetProcess (const ProcessSP &process_sp)
|
||||
{
|
||||
m_lldb_object_sp = process_sp;
|
||||
}
|
||||
|
||||
void
|
||||
SBProcess::Clear ()
|
||||
{
|
||||
m_lldb_object_sp.reset();
|
||||
}
|
||||
|
||||
|
||||
bool
|
||||
SBProcess::IsValid() const
|
||||
{
|
||||
return m_lldb_object_sp.get() != NULL;
|
||||
}
|
||||
|
||||
|
||||
uint32_t
|
||||
SBProcess::GetNumThreads ()
|
||||
{
|
||||
if (m_lldb_object_sp)
|
||||
{
|
||||
const bool can_update = true;
|
||||
return m_lldb_object_sp->GetThreadList().GetSize(can_update);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
SBThread
|
||||
SBProcess::GetCurrentThread () const
|
||||
{
|
||||
SBThread sb_thread;
|
||||
if (m_lldb_object_sp)
|
||||
sb_thread.SetThread (m_lldb_object_sp->GetThreadList().GetCurrentThread());
|
||||
return sb_thread;
|
||||
}
|
||||
|
||||
SBTarget
|
||||
SBProcess::GetTarget() const
|
||||
{
|
||||
SBTarget sb_target;
|
||||
if (m_lldb_object_sp)
|
||||
sb_target = SBDebugger::FindTargetWithLLDBProcess (m_lldb_object_sp);
|
||||
return sb_target;
|
||||
}
|
||||
|
||||
|
||||
size_t
|
||||
SBProcess::PutSTDIN (const char *src, size_t src_len)
|
||||
{
|
||||
if (m_lldb_object_sp != NULL)
|
||||
{
|
||||
Error error;
|
||||
return m_lldb_object_sp->PutSTDIN (src, src_len, error);
|
||||
}
|
||||
else
|
||||
return 0;
|
||||
}
|
||||
|
||||
size_t
|
||||
SBProcess::GetSTDOUT (char *dst, size_t dst_len) const
|
||||
{
|
||||
if (m_lldb_object_sp != NULL)
|
||||
{
|
||||
Error error;
|
||||
return m_lldb_object_sp->GetSTDOUT (dst, dst_len, error);
|
||||
}
|
||||
else
|
||||
return 0;
|
||||
}
|
||||
|
||||
size_t
|
||||
SBProcess::GetSTDERR (char *dst, size_t dst_len) const
|
||||
{
|
||||
if (m_lldb_object_sp != NULL)
|
||||
{
|
||||
Error error;
|
||||
return m_lldb_object_sp->GetSTDERR (dst, dst_len, error);
|
||||
}
|
||||
else
|
||||
return 0;
|
||||
}
|
||||
|
||||
void
|
||||
SBProcess::ReportCurrentState (const SBEvent &event, FILE *out) const
|
||||
{
|
||||
if (out == NULL)
|
||||
return;
|
||||
|
||||
if (m_lldb_object_sp != NULL)
|
||||
{
|
||||
const StateType event_state = SBProcess::GetStateFromEvent (event);
|
||||
char message[1024];
|
||||
int message_len = ::snprintf (message,
|
||||
sizeof (message),
|
||||
"Process %d %s\n",
|
||||
m_lldb_object_sp->GetID(),
|
||||
SBDebugger::StateAsCString (event_state));
|
||||
|
||||
if (message_len > 0)
|
||||
::fwrite (message, 1, message_len, out);
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
SBProcess::AppendCurrentStateReport (const SBEvent &event, SBCommandReturnObject &result)
|
||||
{
|
||||
if (m_lldb_object_sp != NULL)
|
||||
{
|
||||
const StateType event_state = SBProcess::GetStateFromEvent (event);
|
||||
char message[1024];
|
||||
::snprintf (message,
|
||||
sizeof (message),
|
||||
"Process %d %s\n",
|
||||
m_lldb_object_sp->GetID(),
|
||||
SBDebugger::StateAsCString (event_state));
|
||||
|
||||
result.AppendMessage (message);
|
||||
}
|
||||
}
|
||||
|
||||
bool
|
||||
SBProcess::SetCurrentThread (const SBThread &thread)
|
||||
{
|
||||
if (m_lldb_object_sp != NULL)
|
||||
return m_lldb_object_sp->GetThreadList().SetCurrentThreadByID (thread.GetThreadID());
|
||||
return false;
|
||||
}
|
||||
|
||||
bool
|
||||
SBProcess::SetCurrentThreadByID (uint32_t tid)
|
||||
{
|
||||
if (m_lldb_object_sp != NULL)
|
||||
return m_lldb_object_sp->GetThreadList().SetCurrentThreadByID (tid);
|
||||
return false;
|
||||
}
|
||||
|
||||
SBThread
|
||||
SBProcess::GetThreadAtIndex (size_t index)
|
||||
{
|
||||
SBThread thread;
|
||||
if (m_lldb_object_sp)
|
||||
thread.SetThread (m_lldb_object_sp->GetThreadList().GetThreadAtIndex(index));
|
||||
return thread;
|
||||
}
|
||||
|
||||
StateType
|
||||
SBProcess::GetState ()
|
||||
{
|
||||
if (m_lldb_object_sp != NULL)
|
||||
return m_lldb_object_sp->GetState();
|
||||
else
|
||||
return eStateInvalid;
|
||||
}
|
||||
|
||||
|
||||
int
|
||||
SBProcess::GetExitStatus ()
|
||||
{
|
||||
if (m_lldb_object_sp != NULL)
|
||||
return m_lldb_object_sp->GetExitStatus ();
|
||||
else
|
||||
return 0;
|
||||
}
|
||||
|
||||
const char *
|
||||
SBProcess::GetExitDescription ()
|
||||
{
|
||||
if (m_lldb_object_sp != NULL)
|
||||
return m_lldb_object_sp->GetExitDescription ();
|
||||
else
|
||||
return NULL;
|
||||
}
|
||||
|
||||
lldb::pid_t
|
||||
SBProcess::GetProcessID ()
|
||||
{
|
||||
if (m_lldb_object_sp)
|
||||
return m_lldb_object_sp->GetID();
|
||||
else
|
||||
return LLDB_INVALID_PROCESS_ID;
|
||||
}
|
||||
|
||||
uint32_t
|
||||
SBProcess::GetAddressByteSize () const
|
||||
{
|
||||
if (m_lldb_object_sp)
|
||||
return m_lldb_object_sp->GetAddressByteSize();
|
||||
else
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
SBProcess::DisplayThreadsInfo (FILE *out, FILE *err, bool only_threads_with_stop_reason)
|
||||
{
|
||||
if (m_lldb_object_sp != NULL)
|
||||
{
|
||||
size_t num_thread_infos_dumped = 0;
|
||||
size_t num_threads = GetNumThreads();
|
||||
|
||||
if (out == NULL)
|
||||
out = SBDebugger::GetOutputFileHandle();
|
||||
|
||||
if (err == NULL)
|
||||
err = SBDebugger::GetErrorFileHandle();
|
||||
|
||||
if ((out == NULL) ||(err == NULL))
|
||||
return;
|
||||
|
||||
if (num_threads > 0)
|
||||
{
|
||||
Thread::StopInfo thread_stop_info;
|
||||
SBThread curr_thread (m_lldb_object_sp->GetThreadList().GetCurrentThread());
|
||||
for (int i = 0; i < num_threads; ++i)
|
||||
{
|
||||
SBThread thread (m_lldb_object_sp->GetThreadList().GetThreadAtIndex(i));
|
||||
if (thread.IsValid())
|
||||
{
|
||||
bool is_current_thread = false;
|
||||
StreamFile str (out);
|
||||
if (thread == curr_thread)
|
||||
is_current_thread = true;
|
||||
StopReason thread_stop_reason = eStopReasonNone;
|
||||
if (thread->GetStopInfo (&thread_stop_info))
|
||||
{
|
||||
thread_stop_reason = thread_stop_info.GetStopReason();
|
||||
if (thread_stop_reason == eStopReasonNone)
|
||||
{
|
||||
if (only_threads_with_stop_reason && !is_current_thread)
|
||||
continue;
|
||||
}
|
||||
}
|
||||
++num_thread_infos_dumped;
|
||||
fprintf (out, " %c thread #%u: tid = 0x%4.4x, pc = 0x%16.16llx",
|
||||
(is_current_thread ? '*' : ' '),
|
||||
thread->GetIndexID(), thread->GetID(), thread->GetRegisterContext()->GetPC());
|
||||
|
||||
StackFrameSP frame_sp(thread->GetStackFrameAtIndex (0));
|
||||
if (frame_sp)
|
||||
{
|
||||
SymbolContext sc (frame_sp->GetSymbolContext (eSymbolContextEverything));
|
||||
fprintf (out, ", where = ");
|
||||
sc.DumpStopContext (&str, m_lldb_object_sp.get(), frame_sp->GetPC ());
|
||||
}
|
||||
|
||||
if (thread_stop_reason != eStopReasonNone)
|
||||
{
|
||||
fprintf (out, ", stop reason = ");
|
||||
thread_stop_info.Dump (&str);
|
||||
}
|
||||
|
||||
const char *thread_name = thread->GetName();
|
||||
if (thread_name && thread_name[0])
|
||||
fprintf (out, ", thread_name = '%s'", thread_name);
|
||||
|
||||
fprintf (out, "\n");
|
||||
|
||||
SBThread sb_thread (thread);
|
||||
sb_thread.DisplayFramesForCurrentContext (out, err, 0, 1, false, 1);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
bool
|
||||
SBProcess::WaitUntilProcessHasStopped (SBCommandReturnObject &result)
|
||||
{
|
||||
bool state_changed = false;
|
||||
|
||||
if (IsValid())
|
||||
{
|
||||
EventSP event_sp;
|
||||
StateType state = m_lldb_object_sp->WaitForStateChangedEvents (NULL, event_sp);
|
||||
|
||||
while (StateIsStoppedState (state))
|
||||
{
|
||||
state = m_lldb_object_sp->WaitForStateChangedEvents (NULL, event_sp);
|
||||
SBEvent event (event_sp);
|
||||
AppendCurrentStateReport (event, result);
|
||||
state_changed = true;
|
||||
}
|
||||
}
|
||||
return state_changed;
|
||||
}
|
||||
|
||||
SBError
|
||||
SBProcess::Continue ()
|
||||
{
|
||||
SBError sb_error;
|
||||
if (IsValid())
|
||||
sb_error.SetError(m_lldb_object_sp->Resume());
|
||||
else
|
||||
sb_error.SetErrorString ("SBProcess is invalid");
|
||||
|
||||
return sb_error;
|
||||
}
|
||||
|
||||
|
||||
SBError
|
||||
SBProcess::Destroy ()
|
||||
{
|
||||
SBError sb_error;
|
||||
if (m_lldb_object_sp)
|
||||
sb_error.SetError(m_lldb_object_sp->Destroy());
|
||||
else
|
||||
sb_error.SetErrorString ("SBProcess is invalid");
|
||||
|
||||
return sb_error;
|
||||
}
|
||||
|
||||
|
||||
SBError
|
||||
SBProcess::Stop ()
|
||||
{
|
||||
SBError sb_error;
|
||||
if (IsValid())
|
||||
sb_error.SetError (m_lldb_object_sp->Halt());
|
||||
else
|
||||
sb_error.SetErrorString ("SBProcess is invalid");
|
||||
return sb_error;
|
||||
}
|
||||
|
||||
SBError
|
||||
SBProcess::Kill ()
|
||||
{
|
||||
SBError sb_error;
|
||||
if (m_lldb_object_sp)
|
||||
sb_error.SetError (m_lldb_object_sp->Destroy());
|
||||
else
|
||||
sb_error.SetErrorString ("SBProcess is invalid");
|
||||
return sb_error;
|
||||
}
|
||||
|
||||
|
||||
SBError
|
||||
SBProcess::AttachByName (const char *name, bool wait_for_launch)
|
||||
{
|
||||
SBError sb_error;
|
||||
if (m_lldb_object_sp)
|
||||
sb_error.SetError (m_lldb_object_sp->Attach (name, wait_for_launch));
|
||||
else
|
||||
sb_error.SetErrorString ("SBProcess is invalid");
|
||||
return sb_error;
|
||||
}
|
||||
|
||||
lldb::pid_t
|
||||
SBProcess::AttachByPID (lldb::pid_t attach_pid) // DEPRECATED: will be removed in a few builds in favor of SBError AttachByPID(pid_t)
|
||||
{
|
||||
Attach (attach_pid);
|
||||
return GetProcessID();
|
||||
}
|
||||
|
||||
|
||||
SBError
|
||||
SBProcess::Attach (lldb::pid_t attach_pid)
|
||||
{
|
||||
SBError sb_error;
|
||||
if (m_lldb_object_sp)
|
||||
sb_error.SetError (m_lldb_object_sp->Attach (attach_pid));
|
||||
else
|
||||
sb_error.SetErrorString ("SBProcess is invalid");
|
||||
return sb_error;
|
||||
}
|
||||
|
||||
SBError
|
||||
SBProcess::Detach ()
|
||||
{
|
||||
SBError sb_error;
|
||||
if (m_lldb_object_sp)
|
||||
sb_error.SetError (m_lldb_object_sp->Detach());
|
||||
else
|
||||
sb_error.SetErrorString ("SBProcess is invalid");
|
||||
|
||||
return sb_error;
|
||||
}
|
||||
|
||||
SBError
|
||||
SBProcess::Signal (int signal)
|
||||
{
|
||||
SBError sb_error;
|
||||
if (m_lldb_object_sp)
|
||||
sb_error.SetError (m_lldb_object_sp->Signal (signal));
|
||||
else
|
||||
sb_error.SetErrorString ("SBProcess is invalid");
|
||||
return sb_error;
|
||||
}
|
||||
|
||||
void
|
||||
SBProcess::ListThreads ()
|
||||
{
|
||||
FILE *out = SBDebugger::GetOutputFileHandle();
|
||||
if (out == NULL)
|
||||
return;
|
||||
|
||||
if (m_lldb_object_sp)
|
||||
{
|
||||
size_t num_threads = GetNumThreads ();
|
||||
if (num_threads > 0)
|
||||
{
|
||||
Thread *cur_thread = m_lldb_object_sp->GetThreadList().GetCurrentThread().get();
|
||||
for (int i = 0; i < num_threads; ++i)
|
||||
{
|
||||
Thread *thread = m_lldb_object_sp->GetThreadList().GetThreadAtIndex(i).get();
|
||||
if (thread)
|
||||
{
|
||||
bool is_current_thread = false;
|
||||
if (thread == cur_thread)
|
||||
is_current_thread = true;
|
||||
fprintf (out, " [%u] %c tid = 0x%4.4x, pc = 0x%16.16llx",
|
||||
i,
|
||||
(is_current_thread ? '*' : ' '),
|
||||
thread->GetID(),
|
||||
thread->GetRegisterContext()->GetPC());
|
||||
const char *thread_name = thread->GetName();
|
||||
if (thread_name && thread_name[0])
|
||||
fprintf (out, ", name = %s", thread_name);
|
||||
const char *queue_name = thread->GetQueueName();
|
||||
if (queue_name && queue_name[0])
|
||||
fprintf (out, ", queue = %s", queue_name);
|
||||
fprintf (out, "\n");
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
SBThread
|
||||
SBProcess::GetThreadByID (tid_t sb_thread_id)
|
||||
{
|
||||
SBThread thread;
|
||||
if (m_lldb_object_sp)
|
||||
thread.SetThread (m_lldb_object_sp->GetThreadList().FindThreadByID ((tid_t) sb_thread_id));
|
||||
return thread;
|
||||
}
|
||||
|
||||
void
|
||||
SBProcess::Backtrace (bool all_threads, uint32_t num_frames)
|
||||
{
|
||||
if (m_lldb_object_sp)
|
||||
{
|
||||
if (!all_threads)
|
||||
{
|
||||
SBDebugger::UpdateCurrentThread (*this);
|
||||
SBThread cur_thread = GetCurrentThread();
|
||||
if (cur_thread.IsValid())
|
||||
cur_thread.Backtrace (num_frames);
|
||||
}
|
||||
else
|
||||
{
|
||||
int num_threads = GetNumThreads ();
|
||||
for (int i = 0; i < num_threads; ++i)
|
||||
{
|
||||
SBThread sb_thread = GetThreadAtIndex (i);
|
||||
sb_thread.Backtrace (num_frames);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
StateType
|
||||
SBProcess::GetStateFromEvent (const SBEvent &event)
|
||||
{
|
||||
return Process::ProcessEventData::GetStateFromEvent (event.GetLLDBObjectPtr());
|
||||
}
|
||||
|
||||
|
||||
bool
|
||||
SBProcess::GetRestartedFromEvent (const SBEvent &event)
|
||||
{
|
||||
return Process::ProcessEventData::GetRestartedFromEvent (event.GetLLDBObjectPtr());
|
||||
}
|
||||
|
||||
SBProcess
|
||||
SBProcess::GetProcessFromEvent (const SBEvent &event)
|
||||
{
|
||||
SBProcess process(Process::ProcessEventData::GetProcessFromEvent (event.GetLLDBObjectPtr()));
|
||||
return process;
|
||||
}
|
||||
|
||||
|
||||
SBBroadcaster
|
||||
SBProcess::GetBroadcaster () const
|
||||
{
|
||||
SBBroadcaster broadcaster(m_lldb_object_sp.get(), false);
|
||||
return broadcaster;
|
||||
}
|
||||
|
||||
lldb_private::Process *
|
||||
SBProcess::operator->() const
|
||||
{
|
||||
return m_lldb_object_sp.get();
|
||||
}
|
||||
|
||||
size_t
|
||||
SBProcess::ReadMemory (addr_t addr, void *dst, size_t dst_len, SBError &sb_error)
|
||||
{
|
||||
size_t bytes_read = 0;
|
||||
|
||||
if (IsValid())
|
||||
{
|
||||
Error error;
|
||||
bytes_read = m_lldb_object_sp->ReadMemory (addr, dst, dst_len, error);
|
||||
sb_error.SetError (error);
|
||||
}
|
||||
else
|
||||
{
|
||||
sb_error.SetErrorString ("SBProcess is invalid");
|
||||
}
|
||||
|
||||
return bytes_read;
|
||||
}
|
||||
|
||||
size_t
|
||||
SBProcess::WriteMemory (addr_t addr, const void *src, size_t src_len, SBError &sb_error)
|
||||
{
|
||||
size_t bytes_written = 0;
|
||||
|
||||
if (IsValid())
|
||||
{
|
||||
Error error;
|
||||
bytes_written = m_lldb_object_sp->WriteMemory (addr, src, src_len, error);
|
||||
sb_error.SetError (error);
|
||||
}
|
||||
|
||||
return bytes_written;
|
||||
}
|
||||
|
||||
// Mimic shared pointer...
|
||||
lldb_private::Process *
|
||||
SBProcess::get() const
|
||||
{
|
||||
return m_lldb_object_sp.get();
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user