2010-06-09 00:52:24 +08:00
|
|
|
//===-- SBDebugger.cpp ------------------------------------------*- C++ -*-===//
|
|
|
|
//
|
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2018-05-26 04:28:16 +08:00
|
|
|
|
|
|
|
#include "SystemInitializerFull.h"
|
|
|
|
|
2010-06-09 15:37:52 +08:00
|
|
|
#include "lldb/API/SBDebugger.h"
|
2010-06-09 00:52:24 +08:00
|
|
|
|
2011-03-25 05:19:54 +08:00
|
|
|
#include "lldb/lldb-private.h"
|
2010-06-09 00:52:24 +08:00
|
|
|
|
2010-06-09 15:37:52 +08:00
|
|
|
#include "lldb/API/SBBroadcaster.h"
|
|
|
|
#include "lldb/API/SBCommandInterpreter.h"
|
|
|
|
#include "lldb/API/SBCommandReturnObject.h"
|
2011-04-30 09:09:13 +08:00
|
|
|
#include "lldb/API/SBError.h"
|
2010-06-09 15:37:52 +08:00
|
|
|
#include "lldb/API/SBEvent.h"
|
|
|
|
#include "lldb/API/SBFrame.h"
|
2016-09-07 04:57:50 +08:00
|
|
|
#include "lldb/API/SBListener.h"
|
2010-06-09 15:37:52 +08:00
|
|
|
#include "lldb/API/SBProcess.h"
|
|
|
|
#include "lldb/API/SBSourceManager.h"
|
2010-09-20 13:20:02 +08:00
|
|
|
#include "lldb/API/SBStream.h"
|
2010-09-04 08:03:46 +08:00
|
|
|
#include "lldb/API/SBStringList.h"
|
2017-08-09 17:20:40 +08:00
|
|
|
#include "lldb/API/SBStructuredData.h"
|
2010-09-04 08:03:46 +08:00
|
|
|
#include "lldb/API/SBTarget.h"
|
|
|
|
#include "lldb/API/SBThread.h"
|
2012-02-15 10:34:21 +08:00
|
|
|
#include "lldb/API/SBTypeCategory.h"
|
|
|
|
#include "lldb/API/SBTypeFilter.h"
|
2016-09-07 04:57:50 +08:00
|
|
|
#include "lldb/API/SBTypeFormat.h"
|
2012-02-15 10:34:21 +08:00
|
|
|
#include "lldb/API/SBTypeNameSpecifier.h"
|
|
|
|
#include "lldb/API/SBTypeSummary.h"
|
|
|
|
#include "lldb/API/SBTypeSynthetic.h"
|
|
|
|
|
2010-10-11 09:05:37 +08:00
|
|
|
#include "lldb/Core/Debugger.h"
|
2017-08-09 17:20:40 +08:00
|
|
|
#include "lldb/Core/PluginManager.h"
|
2014-01-28 07:43:24 +08:00
|
|
|
#include "lldb/Core/StreamFile.h"
|
2017-08-09 17:20:40 +08:00
|
|
|
#include "lldb/Core/StructuredDataImpl.h"
|
2013-01-29 07:47:25 +08:00
|
|
|
#include "lldb/DataFormatters/DataVisualization.h"
|
2018-02-19 23:06:28 +08:00
|
|
|
#include "lldb/Host/XML.h"
|
2015-04-01 05:03:22 +08:00
|
|
|
#include "lldb/Initialization/SystemLifetimeManager.h"
|
2010-10-11 09:05:37 +08:00
|
|
|
#include "lldb/Interpreter/CommandInterpreter.h"
|
2018-04-10 17:03:59 +08:00
|
|
|
#include "lldb/Interpreter/OptionArgParser.h"
|
2011-09-24 08:52:29 +08:00
|
|
|
#include "lldb/Interpreter/OptionGroupPlatform.h"
|
2010-10-11 09:05:37 +08:00
|
|
|
#include "lldb/Target/Process.h"
|
|
|
|
#include "lldb/Target/TargetList.h"
|
2018-04-18 02:53:35 +08:00
|
|
|
#include "lldb/Utility/Args.h"
|
2018-08-07 19:07:21 +08:00
|
|
|
#include "lldb/Utility/State.h"
|
2010-06-09 00:52:24 +08:00
|
|
|
|
2015-10-20 12:50:09 +08:00
|
|
|
#include "llvm/ADT/STLExtras.h"
|
2016-09-17 03:09:12 +08:00
|
|
|
#include "llvm/ADT/StringRef.h"
|
2014-08-28 04:15:09 +08:00
|
|
|
#include "llvm/Support/DynamicLibrary.h"
|
2016-09-07 04:57:50 +08:00
|
|
|
#include "llvm/Support/ManagedStatic.h"
|
2014-08-28 04:15:09 +08:00
|
|
|
|
2010-06-09 00:52:24 +08:00
|
|
|
using namespace lldb;
|
|
|
|
using namespace lldb_private;
|
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
static llvm::sys::DynamicLibrary LoadPlugin(const lldb::DebuggerSP &debugger_sp,
|
|
|
|
const FileSpec &spec,
|
2017-05-12 12:51:55 +08:00
|
|
|
Status &error) {
|
2016-09-07 04:57:50 +08:00
|
|
|
llvm::sys::DynamicLibrary dynlib =
|
|
|
|
llvm::sys::DynamicLibrary::getPermanentLibrary(spec.GetPath().c_str());
|
|
|
|
if (dynlib.isValid()) {
|
|
|
|
typedef bool (*LLDBCommandPluginInit)(lldb::SBDebugger & debugger);
|
|
|
|
|
|
|
|
lldb::SBDebugger debugger_sb(debugger_sp);
|
|
|
|
// This calls the bool lldb::PluginInitialize(lldb::SBDebugger debugger)
|
|
|
|
// function.
|
|
|
|
// TODO: mangle this differently for your system - on OSX, the first
|
|
|
|
// underscore needs to be removed and the second one stays
|
|
|
|
LLDBCommandPluginInit init_func =
|
2017-10-25 07:46:00 +08:00
|
|
|
(LLDBCommandPluginInit)(uintptr_t)dynlib.getAddressOfSymbol(
|
2016-09-07 04:57:50 +08:00
|
|
|
"_ZN4lldb16PluginInitializeENS_10SBDebuggerE");
|
|
|
|
if (init_func) {
|
|
|
|
if (init_func(debugger_sb))
|
|
|
|
return dynlib;
|
|
|
|
else
|
|
|
|
error.SetErrorString("plug-in refused to load "
|
|
|
|
"(lldb::PluginInitialize(lldb::SBDebugger) "
|
|
|
|
"returned false)");
|
|
|
|
} else {
|
|
|
|
error.SetErrorString("plug-in is missing the required initialization: "
|
|
|
|
"lldb::PluginInitialize(lldb::SBDebugger)");
|
2013-12-03 03:35:49 +08:00
|
|
|
}
|
2016-09-07 04:57:50 +08:00
|
|
|
} else {
|
2018-11-02 01:09:25 +08:00
|
|
|
if (FileSystem::Instance().Exists(spec))
|
2016-09-07 04:57:50 +08:00
|
|
|
error.SetErrorString("this file does not represent a loadable dylib");
|
2013-12-03 03:35:49 +08:00
|
|
|
else
|
2016-09-07 04:57:50 +08:00
|
|
|
error.SetErrorString("no such file");
|
|
|
|
}
|
|
|
|
return llvm::sys::DynamicLibrary();
|
2013-12-03 03:35:49 +08:00
|
|
|
}
|
|
|
|
|
2015-04-01 05:03:22 +08:00
|
|
|
static llvm::ManagedStatic<SystemLifetimeManager> g_debugger_lifetime;
|
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
SBError SBInputReader::Initialize(
|
|
|
|
lldb::SBDebugger &sb_debugger,
|
|
|
|
unsigned long (*)(void *, lldb::SBInputReader *, lldb::InputReaderAction,
|
|
|
|
char const *, unsigned long),
|
|
|
|
void *, lldb::InputReaderGranularity, char const *, char const *, bool) {
|
|
|
|
return SBError();
|
2015-04-01 05:03:22 +08:00
|
|
|
}
|
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
void SBInputReader::SetIsDone(bool) {}
|
2015-10-31 09:22:59 +08:00
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
bool SBInputReader::IsActive() const { return false; }
|
2015-04-01 05:03:22 +08:00
|
|
|
|
2015-10-31 09:22:59 +08:00
|
|
|
SBDebugger::SBDebugger() = default;
|
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
SBDebugger::SBDebugger(const lldb::DebuggerSP &debugger_sp)
|
|
|
|
: m_opaque_sp(debugger_sp) {}
|
2015-10-31 09:22:59 +08:00
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
SBDebugger::SBDebugger(const SBDebugger &rhs) : m_opaque_sp(rhs.m_opaque_sp) {}
|
2015-10-31 09:22:59 +08:00
|
|
|
|
|
|
|
SBDebugger::~SBDebugger() = default;
|
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
SBDebugger &SBDebugger::operator=(const SBDebugger &rhs) {
|
|
|
|
if (this != &rhs) {
|
|
|
|
m_opaque_sp = rhs.m_opaque_sp;
|
|
|
|
}
|
|
|
|
return *this;
|
2015-10-31 09:22:59 +08:00
|
|
|
}
|
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
void SBDebugger::Initialize() {
|
|
|
|
Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
|
2010-10-26 11:11:13 +08:00
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
if (log)
|
|
|
|
log->Printf("SBDebugger::Initialize ()");
|
2010-10-26 11:11:13 +08:00
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
g_debugger_lifetime->Initialize(llvm::make_unique<SystemInitializerFull>(),
|
|
|
|
LoadPlugin);
|
2010-06-09 00:52:24 +08:00
|
|
|
}
|
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
void SBDebugger::Terminate() { g_debugger_lifetime->Terminate(); }
|
2010-06-09 00:52:24 +08:00
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
void SBDebugger::Clear() {
|
|
|
|
Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
|
2010-10-26 11:11:13 +08:00
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
if (log)
|
|
|
|
log->Printf("SBDebugger(%p)::Clear ()",
|
|
|
|
static_cast<void *>(m_opaque_sp.get()));
|
2014-04-04 12:06:10 +08:00
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
if (m_opaque_sp)
|
|
|
|
m_opaque_sp->ClearIOHandlers();
|
2010-10-26 11:11:13 +08:00
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
m_opaque_sp.reset();
|
2010-07-31 04:12:55 +08:00
|
|
|
}
|
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
SBDebugger SBDebugger::Create() {
|
|
|
|
return SBDebugger::Create(false, nullptr, nullptr);
|
2011-08-13 08:22:20 +08:00
|
|
|
}
|
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
SBDebugger SBDebugger::Create(bool source_init_files) {
|
|
|
|
return SBDebugger::Create(source_init_files, nullptr, nullptr);
|
2012-02-21 10:23:08 +08:00
|
|
|
}
|
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
SBDebugger SBDebugger::Create(bool source_init_files,
|
|
|
|
lldb::LogOutputCallback callback, void *baton)
|
2012-02-21 10:23:08 +08:00
|
|
|
|
2010-06-09 00:52:24 +08:00
|
|
|
{
|
2016-09-07 04:57:50 +08:00
|
|
|
Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
|
2010-10-26 11:11:13 +08:00
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
SBDebugger debugger;
|
2010-06-09 00:52:24 +08:00
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
// Currently we have issues if this function is called simultaneously on two
|
2018-05-01 00:49:04 +08:00
|
|
|
// different threads. The issues mainly revolve around the fact that the
|
|
|
|
// lldb_private::FormatManager uses global collections and having two threads
|
|
|
|
// parsing the .lldbinit files can cause mayhem. So to get around this for
|
|
|
|
// now we need to use a mutex to prevent bad things from happening.
|
2016-09-07 04:57:50 +08:00
|
|
|
static std::recursive_mutex g_mutex;
|
|
|
|
std::lock_guard<std::recursive_mutex> guard(g_mutex);
|
2014-04-04 12:06:10 +08:00
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
debugger.reset(Debugger::CreateInstance(callback, baton));
|
2014-04-04 12:06:10 +08:00
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
if (log) {
|
|
|
|
SBStream sstr;
|
|
|
|
debugger.GetDescription(sstr);
|
|
|
|
log->Printf("SBDebugger::Create () => SBDebugger(%p): %s",
|
|
|
|
static_cast<void *>(debugger.m_opaque_sp.get()),
|
|
|
|
sstr.GetData());
|
|
|
|
}
|
|
|
|
|
|
|
|
SBCommandInterpreter interp = debugger.GetCommandInterpreter();
|
|
|
|
if (source_init_files) {
|
|
|
|
interp.get()->SkipLLDBInitFiles(false);
|
|
|
|
interp.get()->SkipAppInitFiles(false);
|
|
|
|
SBCommandReturnObject result;
|
|
|
|
interp.SourceInitFileInHomeDirectory(result);
|
|
|
|
} else {
|
|
|
|
interp.get()->SkipLLDBInitFiles(true);
|
|
|
|
interp.get()->SkipAppInitFiles(true);
|
|
|
|
}
|
|
|
|
return debugger;
|
2011-01-22 09:02:07 +08:00
|
|
|
}
|
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
void SBDebugger::Destroy(SBDebugger &debugger) {
|
|
|
|
Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
|
|
|
|
|
|
|
|
if (log) {
|
|
|
|
SBStream sstr;
|
|
|
|
debugger.GetDescription(sstr);
|
|
|
|
log->Printf("SBDebugger::Destroy () => SBDebugger(%p): %s",
|
|
|
|
static_cast<void *>(debugger.m_opaque_sp.get()),
|
|
|
|
sstr.GetData());
|
|
|
|
}
|
|
|
|
|
|
|
|
Debugger::Destroy(debugger.m_opaque_sp);
|
|
|
|
|
|
|
|
if (debugger.m_opaque_sp.get() != nullptr)
|
|
|
|
debugger.m_opaque_sp.reset();
|
2011-12-15 12:38:41 +08:00
|
|
|
}
|
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
void SBDebugger::MemoryPressureDetected() {
|
2018-05-01 00:49:04 +08:00
|
|
|
// Since this function can be call asynchronously, we allow it to be non-
|
|
|
|
// mandatory. We have seen deadlocks with this function when called so we
|
|
|
|
// need to safeguard against this until we can determine what is causing the
|
|
|
|
// deadlocks.
|
2016-09-07 04:57:50 +08:00
|
|
|
Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
|
|
|
|
|
|
|
|
const bool mandatory = false;
|
|
|
|
if (log) {
|
|
|
|
log->Printf("SBDebugger::MemoryPressureDetected (), mandatory = %d",
|
|
|
|
mandatory);
|
|
|
|
}
|
|
|
|
|
|
|
|
ModuleList::RemoveOrphanSharedModules(mandatory);
|
2010-06-09 00:52:24 +08:00
|
|
|
}
|
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
bool SBDebugger::IsValid() const { return m_opaque_sp.get() != nullptr; }
|
|
|
|
|
|
|
|
void SBDebugger::SetAsync(bool b) {
|
|
|
|
if (m_opaque_sp)
|
|
|
|
m_opaque_sp->SetAsyncExecution(b);
|
2010-06-09 00:52:24 +08:00
|
|
|
}
|
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
bool SBDebugger::GetAsync() {
|
|
|
|
return (m_opaque_sp ? m_opaque_sp->GetAsyncExecution() : false);
|
2011-09-14 07:25:31 +08:00
|
|
|
}
|
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
void SBDebugger::SkipLLDBInitFiles(bool b) {
|
|
|
|
if (m_opaque_sp)
|
|
|
|
m_opaque_sp->GetCommandInterpreter().SkipLLDBInitFiles(b);
|
2010-10-11 09:05:37 +08:00
|
|
|
}
|
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
void SBDebugger::SkipAppInitFiles(bool b) {
|
|
|
|
if (m_opaque_sp)
|
|
|
|
m_opaque_sp->GetCommandInterpreter().SkipAppInitFiles(b);
|
2011-08-13 07:34:31 +08:00
|
|
|
}
|
|
|
|
|
2018-05-01 00:49:04 +08:00
|
|
|
// 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.
|
2016-09-07 04:57:50 +08:00
|
|
|
void SBDebugger::SetInputFileHandle(FILE *fh, bool transfer_ownership) {
|
|
|
|
Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
|
2010-10-26 11:11:13 +08:00
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
if (log)
|
|
|
|
log->Printf(
|
|
|
|
"SBDebugger(%p)::SetInputFileHandle (fh=%p, transfer_ownership=%i)",
|
|
|
|
static_cast<void *>(m_opaque_sp.get()), static_cast<void *>(fh),
|
|
|
|
transfer_ownership);
|
2010-10-26 11:11:13 +08:00
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
if (m_opaque_sp)
|
|
|
|
m_opaque_sp->SetInputFileHandle(fh, transfer_ownership);
|
2010-06-09 00:52:24 +08:00
|
|
|
}
|
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
void SBDebugger::SetOutputFileHandle(FILE *fh, bool transfer_ownership) {
|
|
|
|
Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
|
2010-10-26 11:11:13 +08:00
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
if (log)
|
|
|
|
log->Printf(
|
|
|
|
"SBDebugger(%p)::SetOutputFileHandle (fh=%p, transfer_ownership=%i)",
|
|
|
|
static_cast<void *>(m_opaque_sp.get()), static_cast<void *>(fh),
|
|
|
|
transfer_ownership);
|
2010-10-26 11:11:13 +08:00
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
if (m_opaque_sp)
|
|
|
|
m_opaque_sp->SetOutputFileHandle(fh, transfer_ownership);
|
2010-06-09 00:52:24 +08:00
|
|
|
}
|
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
void SBDebugger::SetErrorFileHandle(FILE *fh, bool transfer_ownership) {
|
|
|
|
Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
|
2010-10-26 11:11:13 +08:00
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
if (log)
|
|
|
|
log->Printf(
|
|
|
|
"SBDebugger(%p)::SetErrorFileHandle (fh=%p, transfer_ownership=%i)",
|
|
|
|
static_cast<void *>(m_opaque_sp.get()), static_cast<void *>(fh),
|
|
|
|
transfer_ownership);
|
2010-10-26 11:11:13 +08:00
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
if (m_opaque_sp)
|
|
|
|
m_opaque_sp->SetErrorFileHandle(fh, transfer_ownership);
|
2010-06-09 00:52:24 +08:00
|
|
|
}
|
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
FILE *SBDebugger::GetInputFileHandle() {
|
|
|
|
if (m_opaque_sp) {
|
|
|
|
StreamFileSP stream_file_sp(m_opaque_sp->GetInputFile());
|
|
|
|
if (stream_file_sp)
|
|
|
|
return stream_file_sp->GetFile().GetStream();
|
|
|
|
}
|
|
|
|
return nullptr;
|
2010-06-09 00:52:24 +08:00
|
|
|
}
|
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
FILE *SBDebugger::GetOutputFileHandle() {
|
|
|
|
if (m_opaque_sp) {
|
|
|
|
StreamFileSP stream_file_sp(m_opaque_sp->GetOutputFile());
|
|
|
|
if (stream_file_sp)
|
|
|
|
return stream_file_sp->GetFile().GetStream();
|
|
|
|
}
|
|
|
|
return nullptr;
|
2010-06-09 00:52:24 +08:00
|
|
|
}
|
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
FILE *SBDebugger::GetErrorFileHandle() {
|
|
|
|
if (m_opaque_sp) {
|
|
|
|
StreamFileSP stream_file_sp(m_opaque_sp->GetErrorFile());
|
|
|
|
if (stream_file_sp)
|
|
|
|
return stream_file_sp->GetFile().GetStream();
|
|
|
|
}
|
|
|
|
return nullptr;
|
2010-06-09 00:52:24 +08:00
|
|
|
}
|
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
void SBDebugger::SaveInputTerminalState() {
|
|
|
|
if (m_opaque_sp)
|
|
|
|
m_opaque_sp->SaveInputTerminalState();
|
2012-12-01 04:23:19 +08:00
|
|
|
}
|
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
void SBDebugger::RestoreInputTerminalState() {
|
|
|
|
if (m_opaque_sp)
|
|
|
|
m_opaque_sp->RestoreInputTerminalState();
|
2012-12-01 04:23:19 +08:00
|
|
|
}
|
2016-09-07 04:57:50 +08:00
|
|
|
SBCommandInterpreter SBDebugger::GetCommandInterpreter() {
|
|
|
|
Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
|
2010-10-26 11:11:13 +08:00
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
SBCommandInterpreter sb_interpreter;
|
|
|
|
if (m_opaque_sp)
|
|
|
|
sb_interpreter.reset(&m_opaque_sp->GetCommandInterpreter());
|
2010-10-26 11:11:13 +08:00
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
if (log)
|
|
|
|
log->Printf(
|
|
|
|
"SBDebugger(%p)::GetCommandInterpreter () => SBCommandInterpreter(%p)",
|
|
|
|
static_cast<void *>(m_opaque_sp.get()),
|
|
|
|
static_cast<void *>(sb_interpreter.get()));
|
2010-10-27 07:49:36 +08:00
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
return sb_interpreter;
|
2010-06-09 00:52:24 +08:00
|
|
|
}
|
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
void SBDebugger::HandleCommand(const char *command) {
|
|
|
|
if (m_opaque_sp) {
|
|
|
|
TargetSP target_sp(m_opaque_sp->GetSelectedTarget());
|
|
|
|
std::unique_lock<std::recursive_mutex> lock;
|
|
|
|
if (target_sp)
|
|
|
|
lock = std::unique_lock<std::recursive_mutex>(target_sp->GetAPIMutex());
|
2010-06-09 00:52:24 +08:00
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
SBCommandInterpreter sb_interpreter(GetCommandInterpreter());
|
|
|
|
SBCommandReturnObject result;
|
2010-10-26 11:11:13 +08:00
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
sb_interpreter.HandleCommand(command, result, false);
|
2010-10-26 11:11:13 +08:00
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
if (GetErrorFileHandle() != nullptr)
|
|
|
|
result.PutError(GetErrorFileHandle());
|
|
|
|
if (GetOutputFileHandle() != nullptr)
|
|
|
|
result.PutOutput(GetOutputFileHandle());
|
2010-10-27 07:49:36 +08:00
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
if (!m_opaque_sp->GetAsyncExecution()) {
|
|
|
|
SBProcess process(GetCommandInterpreter().GetProcess());
|
|
|
|
ProcessSP process_sp(process.GetSP());
|
|
|
|
if (process_sp) {
|
|
|
|
EventSP event_sp;
|
|
|
|
ListenerSP lldb_listener_sp = m_opaque_sp->GetListener();
|
2016-11-30 18:41:42 +08:00
|
|
|
while (lldb_listener_sp->GetEventForBroadcaster(
|
|
|
|
process_sp.get(), event_sp, std::chrono::seconds(0))) {
|
2016-09-07 04:57:50 +08:00
|
|
|
SBEvent event(event_sp);
|
|
|
|
HandleProcessEvent(process, event, GetOutputFileHandle(),
|
|
|
|
GetErrorFileHandle());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2010-06-09 00:52:24 +08:00
|
|
|
}
|
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
SBListener SBDebugger::GetListener() {
|
|
|
|
Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
|
2012-01-30 15:41:31 +08:00
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
SBListener sb_listener;
|
|
|
|
if (m_opaque_sp)
|
|
|
|
sb_listener.reset(m_opaque_sp->GetListener());
|
2010-06-09 00:52:24 +08:00
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
if (log)
|
|
|
|
log->Printf("SBDebugger(%p)::GetListener () => SBListener(%p)",
|
|
|
|
static_cast<void *>(m_opaque_sp.get()),
|
|
|
|
static_cast<void *>(sb_listener.get()));
|
2016-05-19 13:13:57 +08:00
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
return sb_listener;
|
2010-06-09 00:52:24 +08:00
|
|
|
}
|
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
void SBDebugger::HandleProcessEvent(const SBProcess &process,
|
|
|
|
const SBEvent &event, FILE *out,
|
|
|
|
FILE *err) {
|
|
|
|
if (!process.IsValid())
|
|
|
|
return;
|
2010-06-09 00:52:24 +08:00
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
TargetSP target_sp(process.GetTarget().GetSP());
|
|
|
|
if (!target_sp)
|
|
|
|
return;
|
2010-06-09 00:52:24 +08:00
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
const uint32_t event_type = event.GetType();
|
|
|
|
char stdio_buffer[1024];
|
|
|
|
size_t len;
|
2010-06-09 00:52:24 +08:00
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
|
2010-06-09 00:52:24 +08:00
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
if (event_type &
|
|
|
|
(Process::eBroadcastBitSTDOUT | Process::eBroadcastBitStateChanged)) {
|
|
|
|
// Drain stdout when we stop just in case we have any bytes
|
|
|
|
while ((len = process.GetSTDOUT(stdio_buffer, sizeof(stdio_buffer))) > 0)
|
|
|
|
if (out != nullptr)
|
|
|
|
::fwrite(stdio_buffer, 1, len, out);
|
|
|
|
}
|
2010-06-09 00:52:24 +08:00
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
if (event_type &
|
|
|
|
(Process::eBroadcastBitSTDERR | Process::eBroadcastBitStateChanged)) {
|
|
|
|
// Drain stderr when we stop just in case we have any bytes
|
|
|
|
while ((len = process.GetSTDERR(stdio_buffer, sizeof(stdio_buffer))) > 0)
|
|
|
|
if (err != nullptr)
|
|
|
|
::fwrite(stdio_buffer, 1, len, err);
|
|
|
|
}
|
2010-06-09 00:52:24 +08:00
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
if (event_type & Process::eBroadcastBitStateChanged) {
|
|
|
|
StateType event_state = SBProcess::GetStateFromEvent(event);
|
2010-10-30 12:51:46 +08:00
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
if (event_state == eStateInvalid)
|
|
|
|
return;
|
2010-10-30 12:51:46 +08:00
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
bool is_stopped = StateIsStoppedState(event_state);
|
|
|
|
if (!is_stopped)
|
|
|
|
process.ReportEventState(event, out);
|
|
|
|
}
|
2010-06-09 00:52:24 +08:00
|
|
|
}
|
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
SBSourceManager SBDebugger::GetSourceManager() {
|
|
|
|
SBSourceManager sb_source_manager(*this);
|
|
|
|
return sb_source_manager;
|
2010-06-09 00:52:24 +08:00
|
|
|
}
|
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
bool SBDebugger::GetDefaultArchitecture(char *arch_name, size_t arch_name_len) {
|
|
|
|
if (arch_name && arch_name_len) {
|
|
|
|
ArchSpec default_arch = Target::GetDefaultArchitecture();
|
|
|
|
|
|
|
|
if (default_arch.IsValid()) {
|
|
|
|
const std::string &triple_str = default_arch.GetTriple().str();
|
|
|
|
if (!triple_str.empty())
|
|
|
|
::snprintf(arch_name, arch_name_len, "%s", triple_str.c_str());
|
|
|
|
else
|
|
|
|
::snprintf(arch_name, arch_name_len, "%s",
|
|
|
|
default_arch.GetArchitectureName());
|
|
|
|
return true;
|
2011-09-24 08:52:29 +08:00
|
|
|
}
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
|
|
|
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()) {
|
|
|
|
Target::SetDefaultArchitecture(arch);
|
|
|
|
return true;
|
2011-09-24 08:52:29 +08:00
|
|
|
}
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
|
|
|
return false;
|
2011-09-24 08:52:29 +08:00
|
|
|
}
|
2010-06-09 00:52:24 +08:00
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
ScriptLanguage
|
|
|
|
SBDebugger::GetScriptingLanguage(const char *script_language_name) {
|
2016-09-17 03:09:12 +08:00
|
|
|
if (!script_language_name) return eScriptLanguageDefault;
|
2018-04-10 17:03:59 +08:00
|
|
|
return OptionArgParser::ToScriptLanguage(
|
|
|
|
llvm::StringRef(script_language_name), eScriptLanguageDefault, nullptr);
|
2010-06-09 00:52:24 +08:00
|
|
|
}
|
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
const char *SBDebugger::GetVersionString() {
|
|
|
|
return lldb_private::GetVersion();
|
2010-06-23 09:19:29 +08:00
|
|
|
}
|
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
const char *SBDebugger::StateAsCString(StateType state) {
|
|
|
|
return lldb_private::StateAsCString(state);
|
2010-06-09 00:52:24 +08:00
|
|
|
}
|
|
|
|
|
2018-02-19 23:06:28 +08:00
|
|
|
static void AddBoolConfigEntry(StructuredData::Dictionary &dict,
|
|
|
|
llvm::StringRef name, bool value,
|
|
|
|
llvm::StringRef description) {
|
|
|
|
auto entry_up = llvm::make_unique<StructuredData::Dictionary>();
|
|
|
|
entry_up->AddBooleanItem("value", value);
|
|
|
|
entry_up->AddStringItem("description", description);
|
|
|
|
dict.AddItem(name, std::move(entry_up));
|
|
|
|
}
|
|
|
|
|
2018-06-28 22:23:04 +08:00
|
|
|
static void AddLLVMTargets(StructuredData::Dictionary &dict) {
|
|
|
|
auto array_up = llvm::make_unique<StructuredData::Array>();
|
|
|
|
#define LLVM_TARGET(target) \
|
|
|
|
array_up->AddItem(llvm::make_unique<StructuredData::String>(#target));
|
|
|
|
#include "llvm/Config/Targets.def"
|
|
|
|
auto entry_up = llvm::make_unique<StructuredData::Dictionary>();
|
|
|
|
entry_up->AddItem("value", std::move(array_up));
|
|
|
|
entry_up->AddStringItem("description", "A list of configured LLVM targets.");
|
|
|
|
dict.AddItem("targets", std::move(entry_up));
|
|
|
|
}
|
|
|
|
|
2018-02-19 23:06:28 +08:00
|
|
|
SBStructuredData SBDebugger::GetBuildConfiguration() {
|
|
|
|
auto config_up = llvm::make_unique<StructuredData::Dictionary>();
|
|
|
|
AddBoolConfigEntry(
|
|
|
|
*config_up, "xml", XMLDocument::XMLEnabled(),
|
|
|
|
"A boolean value that indicates if XML support is enabled in LLDB");
|
2018-06-28 22:23:04 +08:00
|
|
|
AddLLVMTargets(*config_up);
|
2018-02-19 23:06:28 +08:00
|
|
|
|
|
|
|
SBStructuredData data;
|
|
|
|
data.m_impl_up->SetObjectSP(std::move(config_up));
|
|
|
|
return data;
|
|
|
|
}
|
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
bool SBDebugger::StateIsRunningState(StateType state) {
|
|
|
|
Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
|
2011-06-16 05:24:24 +08:00
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
const bool result = lldb_private::StateIsRunningState(state);
|
|
|
|
if (log)
|
|
|
|
log->Printf("SBDebugger::StateIsRunningState (state=%s) => %i",
|
|
|
|
StateAsCString(state), result);
|
2011-06-16 05:24:24 +08:00
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
return result;
|
2011-06-16 05:24:24 +08:00
|
|
|
}
|
2015-10-31 09:22:59 +08:00
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
bool SBDebugger::StateIsStoppedState(StateType state) {
|
|
|
|
Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
|
2010-06-09 00:52:24 +08:00
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
const bool result = lldb_private::StateIsStoppedState(state, false);
|
|
|
|
if (log)
|
|
|
|
log->Printf("SBDebugger::StateIsStoppedState (state=%s) => %i",
|
|
|
|
StateAsCString(state), result);
|
2012-05-09 07:06:07 +08:00
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
return result;
|
|
|
|
}
|
2012-05-09 07:06:07 +08:00
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
lldb::SBTarget SBDebugger::CreateTarget(const char *filename,
|
|
|
|
const char *target_triple,
|
|
|
|
const char *platform_name,
|
|
|
|
bool add_dependent_modules,
|
|
|
|
lldb::SBError &sb_error) {
|
|
|
|
SBTarget sb_target;
|
|
|
|
TargetSP target_sp;
|
|
|
|
if (m_opaque_sp) {
|
|
|
|
sb_error.Clear();
|
|
|
|
OptionGroupPlatform platform_options(false);
|
|
|
|
platform_options.SetPlatformName(platform_name);
|
2012-05-09 07:06:07 +08:00
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
sb_error.ref() = m_opaque_sp->GetTargetList().CreateTarget(
|
2018-09-20 17:09:05 +08:00
|
|
|
*m_opaque_sp, filename, target_triple,
|
|
|
|
add_dependent_modules ? eLoadDependentsYes : eLoadDependentsNo,
|
2016-09-07 04:57:50 +08:00
|
|
|
&platform_options, target_sp);
|
2012-05-09 07:06:07 +08:00
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
if (sb_error.Success())
|
|
|
|
sb_target.SetSP(target_sp);
|
|
|
|
} else {
|
|
|
|
sb_error.SetErrorString("invalid debugger");
|
|
|
|
}
|
2010-06-09 00:52:24 +08:00
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
|
|
|
|
if (log)
|
|
|
|
log->Printf("SBDebugger(%p)::CreateTarget (filename=\"%s\", triple=%s, "
|
|
|
|
"platform_name=%s, add_dependent_modules=%u, error=%s) => "
|
|
|
|
"SBTarget(%p)",
|
|
|
|
static_cast<void *>(m_opaque_sp.get()), filename, target_triple,
|
|
|
|
platform_name, add_dependent_modules, sb_error.GetCString(),
|
|
|
|
static_cast<void *>(target_sp.get()));
|
|
|
|
|
|
|
|
return sb_target;
|
2010-06-09 00:52:24 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
SBTarget
|
2016-09-07 04:57:50 +08:00
|
|
|
SBDebugger::CreateTargetWithFileAndTargetTriple(const char *filename,
|
|
|
|
const char *target_triple) {
|
|
|
|
SBTarget sb_target;
|
|
|
|
TargetSP target_sp;
|
|
|
|
if (m_opaque_sp) {
|
|
|
|
const bool add_dependent_modules = true;
|
2017-05-12 12:51:55 +08:00
|
|
|
Status error(m_opaque_sp->GetTargetList().CreateTarget(
|
2018-09-20 17:09:05 +08:00
|
|
|
*m_opaque_sp, filename, target_triple,
|
|
|
|
add_dependent_modules ? eLoadDependentsYes : eLoadDependentsNo, nullptr,
|
2016-09-07 04:57:50 +08:00
|
|
|
target_sp));
|
|
|
|
sb_target.SetSP(target_sp);
|
|
|
|
}
|
|
|
|
|
|
|
|
Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
|
|
|
|
if (log)
|
|
|
|
log->Printf("SBDebugger(%p)::CreateTargetWithFileAndTargetTriple "
|
|
|
|
"(filename=\"%s\", triple=%s) => SBTarget(%p)",
|
|
|
|
static_cast<void *>(m_opaque_sp.get()), filename, target_triple,
|
|
|
|
static_cast<void *>(target_sp.get()));
|
|
|
|
|
|
|
|
return sb_target;
|
|
|
|
}
|
|
|
|
|
|
|
|
SBTarget SBDebugger::CreateTargetWithFileAndArch(const char *filename,
|
|
|
|
const char *arch_cstr) {
|
|
|
|
Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
|
|
|
|
|
|
|
|
SBTarget sb_target;
|
|
|
|
TargetSP target_sp;
|
|
|
|
if (m_opaque_sp) {
|
2017-05-12 12:51:55 +08:00
|
|
|
Status error;
|
2016-09-07 04:57:50 +08:00
|
|
|
const bool add_dependent_modules = true;
|
2010-06-09 00:52:24 +08:00
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
error = m_opaque_sp->GetTargetList().CreateTarget(
|
2018-09-20 17:09:05 +08:00
|
|
|
*m_opaque_sp, filename, arch_cstr,
|
|
|
|
add_dependent_modules ? eLoadDependentsYes : eLoadDependentsNo, nullptr,
|
2016-09-07 04:57:50 +08:00
|
|
|
target_sp);
|
2010-06-09 00:52:24 +08:00
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
if (error.Success()) {
|
|
|
|
m_opaque_sp->GetTargetList().SetSelectedTarget(target_sp.get());
|
|
|
|
sb_target.SetSP(target_sp);
|
2010-12-21 04:49:23 +08:00
|
|
|
}
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
2010-10-26 11:11:13 +08:00
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
if (log)
|
|
|
|
log->Printf("SBDebugger(%p)::CreateTargetWithFileAndArch (filename=\"%s\", "
|
|
|
|
"arch=%s) => SBTarget(%p)",
|
|
|
|
static_cast<void *>(m_opaque_sp.get()), filename, arch_cstr,
|
|
|
|
static_cast<void *>(target_sp.get()));
|
2010-10-26 11:11:13 +08:00
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
return sb_target;
|
2010-06-09 00:52:24 +08:00
|
|
|
}
|
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
SBTarget SBDebugger::CreateTarget(const char *filename) {
|
|
|
|
SBTarget sb_target;
|
|
|
|
TargetSP target_sp;
|
|
|
|
if (m_opaque_sp) {
|
2017-05-12 12:51:55 +08:00
|
|
|
Status error;
|
2016-09-07 04:57:50 +08:00
|
|
|
const bool add_dependent_modules = true;
|
|
|
|
error = m_opaque_sp->GetTargetList().CreateTarget(
|
2018-09-20 17:09:05 +08:00
|
|
|
*m_opaque_sp, filename, "",
|
|
|
|
add_dependent_modules ? eLoadDependentsYes : eLoadDependentsNo, nullptr,
|
|
|
|
target_sp);
|
2016-09-07 04:57:50 +08:00
|
|
|
|
|
|
|
if (error.Success()) {
|
|
|
|
m_opaque_sp->GetTargetList().SetSelectedTarget(target_sp.get());
|
|
|
|
sb_target.SetSP(target_sp);
|
2011-09-14 07:25:31 +08:00
|
|
|
}
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
|
|
|
Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
|
|
|
|
if (log)
|
|
|
|
log->Printf(
|
|
|
|
"SBDebugger(%p)::CreateTarget (filename=\"%s\") => SBTarget(%p)",
|
|
|
|
static_cast<void *>(m_opaque_sp.get()), filename,
|
|
|
|
static_cast<void *>(target_sp.get()));
|
|
|
|
return sb_target;
|
|
|
|
}
|
|
|
|
|
2017-09-15 04:22:49 +08:00
|
|
|
SBTarget SBDebugger::GetDummyTarget() {
|
|
|
|
SBTarget sb_target;
|
|
|
|
if (m_opaque_sp) {
|
|
|
|
sb_target.SetSP(m_opaque_sp->GetDummyTarget()->shared_from_this());
|
|
|
|
}
|
|
|
|
Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
|
|
|
|
if (log)
|
|
|
|
log->Printf(
|
|
|
|
"SBDebugger(%p)::GetDummyTarget() => SBTarget(%p)",
|
|
|
|
static_cast<void *>(m_opaque_sp.get()),
|
|
|
|
static_cast<void *>(sb_target.GetSP().get()));
|
|
|
|
return sb_target;
|
|
|
|
}
|
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
bool SBDebugger::DeleteTarget(lldb::SBTarget &target) {
|
|
|
|
bool result = false;
|
|
|
|
if (m_opaque_sp) {
|
|
|
|
TargetSP target_sp(target.GetSP());
|
|
|
|
if (target_sp) {
|
|
|
|
// No need to lock, the target list is thread safe
|
|
|
|
result = m_opaque_sp->GetTargetList().DeleteTarget(target_sp);
|
|
|
|
target_sp->Destroy();
|
|
|
|
target.Clear();
|
|
|
|
const bool mandatory = true;
|
|
|
|
ModuleList::RemoveOrphanSharedModules(mandatory);
|
2011-09-14 07:25:31 +08:00
|
|
|
}
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
2013-11-21 05:07:01 +08:00
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
|
|
|
|
if (log)
|
|
|
|
log->Printf("SBDebugger(%p)::DeleteTarget (SBTarget(%p)) => %i",
|
|
|
|
static_cast<void *>(m_opaque_sp.get()),
|
|
|
|
static_cast<void *>(target.m_opaque_sp.get()), result);
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
SBTarget SBDebugger::GetTargetAtIndex(uint32_t idx) {
|
|
|
|
SBTarget sb_target;
|
|
|
|
if (m_opaque_sp) {
|
|
|
|
// No need to lock, the target list is thread safe
|
|
|
|
sb_target.SetSP(m_opaque_sp->GetTargetList().GetTargetAtIndex(idx));
|
|
|
|
}
|
|
|
|
return sb_target;
|
|
|
|
}
|
|
|
|
|
|
|
|
uint32_t SBDebugger::GetIndexOfTarget(lldb::SBTarget target) {
|
|
|
|
|
|
|
|
lldb::TargetSP target_sp = target.GetSP();
|
|
|
|
if (!target_sp)
|
|
|
|
return UINT32_MAX;
|
|
|
|
|
|
|
|
if (!m_opaque_sp)
|
|
|
|
return UINT32_MAX;
|
|
|
|
|
|
|
|
return m_opaque_sp->GetTargetList().GetIndexOfTarget(target.GetSP());
|
|
|
|
}
|
|
|
|
|
|
|
|
SBTarget SBDebugger::FindTargetWithProcessID(lldb::pid_t pid) {
|
|
|
|
SBTarget sb_target;
|
|
|
|
if (m_opaque_sp) {
|
|
|
|
// No need to lock, the target list is thread safe
|
|
|
|
sb_target.SetSP(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]) {
|
|
|
|
// No need to lock, the target list is thread safe
|
2017-10-31 18:56:03 +08:00
|
|
|
ArchSpec arch = Platform::GetAugmentedArchSpec(
|
|
|
|
m_opaque_sp->GetPlatformList().GetSelectedPlatform().get(), arch_name);
|
2016-09-07 04:57:50 +08:00
|
|
|
TargetSP target_sp(
|
|
|
|
m_opaque_sp->GetTargetList().FindTargetWithExecutableAndArchitecture(
|
2018-11-02 05:05:36 +08:00
|
|
|
FileSpec(filename), arch_name ? &arch : nullptr));
|
2016-09-07 04:57:50 +08:00
|
|
|
sb_target.SetSP(target_sp);
|
|
|
|
}
|
|
|
|
return sb_target;
|
|
|
|
}
|
|
|
|
|
|
|
|
SBTarget SBDebugger::FindTargetWithLLDBProcess(const ProcessSP &process_sp) {
|
|
|
|
SBTarget sb_target;
|
|
|
|
if (m_opaque_sp) {
|
|
|
|
// No need to lock, the target list is thread safe
|
|
|
|
sb_target.SetSP(
|
|
|
|
m_opaque_sp->GetTargetList().FindTargetWithProcess(process_sp.get()));
|
|
|
|
}
|
|
|
|
return sb_target;
|
|
|
|
}
|
|
|
|
|
|
|
|
uint32_t SBDebugger::GetNumTargets() {
|
|
|
|
if (m_opaque_sp) {
|
|
|
|
// No need to lock, the target list is thread safe
|
|
|
|
return m_opaque_sp->GetTargetList().GetNumTargets();
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
2013-11-21 05:07:01 +08:00
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
SBTarget SBDebugger::GetSelectedTarget() {
|
|
|
|
Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
|
|
|
|
|
|
|
|
SBTarget sb_target;
|
|
|
|
TargetSP target_sp;
|
|
|
|
if (m_opaque_sp) {
|
|
|
|
// No need to lock, the target list is thread safe
|
|
|
|
target_sp = m_opaque_sp->GetTargetList().GetSelectedTarget();
|
|
|
|
sb_target.SetSP(target_sp);
|
|
|
|
}
|
2014-04-04 12:06:10 +08:00
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
if (log) {
|
|
|
|
SBStream sstr;
|
|
|
|
sb_target.GetDescription(sstr, eDescriptionLevelBrief);
|
|
|
|
log->Printf("SBDebugger(%p)::GetSelectedTarget () => SBTarget(%p): %s",
|
|
|
|
static_cast<void *>(m_opaque_sp.get()),
|
|
|
|
static_cast<void *>(target_sp.get()), sstr.GetData());
|
|
|
|
}
|
2014-04-04 12:06:10 +08:00
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
return sb_target;
|
2013-11-21 05:07:01 +08:00
|
|
|
}
|
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
void SBDebugger::SetSelectedTarget(SBTarget &sb_target) {
|
|
|
|
Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
|
|
|
|
|
|
|
|
TargetSP target_sp(sb_target.GetSP());
|
|
|
|
if (m_opaque_sp) {
|
|
|
|
m_opaque_sp->GetTargetList().SetSelectedTarget(target_sp.get());
|
|
|
|
}
|
|
|
|
if (log) {
|
|
|
|
SBStream sstr;
|
|
|
|
sb_target.GetDescription(sstr, eDescriptionLevelBrief);
|
|
|
|
log->Printf("SBDebugger(%p)::SetSelectedTarget () => SBTarget(%p): %s",
|
|
|
|
static_cast<void *>(m_opaque_sp.get()),
|
|
|
|
static_cast<void *>(target_sp.get()), sstr.GetData());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
SBPlatform SBDebugger::GetSelectedPlatform() {
|
|
|
|
Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
|
|
|
|
|
|
|
|
SBPlatform sb_platform;
|
|
|
|
DebuggerSP debugger_sp(m_opaque_sp);
|
|
|
|
if (debugger_sp) {
|
|
|
|
sb_platform.SetSP(debugger_sp->GetPlatformList().GetSelectedPlatform());
|
|
|
|
}
|
|
|
|
if (log)
|
|
|
|
log->Printf("SBDebugger(%p)::GetSelectedPlatform () => SBPlatform(%p): %s",
|
|
|
|
static_cast<void *>(m_opaque_sp.get()),
|
|
|
|
static_cast<void *>(sb_platform.GetSP().get()),
|
|
|
|
sb_platform.GetName());
|
|
|
|
return sb_platform;
|
2012-09-07 05:58:25 +08:00
|
|
|
}
|
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
void SBDebugger::SetSelectedPlatform(SBPlatform &sb_platform) {
|
|
|
|
Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
|
|
|
|
|
|
|
|
DebuggerSP debugger_sp(m_opaque_sp);
|
|
|
|
if (debugger_sp) {
|
|
|
|
debugger_sp->GetPlatformList().SetSelectedPlatform(sb_platform.GetSP());
|
|
|
|
}
|
2010-06-09 00:52:24 +08:00
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
if (log)
|
|
|
|
log->Printf("SBDebugger(%p)::SetSelectedPlatform (SBPlatform(%p) %s)",
|
|
|
|
static_cast<void *>(m_opaque_sp.get()),
|
|
|
|
static_cast<void *>(sb_platform.GetSP().get()),
|
|
|
|
sb_platform.GetName());
|
|
|
|
}
|
|
|
|
|
2017-08-09 17:20:40 +08:00
|
|
|
uint32_t SBDebugger::GetNumPlatforms() {
|
|
|
|
if (m_opaque_sp) {
|
|
|
|
// No need to lock, the platform list is thread safe
|
|
|
|
return m_opaque_sp->GetPlatformList().GetSize();
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
SBPlatform SBDebugger::GetPlatformAtIndex(uint32_t idx) {
|
|
|
|
SBPlatform sb_platform;
|
|
|
|
if (m_opaque_sp) {
|
|
|
|
// No need to lock, the platform list is thread safe
|
|
|
|
sb_platform.SetSP(m_opaque_sp->GetPlatformList().GetAtIndex(idx));
|
|
|
|
}
|
|
|
|
return sb_platform;
|
|
|
|
}
|
|
|
|
|
|
|
|
uint32_t SBDebugger::GetNumAvailablePlatforms() {
|
|
|
|
uint32_t idx = 0;
|
|
|
|
while (true) {
|
|
|
|
if (!PluginManager::GetPlatformPluginNameAtIndex(idx)) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
++idx;
|
|
|
|
}
|
|
|
|
// +1 for the host platform, which should always appear first in the list.
|
|
|
|
return idx + 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
SBStructuredData SBDebugger::GetAvailablePlatformInfoAtIndex(uint32_t idx) {
|
|
|
|
SBStructuredData data;
|
|
|
|
auto platform_dict = llvm::make_unique<StructuredData::Dictionary>();
|
|
|
|
llvm::StringRef name_str("name"), desc_str("description");
|
|
|
|
|
|
|
|
if (idx == 0) {
|
|
|
|
PlatformSP host_platform_sp(Platform::GetHostPlatform());
|
|
|
|
platform_dict->AddStringItem(
|
|
|
|
name_str, host_platform_sp->GetPluginName().GetStringRef());
|
|
|
|
platform_dict->AddStringItem(
|
|
|
|
desc_str, llvm::StringRef(host_platform_sp->GetDescription()));
|
|
|
|
} else if (idx > 0) {
|
|
|
|
const char *plugin_name =
|
|
|
|
PluginManager::GetPlatformPluginNameAtIndex(idx - 1);
|
|
|
|
if (!plugin_name) {
|
|
|
|
return data;
|
|
|
|
}
|
|
|
|
platform_dict->AddStringItem(name_str, llvm::StringRef(plugin_name));
|
|
|
|
|
|
|
|
const char *plugin_desc =
|
|
|
|
PluginManager::GetPlatformPluginDescriptionAtIndex(idx - 1);
|
|
|
|
if (!plugin_desc) {
|
|
|
|
return data;
|
|
|
|
}
|
|
|
|
platform_dict->AddStringItem(desc_str, llvm::StringRef(plugin_desc));
|
|
|
|
}
|
|
|
|
|
|
|
|
data.m_impl_up->SetObjectSP(
|
|
|
|
StructuredData::ObjectSP(platform_dict.release()));
|
|
|
|
return data;
|
|
|
|
}
|
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
void SBDebugger::DispatchInput(void *baton, const void *data, size_t data_len) {
|
|
|
|
DispatchInput(data, data_len);
|
|
|
|
}
|
|
|
|
|
|
|
|
void SBDebugger::DispatchInput(const void *data, size_t data_len) {
|
|
|
|
// Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
|
|
|
|
//
|
|
|
|
// if (log)
|
|
|
|
// log->Printf ("SBDebugger(%p)::DispatchInput (data=\"%.*s\",
|
|
|
|
// size_t=%" PRIu64 ")",
|
|
|
|
// m_opaque_sp.get(),
|
|
|
|
// (int) data_len,
|
|
|
|
// (const char *) data,
|
|
|
|
// (uint64_t)data_len);
|
|
|
|
//
|
|
|
|
// if (m_opaque_sp)
|
|
|
|
// m_opaque_sp->DispatchInput ((const char *) data, data_len);
|
2010-11-20 04:47:54 +08:00
|
|
|
}
|
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
void SBDebugger::DispatchInputInterrupt() {
|
|
|
|
if (m_opaque_sp)
|
|
|
|
m_opaque_sp->DispatchInputInterrupt();
|
2010-11-20 04:47:54 +08:00
|
|
|
}
|
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
void SBDebugger::DispatchInputEndOfFile() {
|
|
|
|
if (m_opaque_sp)
|
|
|
|
m_opaque_sp->DispatchInputEndOfFile();
|
2010-06-09 00:52:24 +08:00
|
|
|
}
|
2010-06-23 09:19:29 +08:00
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
void SBDebugger::PushInputReader(SBInputReader &reader) {}
|
2014-10-11 08:38:27 +08:00
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
void SBDebugger::RunCommandInterpreter(bool auto_handle_events,
|
|
|
|
bool spawn_thread) {
|
|
|
|
if (m_opaque_sp) {
|
|
|
|
CommandInterpreterRunOptions options;
|
|
|
|
|
|
|
|
m_opaque_sp->GetCommandInterpreter().RunCommandInterpreter(
|
|
|
|
auto_handle_events, spawn_thread, options);
|
|
|
|
}
|
2014-10-11 08:38:27 +08:00
|
|
|
}
|
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
void SBDebugger::RunCommandInterpreter(bool auto_handle_events,
|
|
|
|
bool spawn_thread,
|
|
|
|
SBCommandInterpreterRunOptions &options,
|
|
|
|
int &num_errors, bool &quit_requested,
|
|
|
|
bool &stopped_for_crash)
|
2014-10-11 08:38:27 +08:00
|
|
|
|
|
|
|
{
|
2016-09-07 04:57:50 +08:00
|
|
|
if (m_opaque_sp) {
|
|
|
|
CommandInterpreter &interp = m_opaque_sp->GetCommandInterpreter();
|
|
|
|
interp.RunCommandInterpreter(auto_handle_events, spawn_thread,
|
|
|
|
options.ref());
|
|
|
|
num_errors = interp.GetNumErrors();
|
|
|
|
quit_requested = interp.GetQuitRequested();
|
|
|
|
stopped_for_crash = interp.GetStoppedForCrash();
|
|
|
|
}
|
This patch captures and serializes all output being written by the
command line driver, including the lldb prompt being output by
editline, the asynchronous process output & error messages, and
asynchronous messages written by target stop-hooks.
As part of this it introduces a new Stream class,
StreamAsynchronousIO. A StreamAsynchronousIO object is created with a
broadcaster, who will eventually broadcast the stream's data for a
listener to handle, and an event type indicating what type of event
the broadcaster will broadcast. When the Write method is called on a
StreamAsynchronousIO object, the data is appended to an internal
string. When the Flush method is called on a StreamAsynchronousIO
object, it broadcasts it's data string and clears the string.
Anything in lldb-core that needs to generate asynchronous output for
the end-user should use the StreamAsynchronousIO objects.
I have also added a new notification type for InputReaders, to let
them know that a asynchronous output has been written. This is to
allow the input readers to, for example, refresh their prompts and
lines, if desired. I added the case statements to all the input
readers to catch this notification, but I haven't added any code for
handling them yet (except to the IOChannel input reader).
llvm-svn: 130721
2011-05-03 04:41:46 +08:00
|
|
|
}
|
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
SBError SBDebugger::RunREPL(lldb::LanguageType language,
|
|
|
|
const char *repl_options) {
|
|
|
|
SBError error;
|
|
|
|
if (m_opaque_sp)
|
|
|
|
error.ref() = m_opaque_sp->RunREPL(language, repl_options);
|
|
|
|
else
|
|
|
|
error.SetErrorString("invalid debugger");
|
|
|
|
return error;
|
2015-10-20 08:23:46 +08:00
|
|
|
}
|
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
void SBDebugger::reset(const DebuggerSP &debugger_sp) {
|
|
|
|
m_opaque_sp = debugger_sp;
|
2010-06-23 09:19:29 +08:00
|
|
|
}
|
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
Debugger *SBDebugger::get() const { return m_opaque_sp.get(); }
|
2010-06-23 09:19:29 +08:00
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
Debugger &SBDebugger::ref() const {
|
|
|
|
assert(m_opaque_sp.get());
|
|
|
|
return *m_opaque_sp;
|
2010-06-23 09:19:29 +08:00
|
|
|
}
|
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
const lldb::DebuggerSP &SBDebugger::get_sp() const { return m_opaque_sp; }
|
2010-06-23 09:19:29 +08:00
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
SBDebugger SBDebugger::FindDebuggerWithID(int id) {
|
|
|
|
// No need to lock, the debugger list is thread safe
|
|
|
|
SBDebugger sb_debugger;
|
|
|
|
DebuggerSP debugger_sp = Debugger::FindDebuggerWithID(id);
|
|
|
|
if (debugger_sp)
|
|
|
|
sb_debugger.reset(debugger_sp);
|
|
|
|
return sb_debugger;
|
2010-07-01 00:22:25 +08:00
|
|
|
}
|
2010-08-31 03:44:40 +08:00
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
const char *SBDebugger::GetInstanceName() {
|
|
|
|
return (m_opaque_sp ? m_opaque_sp->GetInstanceName().AsCString() : nullptr);
|
2010-09-10 01:45:09 +08:00
|
|
|
}
|
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
SBError SBDebugger::SetInternalVariable(const char *var_name, const char *value,
|
|
|
|
const char *debugger_instance_name) {
|
|
|
|
SBError sb_error;
|
|
|
|
DebuggerSP debugger_sp(Debugger::FindDebuggerWithInstanceName(
|
|
|
|
ConstString(debugger_instance_name)));
|
2017-05-12 12:51:55 +08:00
|
|
|
Status error;
|
2016-09-07 04:57:50 +08:00
|
|
|
if (debugger_sp) {
|
|
|
|
ExecutionContext exe_ctx(
|
|
|
|
debugger_sp->GetCommandInterpreter().GetExecutionContext());
|
|
|
|
error = debugger_sp->SetPropertyValue(&exe_ctx, eVarSetOperationAssign,
|
|
|
|
var_name, value);
|
|
|
|
} else {
|
|
|
|
error.SetErrorStringWithFormat("invalid debugger instance name '%s'",
|
|
|
|
debugger_instance_name);
|
|
|
|
}
|
|
|
|
if (error.Fail())
|
|
|
|
sb_error.SetError(error);
|
|
|
|
return sb_error;
|
2010-09-04 08:03:46 +08:00
|
|
|
}
|
|
|
|
|
2011-04-19 07:15:17 +08:00
|
|
|
SBStringList
|
2016-09-07 04:57:50 +08:00
|
|
|
SBDebugger::GetInternalVariableValue(const char *var_name,
|
|
|
|
const char *debugger_instance_name) {
|
|
|
|
SBStringList ret_value;
|
|
|
|
DebuggerSP debugger_sp(Debugger::FindDebuggerWithInstanceName(
|
|
|
|
ConstString(debugger_instance_name)));
|
2017-05-12 12:51:55 +08:00
|
|
|
Status error;
|
2016-09-07 04:57:50 +08:00
|
|
|
if (debugger_sp) {
|
|
|
|
ExecutionContext exe_ctx(
|
|
|
|
debugger_sp->GetCommandInterpreter().GetExecutionContext());
|
|
|
|
lldb::OptionValueSP value_sp(
|
|
|
|
debugger_sp->GetPropertyValue(&exe_ctx, var_name, false, error));
|
|
|
|
if (value_sp) {
|
|
|
|
StreamString value_strm;
|
|
|
|
value_sp->DumpValue(&exe_ctx, value_strm, OptionValue::eDumpOptionValue);
|
|
|
|
const std::string &value_str = value_strm.GetString();
|
|
|
|
if (!value_str.empty()) {
|
|
|
|
StringList string_list;
|
|
|
|
string_list.SplitIntoLines(value_str);
|
|
|
|
return SBStringList(&string_list);
|
|
|
|
}
|
2012-08-23 02:39:03 +08:00
|
|
|
}
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
|
|
|
return SBStringList();
|
2010-09-04 08:03:46 +08:00
|
|
|
}
|
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
uint32_t SBDebugger::GetTerminalWidth() const {
|
|
|
|
return (m_opaque_sp ? m_opaque_sp->GetTerminalWidth() : 0);
|
2010-09-18 09:14:36 +08:00
|
|
|
}
|
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
void SBDebugger::SetTerminalWidth(uint32_t term_width) {
|
|
|
|
if (m_opaque_sp)
|
|
|
|
m_opaque_sp->SetTerminalWidth(term_width);
|
2010-09-18 09:14:36 +08:00
|
|
|
}
|
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
const char *SBDebugger::GetPrompt() const {
|
|
|
|
Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
|
2014-04-04 12:06:10 +08:00
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
if (log)
|
|
|
|
log->Printf("SBDebugger(%p)::GetPrompt () => \"%s\"",
|
|
|
|
static_cast<void *>(m_opaque_sp.get()),
|
2016-09-24 02:06:53 +08:00
|
|
|
(m_opaque_sp ? m_opaque_sp->GetPrompt().str().c_str() : ""));
|
2010-10-26 11:11:13 +08:00
|
|
|
|
2016-09-24 02:06:53 +08:00
|
|
|
return (m_opaque_sp ? ConstString(m_opaque_sp->GetPrompt()).GetCString()
|
|
|
|
: nullptr);
|
2010-09-18 09:14:36 +08:00
|
|
|
}
|
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
void SBDebugger::SetPrompt(const char *prompt) {
|
|
|
|
if (m_opaque_sp)
|
2016-09-24 02:06:53 +08:00
|
|
|
m_opaque_sp->SetPrompt(llvm::StringRef::withNullAsEmpty(prompt));
|
2010-09-18 09:14:36 +08:00
|
|
|
}
|
2016-09-07 04:57:50 +08:00
|
|
|
|
|
|
|
ScriptLanguage SBDebugger::GetScriptLanguage() const {
|
|
|
|
return (m_opaque_sp ? m_opaque_sp->GetScriptLanguage() : eScriptLanguageNone);
|
2010-09-18 09:14:36 +08:00
|
|
|
}
|
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
void SBDebugger::SetScriptLanguage(ScriptLanguage script_lang) {
|
|
|
|
if (m_opaque_sp) {
|
|
|
|
m_opaque_sp->SetScriptLanguage(script_lang);
|
|
|
|
}
|
2010-09-18 09:14:36 +08:00
|
|
|
}
|
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
bool SBDebugger::SetUseExternalEditor(bool value) {
|
|
|
|
return (m_opaque_sp ? m_opaque_sp->SetUseExternalEditor(value) : false);
|
2010-08-31 03:44:40 +08:00
|
|
|
}
|
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
bool SBDebugger::GetUseExternalEditor() {
|
|
|
|
return (m_opaque_sp ? m_opaque_sp->GetUseExternalEditor() : false);
|
2010-08-31 03:44:40 +08:00
|
|
|
}
|
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
bool SBDebugger::SetUseColor(bool value) {
|
|
|
|
return (m_opaque_sp ? m_opaque_sp->SetUseColor(value) : false);
|
2013-05-24 04:47:45 +08:00
|
|
|
}
|
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
bool SBDebugger::GetUseColor() const {
|
|
|
|
return (m_opaque_sp ? m_opaque_sp->GetUseColor() : false);
|
2013-05-24 04:47:45 +08:00
|
|
|
}
|
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
bool SBDebugger::GetDescription(SBStream &description) {
|
|
|
|
Stream &strm = description.ref();
|
2011-11-13 14:57:31 +08:00
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
if (m_opaque_sp) {
|
|
|
|
const char *name = m_opaque_sp->GetInstanceName().AsCString();
|
|
|
|
user_id_t id = m_opaque_sp->GetID();
|
|
|
|
strm.Printf("Debugger (instance: \"%s\", id: %" PRIu64 ")", name, id);
|
|
|
|
} else
|
|
|
|
strm.PutCString("No value");
|
|
|
|
|
|
|
|
return true;
|
2010-09-20 13:20:02 +08:00
|
|
|
}
|
2010-11-20 04:47:54 +08:00
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
user_id_t SBDebugger::GetID() {
|
|
|
|
return (m_opaque_sp ? m_opaque_sp->GetID() : LLDB_INVALID_UID);
|
2010-11-20 04:47:54 +08:00
|
|
|
}
|
2011-04-30 09:09:13 +08:00
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
SBError SBDebugger::SetCurrentPlatform(const char *platform_name_cstr) {
|
|
|
|
SBError sb_error;
|
|
|
|
if (m_opaque_sp) {
|
|
|
|
if (platform_name_cstr && platform_name_cstr[0]) {
|
|
|
|
ConstString platform_name(platform_name_cstr);
|
|
|
|
PlatformSP platform_sp(Platform::Find(platform_name));
|
|
|
|
|
|
|
|
if (platform_sp) {
|
|
|
|
// Already have a platform with this name, just select it
|
|
|
|
m_opaque_sp->GetPlatformList().SetSelectedPlatform(platform_sp);
|
|
|
|
} else {
|
|
|
|
// We don't have a platform by this name yet, create one
|
|
|
|
platform_sp = Platform::Create(platform_name, sb_error.ref());
|
|
|
|
if (platform_sp) {
|
|
|
|
// We created the platform, now append and select it
|
|
|
|
bool make_selected = true;
|
|
|
|
m_opaque_sp->GetPlatformList().Append(platform_sp, make_selected);
|
2011-04-30 09:09:13 +08:00
|
|
|
}
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
|
|
|
} else {
|
|
|
|
sb_error.ref().SetErrorString("invalid platform name");
|
2011-04-30 09:09:13 +08:00
|
|
|
}
|
2016-09-07 04:57:50 +08:00
|
|
|
} else {
|
|
|
|
sb_error.ref().SetErrorString("invalid debugger");
|
|
|
|
}
|
|
|
|
return sb_error;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool SBDebugger::SetCurrentPlatformSDKRoot(const char *sysroot) {
|
|
|
|
Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
|
|
|
|
if (m_opaque_sp) {
|
|
|
|
PlatformSP platform_sp(
|
|
|
|
m_opaque_sp->GetPlatformList().GetSelectedPlatform());
|
|
|
|
|
|
|
|
if (platform_sp) {
|
|
|
|
if (log && sysroot)
|
|
|
|
log->Printf("SBDebugger::SetCurrentPlatformSDKRoot (\"%s\")", sysroot);
|
|
|
|
platform_sp->SetSDKRootDirectory(ConstString(sysroot));
|
|
|
|
return true;
|
2014-09-20 04:11:50 +08:00
|
|
|
}
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
|
|
|
return false;
|
2011-04-30 09:09:13 +08:00
|
|
|
}
|
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
bool SBDebugger::GetCloseInputOnEOF() const {
|
|
|
|
return (m_opaque_sp ? m_opaque_sp->GetCloseInputOnEOF() : false);
|
2011-06-17 11:31:01 +08:00
|
|
|
}
|
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
void SBDebugger::SetCloseInputOnEOF(bool b) {
|
|
|
|
if (m_opaque_sp)
|
|
|
|
m_opaque_sp->SetCloseInputOnEOF(b);
|
2011-05-29 12:06:55 +08:00
|
|
|
}
|
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
SBTypeCategory SBDebugger::GetCategory(const char *category_name) {
|
|
|
|
if (!category_name || *category_name == 0)
|
|
|
|
return SBTypeCategory();
|
2012-02-15 10:34:21 +08:00
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
TypeCategoryImplSP category_sp;
|
|
|
|
|
|
|
|
if (DataVisualization::Categories::GetCategory(ConstString(category_name),
|
|
|
|
category_sp, false))
|
|
|
|
return SBTypeCategory(category_sp);
|
|
|
|
else
|
|
|
|
return SBTypeCategory();
|
2012-02-15 10:34:21 +08:00
|
|
|
}
|
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
SBTypeCategory SBDebugger::GetCategory(lldb::LanguageType lang_type) {
|
|
|
|
TypeCategoryImplSP category_sp;
|
|
|
|
if (DataVisualization::Categories::GetCategory(lang_type, category_sp))
|
|
|
|
return SBTypeCategory(category_sp);
|
|
|
|
else
|
|
|
|
return SBTypeCategory();
|
2015-12-19 05:25:24 +08:00
|
|
|
}
|
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
SBTypeCategory SBDebugger::CreateCategory(const char *category_name) {
|
|
|
|
if (!category_name || *category_name == 0)
|
|
|
|
return SBTypeCategory();
|
|
|
|
|
|
|
|
TypeCategoryImplSP category_sp;
|
|
|
|
|
|
|
|
if (DataVisualization::Categories::GetCategory(ConstString(category_name),
|
|
|
|
category_sp, true))
|
|
|
|
return SBTypeCategory(category_sp);
|
|
|
|
else
|
|
|
|
return SBTypeCategory();
|
2012-02-15 10:34:21 +08:00
|
|
|
}
|
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
bool SBDebugger::DeleteCategory(const char *category_name) {
|
|
|
|
if (!category_name || *category_name == 0)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
return DataVisualization::Categories::Delete(ConstString(category_name));
|
2012-02-15 10:34:21 +08:00
|
|
|
}
|
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
uint32_t SBDebugger::GetNumCategories() {
|
|
|
|
return DataVisualization::Categories::GetCount();
|
2012-02-15 10:34:21 +08:00
|
|
|
}
|
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
SBTypeCategory SBDebugger::GetCategoryAtIndex(uint32_t index) {
|
|
|
|
return SBTypeCategory(
|
|
|
|
DataVisualization::Categories::GetCategoryAtIndex(index));
|
2012-02-15 10:34:21 +08:00
|
|
|
}
|
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
SBTypeCategory SBDebugger::GetDefaultCategory() {
|
|
|
|
return GetCategory("default");
|
2012-02-15 10:34:21 +08:00
|
|
|
}
|
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
SBTypeFormat SBDebugger::GetFormatForType(SBTypeNameSpecifier type_name) {
|
|
|
|
SBTypeCategory default_category_sb = GetDefaultCategory();
|
|
|
|
if (default_category_sb.GetEnabled())
|
|
|
|
return default_category_sb.GetFormatForType(type_name);
|
|
|
|
return SBTypeFormat();
|
2012-02-15 10:34:21 +08:00
|
|
|
}
|
|
|
|
|
2012-02-21 13:33:55 +08:00
|
|
|
#ifndef LLDB_DISABLE_PYTHON
|
2016-09-07 04:57:50 +08:00
|
|
|
SBTypeSummary SBDebugger::GetSummaryForType(SBTypeNameSpecifier type_name) {
|
|
|
|
if (!type_name.IsValid())
|
|
|
|
return SBTypeSummary();
|
|
|
|
return SBTypeSummary(DataVisualization::GetSummaryForType(type_name.GetSP()));
|
2012-02-15 10:34:21 +08:00
|
|
|
}
|
2012-02-21 13:33:55 +08:00
|
|
|
#endif // LLDB_DISABLE_PYTHON
|
2012-02-15 10:34:21 +08:00
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
SBTypeFilter SBDebugger::GetFilterForType(SBTypeNameSpecifier type_name) {
|
|
|
|
if (!type_name.IsValid())
|
|
|
|
return SBTypeFilter();
|
|
|
|
return SBTypeFilter(DataVisualization::GetFilterForType(type_name.GetSP()));
|
2012-02-15 10:34:21 +08:00
|
|
|
}
|
|
|
|
|
2012-02-21 13:33:55 +08:00
|
|
|
#ifndef LLDB_DISABLE_PYTHON
|
2016-09-07 04:57:50 +08:00
|
|
|
SBTypeSynthetic SBDebugger::GetSyntheticForType(SBTypeNameSpecifier type_name) {
|
|
|
|
if (!type_name.IsValid())
|
|
|
|
return SBTypeSynthetic();
|
|
|
|
return SBTypeSynthetic(
|
|
|
|
DataVisualization::GetSyntheticForType(type_name.GetSP()));
|
2012-02-15 10:34:21 +08:00
|
|
|
}
|
2012-02-21 13:33:55 +08:00
|
|
|
#endif // LLDB_DISABLE_PYTHON
|
2012-02-15 10:34:21 +08:00
|
|
|
|
2017-03-01 18:08:40 +08:00
|
|
|
static llvm::ArrayRef<const char *> GetCategoryArray(const char **categories) {
|
|
|
|
if (categories == nullptr)
|
|
|
|
return {};
|
|
|
|
size_t len = 0;
|
|
|
|
while (categories[len] != nullptr)
|
|
|
|
++len;
|
|
|
|
return llvm::makeArrayRef(categories, len);
|
|
|
|
}
|
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
bool SBDebugger::EnableLog(const char *channel, const char **categories) {
|
|
|
|
if (m_opaque_sp) {
|
|
|
|
uint32_t log_options =
|
|
|
|
LLDB_LOG_OPTION_PREPEND_TIMESTAMP | LLDB_LOG_OPTION_PREPEND_THREAD_NAME;
|
2017-03-15 17:06:58 +08:00
|
|
|
std::string error;
|
|
|
|
llvm::raw_string_ostream error_stream(error);
|
2017-03-01 18:08:40 +08:00
|
|
|
return m_opaque_sp->EnableLog(channel, GetCategoryArray(categories), "",
|
2017-03-15 17:06:58 +08:00
|
|
|
log_options, error_stream);
|
2016-09-07 04:57:50 +08:00
|
|
|
} else
|
|
|
|
return false;
|
2012-02-21 10:23:08 +08:00
|
|
|
}
|
2012-02-23 06:49:20 +08:00
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
void SBDebugger::SetLoggingCallback(lldb::LogOutputCallback log_callback,
|
|
|
|
void *baton) {
|
|
|
|
if (m_opaque_sp) {
|
|
|
|
return m_opaque_sp->SetLoggingCallback(log_callback, baton);
|
|
|
|
}
|
2012-02-23 06:49:20 +08:00
|
|
|
}
|