Files
llvm-tms34010/lldb/source/API/SBStructuredData.cpp
T
jimingham 457380cee1 Add a breakpoint override resolver feature to lldb (#195392)
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.
2026-05-11 15:55:34 -07:00

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());
}