ebc1bb277c
Add functions to look up debugger by id Add global variable to lldb python module, to hold debugger id Modify embedded Python interpreter to update the global variable with the id of its current debugger. Modify the char ** typemap definition in lldb.swig to accept 'None' (for NULL) as a valid value. The point of all this is so that, when you drop into the embedded interpreter from the command interpreter (or when doing Python-based breakpoint commands), there is a way for the Python side to find/get the correct debugger instance ( by checking debugger_unique_id, then calling SBDebugger::FindDebuggerWithID on it). llvm-svn: 107287
560 lines
14 KiB
C++
560 lines
14 KiB
C++
//===-- SBDebugger.cpp ------------------------------------------*- C++ -*-===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "lldb/API/SBDebugger.h"
|
|
|
|
#include "lldb/lldb-include.h"
|
|
#include "lldb/Interpreter/Args.h"
|
|
#include "lldb/Core/Debugger.h"
|
|
#include "lldb/Core/State.h"
|
|
#include "lldb/Target/Process.h"
|
|
#include "lldb/Target/TargetList.h"
|
|
|
|
#include "lldb/API/SBListener.h"
|
|
#include "lldb/API/SBBroadcaster.h"
|
|
#include "lldb/API/SBCommandInterpreter.h"
|
|
#include "lldb/API/SBCommandReturnObject.h"
|
|
#include "lldb/API/SBEvent.h"
|
|
#include "lldb/API/SBFrame.h"
|
|
#include "lldb/API/SBTarget.h"
|
|
#include "lldb/API/SBProcess.h"
|
|
#include "lldb/API/SBThread.h"
|
|
#include "lldb/API/SBSourceManager.h"
|
|
#include "lldb/API/SBInputReader.h"
|
|
|
|
using namespace lldb;
|
|
using namespace lldb_private;
|
|
|
|
void
|
|
SBDebugger::Initialize ()
|
|
{
|
|
Debugger::Initialize();
|
|
}
|
|
|
|
void
|
|
SBDebugger::Terminate ()
|
|
{
|
|
Debugger::Terminate();
|
|
}
|
|
|
|
SBDebugger
|
|
SBDebugger::Create()
|
|
{
|
|
SBDebugger debugger;
|
|
debugger.reset(Debugger::CreateInstance());
|
|
return debugger;
|
|
}
|
|
|
|
SBDebugger::SBDebugger () :
|
|
m_opaque_sp ()
|
|
{
|
|
}
|
|
|
|
SBDebugger::~SBDebugger ()
|
|
{
|
|
}
|
|
|
|
bool
|
|
SBDebugger::IsValid() const
|
|
{
|
|
return m_opaque_sp.get() != NULL;
|
|
}
|
|
|
|
|
|
void
|
|
SBDebugger::SetAsync (bool b)
|
|
{
|
|
if (m_opaque_sp)
|
|
m_opaque_sp->SetAsyncExecution(b);
|
|
}
|
|
|
|
// Shouldn't really be settable after initialization as this could cause lots of problems; don't want users
|
|
// trying to switch modes in the middle of a debugging session.
|
|
void
|
|
SBDebugger::SetInputFileHandle (FILE *fh, bool transfer_ownership)
|
|
{
|
|
if (m_opaque_sp)
|
|
m_opaque_sp->SetInputFileHandle (fh, transfer_ownership);
|
|
}
|
|
|
|
void
|
|
SBDebugger::SetOutputFileHandle (FILE *fh, bool transfer_ownership)
|
|
{
|
|
if (m_opaque_sp)
|
|
m_opaque_sp->SetOutputFileHandle (fh, transfer_ownership);
|
|
}
|
|
|
|
void
|
|
SBDebugger::SetErrorFileHandle (FILE *fh, bool transfer_ownership)
|
|
{
|
|
if (m_opaque_sp)
|
|
m_opaque_sp->SetErrorFileHandle (fh, transfer_ownership);
|
|
}
|
|
|
|
FILE *
|
|
SBDebugger::GetInputFileHandle ()
|
|
{
|
|
if (m_opaque_sp)
|
|
return m_opaque_sp->GetInputFileHandle();
|
|
return NULL;
|
|
}
|
|
|
|
FILE *
|
|
SBDebugger::GetOutputFileHandle ()
|
|
{
|
|
if (m_opaque_sp)
|
|
return m_opaque_sp->GetOutputFileHandle();
|
|
return NULL;
|
|
}
|
|
|
|
FILE *
|
|
SBDebugger::GetErrorFileHandle ()
|
|
{
|
|
if (m_opaque_sp)
|
|
return m_opaque_sp->GetErrorFileHandle();
|
|
return NULL;
|
|
}
|
|
|
|
SBCommandInterpreter
|
|
SBDebugger::GetCommandInterpreter ()
|
|
{
|
|
SBCommandInterpreter sb_interpreter;
|
|
if (m_opaque_sp)
|
|
sb_interpreter.reset (&m_opaque_sp->GetCommandInterpreter());
|
|
return sb_interpreter;
|
|
}
|
|
|
|
void
|
|
SBDebugger::HandleCommand (const char *command)
|
|
{
|
|
if (m_opaque_sp)
|
|
{
|
|
SBCommandInterpreter sb_interpreter(GetCommandInterpreter ());
|
|
SBCommandReturnObject result;
|
|
|
|
sb_interpreter.HandleCommand (command, result, false);
|
|
|
|
if (GetErrorFileHandle() != NULL)
|
|
result.PutError (GetErrorFileHandle());
|
|
if (GetOutputFileHandle() != NULL)
|
|
result.PutOutput (GetOutputFileHandle());
|
|
|
|
if (m_opaque_sp->GetAsyncExecution() == false)
|
|
{
|
|
SBProcess process(GetCommandInterpreter().GetProcess ());
|
|
if (process.IsValid())
|
|
{
|
|
EventSP event_sp;
|
|
Listener &lldb_listener = m_opaque_sp->GetListener();
|
|
while (lldb_listener.GetNextEventForBroadcaster (process.get(), event_sp))
|
|
{
|
|
SBEvent event(event_sp);
|
|
HandleProcessEvent (process, event, GetOutputFileHandle(), GetErrorFileHandle());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
SBListener
|
|
SBDebugger::GetListener ()
|
|
{
|
|
SBListener sb_listener;
|
|
if (m_opaque_sp)
|
|
sb_listener.reset(&m_opaque_sp->GetListener(), false);
|
|
return sb_listener;
|
|
}
|
|
|
|
void
|
|
SBDebugger::HandleProcessEvent (const SBProcess &process, const SBEvent &event, FILE *out, FILE *err)
|
|
{
|
|
const uint32_t event_type = event.GetType();
|
|
char stdio_buffer[1024];
|
|
size_t len;
|
|
|
|
if (event_type & Process::eBroadcastBitSTDOUT)
|
|
{
|
|
while ((len = process.GetSTDOUT (stdio_buffer, sizeof (stdio_buffer))) > 0)
|
|
if (out != NULL)
|
|
::fwrite (stdio_buffer, 1, len, out);
|
|
}
|
|
else if (event_type & Process::eBroadcastBitSTDERR)
|
|
{
|
|
while ((len = process.GetSTDERR (stdio_buffer, sizeof (stdio_buffer))) > 0)
|
|
if (out != NULL)
|
|
::fwrite (stdio_buffer, 1, len, out);
|
|
}
|
|
else if (event_type & Process::eBroadcastBitStateChanged)
|
|
{
|
|
// Drain any stdout messages.
|
|
while ((len = process.GetSTDOUT (stdio_buffer, sizeof (stdio_buffer))) > 0)
|
|
if (out != NULL)
|
|
::fwrite (stdio_buffer, 1, len, out);
|
|
|
|
// Drain any stderr messages.
|
|
while ((len = process.GetSTDERR (stdio_buffer, sizeof (stdio_buffer))) > 0)
|
|
if (out != NULL)
|
|
::fwrite (stdio_buffer, 1, len, out);
|
|
|
|
StateType event_state = SBProcess::GetStateFromEvent (event);
|
|
|
|
if (event_state == eStateInvalid)
|
|
return;
|
|
|
|
bool is_stopped = StateIsStoppedState (event_state);
|
|
if (!is_stopped)
|
|
process.ReportCurrentState (event, out);
|
|
}
|
|
}
|
|
|
|
void
|
|
SBDebugger::UpdateCurrentThread (SBProcess &process)
|
|
{
|
|
if (process.IsValid())
|
|
{
|
|
SBThread curr_thread = process.GetCurrentThread ();
|
|
SBThread thread;
|
|
StopReason curr_thread_stop_reason = eStopReasonInvalid;
|
|
if (curr_thread.IsValid())
|
|
{
|
|
if (curr_thread.GetStopReason() != eStopReasonInvalid)
|
|
curr_thread_stop_reason = curr_thread.GetStopReason ();
|
|
}
|
|
|
|
if (! curr_thread.IsValid()
|
|
|| curr_thread_stop_reason == eStopReasonInvalid
|
|
|| curr_thread_stop_reason == eStopReasonNone)
|
|
{
|
|
// Prefer a thread that has just completed its plan over another thread as current thread.
|
|
SBThread plan_thread;
|
|
SBThread other_thread;
|
|
const size_t num_threads = process.GetNumThreads ();
|
|
size_t i;
|
|
for (i = 0; i < num_threads; ++i)
|
|
{
|
|
thread = process.GetThreadAtIndex(i);
|
|
if (thread.GetStopReason () != eStopReasonInvalid)
|
|
{
|
|
switch (thread.GetStopReason ())
|
|
{
|
|
default:
|
|
case eStopReasonInvalid:
|
|
case eStopReasonNone:
|
|
break;
|
|
|
|
case eStopReasonTrace:
|
|
case eStopReasonBreakpoint:
|
|
case eStopReasonWatchpoint:
|
|
case eStopReasonSignal:
|
|
case eStopReasonException:
|
|
if (! other_thread.IsValid())
|
|
other_thread = thread;
|
|
break;
|
|
case eStopReasonPlanComplete:
|
|
if (! plan_thread.IsValid())
|
|
plan_thread = thread;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (plan_thread.IsValid())
|
|
process.SetCurrentThreadByID (plan_thread.GetThreadID());
|
|
else if (other_thread.IsValid())
|
|
process.SetCurrentThreadByID (other_thread.GetThreadID());
|
|
else
|
|
{
|
|
if (curr_thread.IsValid())
|
|
thread = curr_thread;
|
|
else
|
|
thread = process.GetThreadAtIndex(0);
|
|
|
|
if (thread.IsValid())
|
|
process.SetCurrentThreadByID (thread.GetThreadID());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
SBSourceManager &
|
|
SBDebugger::GetSourceManager ()
|
|
{
|
|
static SourceManager g_lldb_source_manager;
|
|
static SBSourceManager g_sb_source_manager (g_lldb_source_manager);
|
|
return g_sb_source_manager;
|
|
}
|
|
|
|
|
|
bool
|
|
SBDebugger::GetDefaultArchitecture (char *arch_name, size_t arch_name_len)
|
|
{
|
|
if (arch_name && arch_name_len)
|
|
{
|
|
ArchSpec &default_arch = lldb_private::GetDefaultArchitecture ();
|
|
if (default_arch.IsValid())
|
|
{
|
|
::snprintf (arch_name, arch_name_len, "%s", default_arch.AsCString());
|
|
return true;
|
|
}
|
|
}
|
|
if (arch_name && arch_name_len)
|
|
arch_name[0] = '\0';
|
|
return false;
|
|
}
|
|
|
|
|
|
bool
|
|
SBDebugger::SetDefaultArchitecture (const char *arch_name)
|
|
{
|
|
if (arch_name)
|
|
{
|
|
ArchSpec arch (arch_name);
|
|
if (arch.IsValid())
|
|
{
|
|
lldb_private::GetDefaultArchitecture () = arch;
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
ScriptLanguage
|
|
SBDebugger::GetScriptingLanguage (const char *script_language_name)
|
|
{
|
|
return Args::StringToScriptLanguage (script_language_name,
|
|
eScriptLanguageDefault,
|
|
NULL);
|
|
}
|
|
|
|
const char *
|
|
SBDebugger::GetVersionString ()
|
|
{
|
|
return lldb_private::GetVersion();
|
|
}
|
|
|
|
const char *
|
|
SBDebugger::StateAsCString (lldb::StateType state)
|
|
{
|
|
return lldb_private::StateAsCString (state);
|
|
}
|
|
|
|
bool
|
|
SBDebugger::StateIsRunningState (lldb::StateType state)
|
|
{
|
|
return lldb_private::StateIsRunningState (state);
|
|
}
|
|
|
|
bool
|
|
SBDebugger::StateIsStoppedState (lldb::StateType state)
|
|
{
|
|
return lldb_private::StateIsStoppedState (state);
|
|
}
|
|
|
|
|
|
SBTarget
|
|
SBDebugger::CreateTargetWithFileAndTargetTriple (const char *filename,
|
|
const char *target_triple)
|
|
{
|
|
SBTarget target;
|
|
if (m_opaque_sp)
|
|
{
|
|
ArchSpec arch;
|
|
FileSpec file_spec (filename);
|
|
arch.SetArchFromTargetTriple(target_triple);
|
|
TargetSP target_sp;
|
|
Error error (m_opaque_sp->GetTargetList().CreateTarget (*m_opaque_sp, file_spec, arch, NULL, true, target_sp));
|
|
target.reset (target_sp);
|
|
}
|
|
return target;
|
|
}
|
|
|
|
SBTarget
|
|
SBDebugger::CreateTargetWithFileAndArch (const char *filename, const char *archname)
|
|
{
|
|
SBTarget target;
|
|
if (m_opaque_sp)
|
|
{
|
|
FileSpec file (filename);
|
|
ArchSpec arch = lldb_private::GetDefaultArchitecture();
|
|
TargetSP target_sp;
|
|
Error error;
|
|
|
|
if (archname != NULL)
|
|
{
|
|
ArchSpec arch2 (archname);
|
|
error = m_opaque_sp->GetTargetList().CreateTarget (*m_opaque_sp, file, arch2, NULL, true, target_sp);
|
|
}
|
|
else
|
|
{
|
|
if (!arch.IsValid())
|
|
arch = LLDB_ARCH_DEFAULT;
|
|
|
|
error = m_opaque_sp->GetTargetList().CreateTarget (*m_opaque_sp, file, arch, NULL, true, target_sp);
|
|
|
|
if (error.Fail())
|
|
{
|
|
if (arch == LLDB_ARCH_DEFAULT_32BIT)
|
|
arch = LLDB_ARCH_DEFAULT_64BIT;
|
|
else
|
|
arch = LLDB_ARCH_DEFAULT_32BIT;
|
|
|
|
error = m_opaque_sp->GetTargetList().CreateTarget (*m_opaque_sp, file, arch, NULL, true, target_sp);
|
|
}
|
|
}
|
|
|
|
if (error.Success())
|
|
{
|
|
m_opaque_sp->GetTargetList().SetCurrentTarget (target_sp.get());
|
|
target.reset(target_sp);
|
|
}
|
|
}
|
|
return target;
|
|
}
|
|
|
|
SBTarget
|
|
SBDebugger::CreateTarget (const char *filename)
|
|
{
|
|
SBTarget target;
|
|
if (m_opaque_sp)
|
|
{
|
|
FileSpec file (filename);
|
|
ArchSpec arch = lldb_private::GetDefaultArchitecture();
|
|
TargetSP target_sp;
|
|
Error error;
|
|
|
|
if (!arch.IsValid())
|
|
arch = LLDB_ARCH_DEFAULT;
|
|
|
|
error = m_opaque_sp->GetTargetList().CreateTarget (*m_opaque_sp, file, arch, NULL, true, target_sp);
|
|
|
|
if (error.Fail())
|
|
{
|
|
if (arch == LLDB_ARCH_DEFAULT_32BIT)
|
|
arch = LLDB_ARCH_DEFAULT_64BIT;
|
|
else
|
|
arch = LLDB_ARCH_DEFAULT_32BIT;
|
|
|
|
error = m_opaque_sp->GetTargetList().CreateTarget (*m_opaque_sp, file, arch, NULL, true, target_sp);
|
|
}
|
|
|
|
if (error.Success())
|
|
{
|
|
m_opaque_sp->GetTargetList().SetCurrentTarget (target_sp.get());
|
|
target.reset (target_sp);
|
|
}
|
|
}
|
|
return target;
|
|
}
|
|
|
|
SBTarget
|
|
SBDebugger::GetTargetAtIndex (uint32_t idx)
|
|
{
|
|
SBTarget sb_target;
|
|
if (m_opaque_sp)
|
|
sb_target.reset(m_opaque_sp->GetTargetList().GetTargetAtIndex (idx));
|
|
return sb_target;
|
|
}
|
|
|
|
SBTarget
|
|
SBDebugger::FindTargetWithProcessID (pid_t pid)
|
|
{
|
|
SBTarget sb_target;
|
|
if (m_opaque_sp)
|
|
sb_target.reset(m_opaque_sp->GetTargetList().FindTargetWithProcessID (pid));
|
|
return sb_target;
|
|
}
|
|
|
|
SBTarget
|
|
SBDebugger::FindTargetWithFileAndArch (const char *filename, const char *arch_name)
|
|
{
|
|
SBTarget sb_target;
|
|
if (m_opaque_sp && filename && filename[0])
|
|
{
|
|
ArchSpec arch;
|
|
if (arch_name)
|
|
arch.SetArch(arch_name);
|
|
TargetSP target_sp (m_opaque_sp->GetTargetList().FindTargetWithExecutableAndArchitecture (FileSpec(filename), arch_name ? &arch : NULL));
|
|
sb_target.reset(target_sp);
|
|
}
|
|
return sb_target;
|
|
}
|
|
|
|
SBTarget
|
|
SBDebugger::FindTargetWithLLDBProcess (const lldb::ProcessSP &process_sp)
|
|
{
|
|
SBTarget sb_target;
|
|
if (m_opaque_sp)
|
|
sb_target.reset(m_opaque_sp->GetTargetList().FindTargetWithProcess (process_sp.get()));
|
|
return sb_target;
|
|
}
|
|
|
|
|
|
uint32_t
|
|
SBDebugger::GetNumTargets ()
|
|
{
|
|
if (m_opaque_sp)
|
|
return m_opaque_sp->GetTargetList().GetNumTargets ();
|
|
return 0;
|
|
}
|
|
|
|
SBTarget
|
|
SBDebugger::GetCurrentTarget ()
|
|
{
|
|
SBTarget sb_target;
|
|
if (m_opaque_sp)
|
|
sb_target.reset(m_opaque_sp->GetTargetList().GetCurrentTarget ());
|
|
return sb_target;
|
|
}
|
|
|
|
void
|
|
SBDebugger::DispatchInput (void *baton, const void *data, size_t data_len)
|
|
{
|
|
if (m_opaque_sp)
|
|
m_opaque_sp->DispatchInput ((const char *) data, data_len);
|
|
}
|
|
|
|
void
|
|
SBDebugger::PushInputReader (SBInputReader &reader)
|
|
{
|
|
if (m_opaque_sp && reader.IsValid())
|
|
{
|
|
InputReaderSP reader_sp(*reader);
|
|
m_opaque_sp->PushInputReader (reader_sp);
|
|
}
|
|
}
|
|
|
|
void
|
|
SBDebugger::reset (const lldb::DebuggerSP &debugger_sp)
|
|
{
|
|
m_opaque_sp = debugger_sp;
|
|
}
|
|
|
|
Debugger *
|
|
SBDebugger::get () const
|
|
{
|
|
return m_opaque_sp.get();
|
|
}
|
|
|
|
Debugger &
|
|
SBDebugger::ref () const
|
|
{
|
|
assert (m_opaque_sp.get());
|
|
return *m_opaque_sp;
|
|
}
|
|
|
|
|
|
SBDebugger
|
|
SBDebugger::FindDebuggerWithID (int id)
|
|
{
|
|
SBDebugger sb_debugger;
|
|
lldb::DebuggerSP debugger_sp = Debugger::FindDebuggerWithID (id);
|
|
if (debugger_sp)
|
|
sb_debugger.reset (debugger_sp);
|
|
return sb_debugger;
|
|
}
|