This is a general mechanism that allows a custom breakpoint resolver to "override" the resolver lldb would have used. It is implemented by making a scripted breakpoint resolver class, implementing an extra "overrides_resolver" method. When lldb has decided what resolver it is going to use for the breakpoint, if there are any override resolvers registered, it will pass the serialized form of the resolver to the `overrides_resolver` method of the registered resolvers. If any of the override resolvers return true from the overrides_resolver method, that resolver will be used in place of the one lldb would have used. The original motivation for this feature is to make the support of "debugging a scripting language from the implementation side". We added the notion of "facade breakpoints" so that a location given in the context of the scripting language can be handled by the emulation code. But when you are using lldb in some IDE, when "stopped" in the scripting language, the IDE will show the scripting language source. It is natural in that case for the user to expect the UI gesture to set a file and line breakpoint should work the same way. To implement that, the implementor would make their facade breakpoint resolver also an override resolver that checks to see if the incoming resolver was a file and line breakpoint for a source file of the scripting language type. If it is, it returns true, and lldb will use that resolver instead. Note, this will also work when breakpoints are set on the command line, so you can transparently support "scripting language" breakpoints from the command line as well.
283 lines
7.5 KiB
C++
283 lines
7.5 KiB
C++
//===-- SBStructuredData.cpp ----------------------------------------------===//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "lldb/API/SBStructuredData.h"
|
|
|
|
#include "lldb/API/SBDebugger.h"
|
|
#include "lldb/API/SBScriptObject.h"
|
|
#include "lldb/API/SBStream.h"
|
|
#include "lldb/API/SBStringList.h"
|
|
#include "lldb/Core/Debugger.h"
|
|
#include "lldb/Core/StructuredDataImpl.h"
|
|
#include "lldb/Interpreter/ScriptInterpreter.h"
|
|
#include "lldb/Target/StructuredDataPlugin.h"
|
|
#include "lldb/Utility/Event.h"
|
|
#include "lldb/Utility/Instrumentation.h"
|
|
#include "lldb/Utility/Status.h"
|
|
#include "lldb/Utility/Stream.h"
|
|
#include "lldb/Utility/StringList.h"
|
|
#include "lldb/Utility/StructuredData.h"
|
|
|
|
using namespace lldb;
|
|
using namespace lldb_private;
|
|
|
|
#pragma mark--
|
|
#pragma mark SBStructuredData
|
|
|
|
SBStructuredData::SBStructuredData() : m_impl_up(new StructuredDataImpl()) {
|
|
LLDB_INSTRUMENT_VA(this);
|
|
}
|
|
|
|
SBStructuredData::SBStructuredData(const lldb::SBStructuredData &rhs)
|
|
: m_impl_up(new StructuredDataImpl(*rhs.m_impl_up)) {
|
|
LLDB_INSTRUMENT_VA(this, rhs);
|
|
}
|
|
|
|
SBStructuredData::SBStructuredData(const lldb::SBScriptObject obj,
|
|
const lldb::SBDebugger &debugger) {
|
|
LLDB_INSTRUMENT_VA(this, obj, debugger);
|
|
|
|
if (!obj.IsValid())
|
|
return;
|
|
|
|
ScriptInterpreter *interpreter =
|
|
debugger.m_opaque_sp->GetScriptInterpreter(true, obj.GetLanguage());
|
|
|
|
if (!interpreter)
|
|
return;
|
|
|
|
StructuredDataImplUP impl_up = std::make_unique<StructuredDataImpl>(
|
|
interpreter->CreateStructuredDataFromScriptObject(obj.ref()));
|
|
if (impl_up && impl_up->IsValid())
|
|
m_impl_up.reset(impl_up.release());
|
|
}
|
|
|
|
SBStructuredData::SBStructuredData(const lldb::EventSP &event_sp)
|
|
: m_impl_up(new StructuredDataImpl(event_sp)) {
|
|
LLDB_INSTRUMENT_VA(this, event_sp);
|
|
}
|
|
|
|
SBStructuredData::SBStructuredData(const lldb_private::StructuredDataImpl &impl)
|
|
: m_impl_up(new StructuredDataImpl(impl)) {
|
|
LLDB_INSTRUMENT_VA(this, impl);
|
|
}
|
|
|
|
SBStructuredData::~SBStructuredData() = default;
|
|
|
|
SBStructuredData &SBStructuredData::
|
|
operator=(const lldb::SBStructuredData &rhs) {
|
|
LLDB_INSTRUMENT_VA(this, rhs);
|
|
|
|
*m_impl_up = *rhs.m_impl_up;
|
|
return *this;
|
|
}
|
|
|
|
void SBStructuredData::CopyImpl(lldb_private::StructuredDataImpl &new_impl) {
|
|
new_impl.SetObjectSP(m_impl_up->GetObjectSP());
|
|
}
|
|
|
|
lldb::SBError SBStructuredData::SetFromJSON(lldb::SBStream &stream) {
|
|
LLDB_INSTRUMENT_VA(this, stream);
|
|
|
|
lldb::SBError error;
|
|
|
|
StructuredData::ObjectSP json_obj =
|
|
StructuredData::ParseJSON(stream.GetData());
|
|
m_impl_up->SetObjectSP(json_obj);
|
|
|
|
static constexpr StructuredDataType unsupported_type[] = {
|
|
eStructuredDataTypeInvalid,
|
|
eStructuredDataTypeGeneric,
|
|
};
|
|
|
|
if (!json_obj || llvm::is_contained(unsupported_type, json_obj->GetType()))
|
|
error = Status::FromErrorString("Invalid Syntax");
|
|
return error;
|
|
}
|
|
|
|
lldb::SBError SBStructuredData::SetFromJSON(const char *json) {
|
|
LLDB_INSTRUMENT_VA(this, json);
|
|
lldb::SBStream s;
|
|
s.Print(json);
|
|
return SetFromJSON(s);
|
|
}
|
|
|
|
bool SBStructuredData::IsValid() const {
|
|
LLDB_INSTRUMENT_VA(this);
|
|
return this->operator bool();
|
|
}
|
|
|
|
SBStructuredData::operator bool() const {
|
|
LLDB_INSTRUMENT_VA(this);
|
|
|
|
return m_impl_up->IsValid();
|
|
}
|
|
|
|
void SBStructuredData::Clear() {
|
|
LLDB_INSTRUMENT_VA(this);
|
|
|
|
m_impl_up->Clear();
|
|
}
|
|
|
|
SBError SBStructuredData::GetAsJSON(lldb::SBStream &stream) const {
|
|
LLDB_INSTRUMENT_VA(this, stream);
|
|
|
|
SBError error;
|
|
error.SetError(m_impl_up->GetAsJSON(stream.ref()));
|
|
return error;
|
|
}
|
|
|
|
lldb::SBError SBStructuredData::GetDescription(lldb::SBStream &stream) const {
|
|
LLDB_INSTRUMENT_VA(this, stream);
|
|
|
|
Status error = m_impl_up->GetDescription(stream.ref());
|
|
SBError sb_error;
|
|
sb_error.SetError(std::move(error));
|
|
return sb_error;
|
|
}
|
|
|
|
StructuredDataType SBStructuredData::GetType() const {
|
|
LLDB_INSTRUMENT_VA(this);
|
|
|
|
return m_impl_up->GetType();
|
|
}
|
|
|
|
size_t SBStructuredData::GetSize() const {
|
|
LLDB_INSTRUMENT_VA(this);
|
|
|
|
return m_impl_up->GetSize();
|
|
}
|
|
|
|
bool SBStructuredData::GetKeys(lldb::SBStringList &keys) const {
|
|
LLDB_INSTRUMENT_VA(this, keys);
|
|
|
|
if (GetType() != eStructuredDataTypeDictionary)
|
|
return false;
|
|
|
|
StructuredData::ObjectSP obj_sp = m_impl_up->GetObjectSP();
|
|
if (!obj_sp)
|
|
return false;
|
|
|
|
StructuredData::Dictionary *dict = obj_sp->GetAsDictionary();
|
|
// We claimed we were a dictionary, so this can't be null.
|
|
assert(dict);
|
|
// The return kind of GetKeys is an Array:
|
|
StructuredData::ObjectSP array_sp = dict->GetKeys();
|
|
StructuredData::Array *key_arr = array_sp->GetAsArray();
|
|
assert(key_arr);
|
|
|
|
key_arr->ForEach([&keys](StructuredData::Object *object) -> bool {
|
|
llvm::StringRef key = object->GetStringValue("");
|
|
keys->AppendString(key);
|
|
return true;
|
|
});
|
|
return true;
|
|
}
|
|
|
|
lldb::SBStructuredData SBStructuredData::GetValueForKey(const char *key) const {
|
|
LLDB_INSTRUMENT_VA(this, key);
|
|
|
|
SBStructuredData result;
|
|
result.m_impl_up->SetObjectSP(m_impl_up->GetValueForKey(key));
|
|
return result;
|
|
}
|
|
|
|
lldb::SBStructuredData SBStructuredData::GetItemAtIndex(size_t idx) const {
|
|
LLDB_INSTRUMENT_VA(this, idx);
|
|
|
|
SBStructuredData result;
|
|
result.m_impl_up->SetObjectSP(m_impl_up->GetItemAtIndex(idx));
|
|
return result;
|
|
}
|
|
|
|
uint64_t SBStructuredData::GetIntegerValue(uint64_t fail_value) const {
|
|
LLDB_INSTRUMENT_VA(this, fail_value);
|
|
|
|
return GetUnsignedIntegerValue(fail_value);
|
|
}
|
|
|
|
uint64_t SBStructuredData::GetUnsignedIntegerValue(uint64_t fail_value) const {
|
|
LLDB_INSTRUMENT_VA(this, fail_value);
|
|
|
|
return m_impl_up->GetIntegerValue(fail_value);
|
|
}
|
|
|
|
int64_t SBStructuredData::GetSignedIntegerValue(int64_t fail_value) const {
|
|
LLDB_INSTRUMENT_VA(this, fail_value);
|
|
|
|
return m_impl_up->GetIntegerValue(fail_value);
|
|
}
|
|
|
|
double SBStructuredData::GetFloatValue(double fail_value) const {
|
|
LLDB_INSTRUMENT_VA(this, fail_value);
|
|
|
|
return m_impl_up->GetFloatValue(fail_value);
|
|
}
|
|
|
|
bool SBStructuredData::GetBooleanValue(bool fail_value) const {
|
|
LLDB_INSTRUMENT_VA(this, fail_value);
|
|
|
|
return m_impl_up->GetBooleanValue(fail_value);
|
|
}
|
|
|
|
size_t SBStructuredData::GetStringValue(char *dst, size_t dst_len) const {
|
|
LLDB_INSTRUMENT_VA(this, dst, dst_len);
|
|
|
|
return m_impl_up->GetStringValue(dst, dst_len);
|
|
}
|
|
|
|
lldb::SBScriptObject SBStructuredData::GetGenericValue() const {
|
|
LLDB_INSTRUMENT_VA(this);
|
|
|
|
return {m_impl_up->GetGenericValue(), eScriptLanguageDefault};
|
|
}
|
|
|
|
void SBStructuredData::SetValueForKey(const char *key,
|
|
SBStructuredData &value) {
|
|
LLDB_INSTRUMENT_VA(this, key, value);
|
|
|
|
if (StructuredData::ObjectSP obj_sp = value.m_impl_up->GetObjectSP())
|
|
m_impl_up->SetValueForKey(key, obj_sp);
|
|
}
|
|
|
|
void SBStructuredData::SetUnsignedIntegerValue(uint64_t value) {
|
|
LLDB_INSTRUMENT_VA(this, value);
|
|
|
|
m_impl_up->SetUnsignedIntegerValue(value);
|
|
}
|
|
|
|
void SBStructuredData::SetSignedIntegerValue(int64_t value) {
|
|
LLDB_INSTRUMENT_VA(this, value);
|
|
|
|
m_impl_up->SetSignedIntegerValue(value);
|
|
}
|
|
|
|
void SBStructuredData::SetFloatValue(double value) {
|
|
LLDB_INSTRUMENT_VA(this, value);
|
|
|
|
m_impl_up->SetFloatValue(value);
|
|
}
|
|
|
|
void SBStructuredData::SetBooleanValue(bool value) {
|
|
LLDB_INSTRUMENT_VA(this, value);
|
|
|
|
m_impl_up->SetBooleanValue(value);
|
|
}
|
|
|
|
void SBStructuredData::SetStringValue(const char *value) {
|
|
LLDB_INSTRUMENT_VA(this, value);
|
|
|
|
m_impl_up->SetStringValue(value);
|
|
}
|
|
|
|
void SBStructuredData::SetGenericValue(SBScriptObject value) {
|
|
LLDB_INSTRUMENT_VA(this, value);
|
|
|
|
m_impl_up->SetGenericValue(value.GetPointer());
|
|
}
|