https://github.com/jimingham updated https://github.com/llvm/llvm-project/pull/195392
>From 60cca57c9b3ee1ab9e9a4341a8c4242ae233bedb Mon Sep 17 00:00:00 2001 From: Jim Ingham <[email protected]> Date: Thu, 30 Apr 2026 16:00:56 -0700 Subject: [PATCH 1/3] First stage of adding "override resolvers". This adds a Python API to add the resolvers, the underlying code to support the overrides, and a test for the Python API. I still need to add commands to list, delete, enable and disable these overrides, and tests for the commands. --- lldb/ScriptedBreakpointInterface.cpp | 23 ++ lldb/bindings/python/python-wrapper.swig | 12 + .../tutorials/creating-custom-breakpoints.md | 26 +++ lldb/include/lldb/API/SBStructuredData.h | 4 + lldb/include/lldb/API/SBTarget.h | 7 + .../lldb/Breakpoint/BreakpointResolver.h | 7 + .../Breakpoint/BreakpointResolverScripted.h | 11 +- .../Interfaces/ScriptedBreakpointInterface.h | 30 +++ .../lldb/Interpreter/ScriptInterpreter.h | 3 + lldb/include/lldb/Target/Target.h | 86 +++++++ lldb/source/API/SBStructuredData.cpp | 4 + lldb/source/API/SBTarget.cpp | 23 ++ .../Breakpoint/BreakpointResolverScripted.cpp | 50 +++- .../Commands/CommandObjectBreakpoint.cpp | 220 ++++++++++++++++++ lldb/source/Commands/Options.td | 4 + .../Interpreter/Interfaces/CMakeLists.txt | 1 + .../ScriptedBreakpointInterface.cpp | 23 ++ lldb/source/Interpreter/ScriptInterpreter.cpp | 5 + .../ScriptedBreakpointPythonInterface.cpp | 31 +++ .../ScriptedBreakpointPythonInterface.h | 5 +- .../Interfaces/ScriptedPythonInterface.cpp | 15 ++ .../Interfaces/ScriptedPythonInterface.h | 7 +- .../Python/SWIGPythonBridge.h | 1 + lldb/source/Target/Target.cpp | 24 ++ .../scripted_bkpt/overrides_resolver/Makefile | 4 + .../TestOverridesResolver.py | 124 ++++++++++ .../overrides_resolver/bkpt_resolver.py | 38 +++ .../scripted_bkpt/overrides_resolver/main.c | 22 ++ .../Python/PythonTestSuite.cpp | 5 + 29 files changed, 807 insertions(+), 8 deletions(-) create mode 100644 lldb/ScriptedBreakpointInterface.cpp create mode 100644 lldb/source/Interpreter/Interfaces/ScriptedBreakpointInterface.cpp create mode 100644 lldb/test/API/functionalities/breakpoint/scripted_bkpt/overrides_resolver/Makefile create mode 100644 lldb/test/API/functionalities/breakpoint/scripted_bkpt/overrides_resolver/TestOverridesResolver.py create mode 100644 lldb/test/API/functionalities/breakpoint/scripted_bkpt/overrides_resolver/bkpt_resolver.py create mode 100644 lldb/test/API/functionalities/breakpoint/scripted_bkpt/overrides_resolver/main.c diff --git a/lldb/ScriptedBreakpointInterface.cpp b/lldb/ScriptedBreakpointInterface.cpp new file mode 100644 index 0000000000000..66c482b69af9a --- /dev/null +++ b/lldb/ScriptedBreakpointInterface.cpp @@ -0,0 +1,23 @@ +//===----------------------------------------------------------------------===// +// +// 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/Interpreter/Interfaces/ScriptedBreakpointInterface.h" +#include "lldb/Breakpoint/Breakpoint.h" +#include "lldb/Breakpoint/BreakpointResolverScripted.h" + +namespace lldb_private { +lldb::BreakpointResolverSP ScriptedBreakpointResolverOverride::CheckForOverride( + lldb::BreakpointResolverSP initial_sp) { + lldb::BreakpointResolverSP candidate_sp(new BreakpointResolverScripted( + initial_sp->GetBreakpoint(), m_class_name, initial_sp->GetDepth(), + m_args_data)); + if (candidate_sp->OverridesResolver(initial_sp)) + return candidate_sp; + return {}; +} +} diff --git a/lldb/bindings/python/python-wrapper.swig b/lldb/bindings/python/python-wrapper.swig index 72f90f1b23c29..dea4f6b4c7f7c 100644 --- a/lldb/bindings/python/python-wrapper.swig +++ b/lldb/bindings/python/python-wrapper.swig @@ -595,6 +595,18 @@ void *lldb_private::python::LLDBSWIGPython_CastPyObjectToSBFrameList(PyObject *d return sb_ptr; } +void *lldb_private::python::LLDBSWIGPython_CastPyObjectToSBTarget(PyObject * + data) { + lldb::SBTarget *sb_ptr = NULL; + + int valid_cast = SWIG_ConvertPtr(data, (void **)&sb_ptr, + SWIGTYPE_p_lldb__SBTarget, 0); + + if (valid_cast == -1) + return NULL; + + return sb_ptr; +} bool lldb_private::python::SWIGBridge::LLDBSwigPythonCallCommand( const char *python_function_name, const char *session_dictionary_name, lldb::DebuggerSP debugger, const char *args, diff --git a/lldb/docs/use/tutorials/creating-custom-breakpoints.md b/lldb/docs/use/tutorials/creating-custom-breakpoints.md index b31a600a7505a..f12655d9471af 100644 --- a/lldb/docs/use/tutorials/creating-custom-breakpoints.md +++ b/lldb/docs/use/tutorials/creating-custom-breakpoints.md @@ -170,3 +170,29 @@ The Facade location adds these optional affordances to the Resolver class: |`was_hit`| `frame`:`lldb.SBFrame` `bp_loc`:`lldb.SBBreakpointLocation` | This will get called when one of the "real" locations set by your resolver is hit. `frame` is the stack frame that hit this location. `bp_loc` is the real location that was hit. Return either the facade location that you want to consider hit on this stop, or None if you don't consider any of your facade locations to have been hit. | | `get_location_description` | `bp_loc`:`lldb.SBBreakpointLocation` `desc_level`:`lldb.DescriptionLevel` `bp_loc` is the facade location to describe.| Use this to provide a helpful description of each facade location. ``desc_level`` is the level of description requested. The Brief description is printed when the location is hit. Full is printed for `break list` and Verbose for `break list -v`.| +## Override breakpoint resolvers + +If a breakpoint resolver can provide a better action for some subset of +breakpoints that lldb would normally set using its own resolvers, it can +register itself as an "Override Resolver" using: + +``` +SBTarget.AddBreakpointOverrideResolver(classname, description, extra_args) +``` + +description is what will show in the command: + +``` +(lldb) breakpoint override resolver list +``` + +And extra_args is an SBStructuredData that will get passed to the constructor +of your breakpoint resolver when we make an instance to check for overrides. + +The overrides resolver requires the following to be implemented: + +| Name | Arguments | Description| +|-------|-----------|------------| +|`overrides_resolver`| `orig_resolver_data`:`lldb.SBStructuredData` | This will get called when lldb has determined the resolver it would normally use for the breakpoint. `orig_resolver_data` the serialized form of the breakpoint resolver lldb would have used. If you return True from the API, then lldb will use this instance of your resolver instead of the one it would have used. | + + diff --git a/lldb/include/lldb/API/SBStructuredData.h b/lldb/include/lldb/API/SBStructuredData.h index 5f688664c570b..d7f2a539210af 100644 --- a/lldb/include/lldb/API/SBStructuredData.h +++ b/lldb/include/lldb/API/SBStructuredData.h @@ -137,6 +137,10 @@ class SBStructuredData { /// Change the type to generic and overwrite the previous data with the new /// value. void SetGenericValue(SBScriptObject value); + +#ifndef SWIG + void CopyImpl(lldb_private::StructuredDataImpl &new_impl); +#endif protected: friend class SBAttachInfo; diff --git a/lldb/include/lldb/API/SBTarget.h b/lldb/include/lldb/API/SBTarget.h index 93b3aab578f42..e859e04f72489 100644 --- a/lldb/include/lldb/API/SBTarget.h +++ b/lldb/include/lldb/API/SBTarget.h @@ -637,6 +637,11 @@ class LLDB_API SBTarget { /// The amount of data read in host bytes. size_t ReadMemory(const SBAddress addr, void *buf, size_t size, lldb::SBError &error); + + uint64_t AddBreakpointOverride(const char *class_name, + const char *description, SBStructuredData &args_data); + + bool RemoveBreakpointOverride(uint64_t id); lldb::SBBreakpoint BreakpointCreateByLocation(const char *file, uint32_t line); @@ -1050,6 +1055,8 @@ class LLDB_API SBTarget { friend class SBVariablesOptions; friend class lldb_private::python::SWIGBridge; + friend class lldb_private::lua::SWIGBridge; + friend class lldb_private::ScriptInterpreter; // Constructors are private, use static Target::Create function to create an // instance of this class. diff --git a/lldb/include/lldb/Breakpoint/BreakpointResolver.h b/lldb/include/lldb/Breakpoint/BreakpointResolver.h index 7be6b7a94c618..df94086c76122 100644 --- a/lldb/include/lldb/Breakpoint/BreakpointResolver.h +++ b/lldb/include/lldb/Breakpoint/BreakpointResolver.h @@ -112,6 +112,13 @@ class BreakpointResolver : public Searcher { virtual StructuredData::ObjectSP SerializeToStructuredData() { return StructuredData::ObjectSP(); } + + /// The resolver_sp won't have had its breakpoint set by the time we are + /// checking the Override, but it might need to access the Target, so we pass + /// that in here. + virtual bool OverridesResolver(Target &target, lldb::BreakpointResolverSP resolver_sp) { + return false; + } static const char *GetSerializationKey() { return "BKPTResolver"; } diff --git a/lldb/include/lldb/Breakpoint/BreakpointResolverScripted.h b/lldb/include/lldb/Breakpoint/BreakpointResolverScripted.h index c3c1c80f49043..ed931316cfc46 100644 --- a/lldb/include/lldb/Breakpoint/BreakpointResolverScripted.h +++ b/lldb/include/lldb/Breakpoint/BreakpointResolverScripted.h @@ -62,11 +62,19 @@ class BreakpointResolverScripted : public BreakpointResolver { lldb::BreakpointResolverSP CopyForBreakpoint(lldb::BreakpointSP &breakpoint) override; - + + // OverridesResolver will get called before this resolver has been assigned a + // breakpoint. You should only need to see the resolver to know whether you + // want to override it, but you may need to check something about the target, + // which you would normally get to from the breakpoint, so we pass it in here. + bool OverridesResolver(Target &target, + lldb::BreakpointResolverSP original_sp) override; + protected: void NotifyBreakpointSet() override; private: void CreateImplementationIfNeeded(lldb::BreakpointSP bkpt); + void CreateImplementationIfNeeded(Target &target, lldb::BreakpointSP bkpt); ScriptInterpreter *GetScriptInterpreter(); std::string m_class_name; @@ -74,6 +82,7 @@ class BreakpointResolverScripted : public BreakpointResolver { StructuredDataImpl m_args; Status m_error; lldb::ScriptedBreakpointInterfaceSP m_interface_sp; + bool m_breakpoint_sent = false; BreakpointResolverScripted(const BreakpointResolverScripted &) = delete; const BreakpointResolverScripted & diff --git a/lldb/include/lldb/Interpreter/Interfaces/ScriptedBreakpointInterface.h b/lldb/include/lldb/Interpreter/Interfaces/ScriptedBreakpointInterface.h index d6d2ee786788e..83cf93c997c24 100644 --- a/lldb/include/lldb/Interpreter/Interfaces/ScriptedBreakpointInterface.h +++ b/lldb/include/lldb/Interpreter/Interfaces/ScriptedBreakpointInterface.h @@ -11,9 +11,32 @@ #include "ScriptedInterface.h" #include "lldb/Symbol/SymbolContext.h" +#include "lldb/Target/Target.h" #include "lldb/lldb-private.h" namespace lldb_private { +class ScriptedBreakpointResolverOverride + : public Target::BreakpointResolverOverride { +public: + ScriptedBreakpointResolverOverride(Target &target, const std::string &description, + const std::string &class_name, StructuredDataImpl &args_data) + : Target::BreakpointResolverOverride(target, description), + m_args_data(args_data), m_class_name(class_name) {} + + BreakpointResolverOverride *CopyIntoNewTarget(Target &target) override { + return new ScriptedBreakpointResolverOverride(target, m_desc, m_class_name, + m_args_data); + } + + lldb::BreakpointResolverSP CheckForOverride(Target &target, + lldb::BreakpointResolverSP initial_sp) override; + +private: + StructuredDataImpl m_args_data; + std::string m_class_name; +}; + + class ScriptedBreakpointInterface : public ScriptedInterface { public: virtual llvm::Expected<StructuredData::GenericSP> @@ -36,6 +59,13 @@ class ScriptedBreakpointInterface : public ScriptedInterface { lldb::DescriptionLevel level) { return {}; } + + virtual void SetBreakpoint(lldb::BreakpointSP break_sp) {} + + virtual bool OverridesResolver(Target &target, StructuredDataImpl &original_resolver) { + return false; + } + }; } // namespace lldb_private diff --git a/lldb/include/lldb/Interpreter/ScriptInterpreter.h b/lldb/include/lldb/Interpreter/ScriptInterpreter.h index 0c37c119540f6..6c213ab179830 100644 --- a/lldb/include/lldb/Interpreter/ScriptInterpreter.h +++ b/lldb/include/lldb/Interpreter/ScriptInterpreter.h @@ -661,6 +661,9 @@ class ScriptInterpreter : public PluginInterface { lldb::ValueObjectSP GetOpaqueTypeFromSBValue(const lldb::SBValue &value) const; + lldb::TargetSP + GetOpaqueTypeFromSBTarget(const lldb::SBTarget &target) const; + protected: Debugger &m_debugger; lldb::ScriptLanguage m_script_lang; diff --git a/lldb/include/lldb/Target/Target.h b/lldb/include/lldb/Target/Target.h index 87b5c4f9591f1..9cb7fdccd5d24 100644 --- a/lldb/include/lldb/Target/Target.h +++ b/lldb/include/lldb/Target/Target.h @@ -39,6 +39,7 @@ #include "lldb/Utility/LLDBAssert.h" #include "lldb/Utility/RealpathPrefixes.h" #include "lldb/Utility/StructuredData.h" +#include "lldb/Utility/Stream.h" #include "lldb/Utility/Timeout.h" #include "lldb/lldb-public.h" #include "llvm/ADT/MapVector.h" @@ -997,7 +998,89 @@ class Target : public std::enable_shared_from_this<Target>, /// Resets the hit count of all breakpoints. void ResetBreakpointHitCounts(); + + // This callout implements the "Resolver Override". When we have determined + // the Resolver for a given breakpoint, we pass each of the registered + // overrides the "natural" resolver, and then we will use whatever resolver + // we get back from it if it is non-null. + // We keep a list of overrides ordered by ID - and we search through the list + // by ID order, and the first override that returns a non-null Resolver will + // be the one we use. If no overrides return an override resolver, we'll use + // the original one. + + // This is the abstract version of the override. Particular implementations + // e.g. the scripted + class BreakpointResolverOverride { + public: + BreakpointResolverOverride(Target &target, const std::string &description) + : m_target(target), m_desc(description) {} + + virtual BreakpointResolverOverride *CopyIntoNewTarget(Target &target) = 0; + + virtual ~BreakpointResolverOverride() {} + virtual lldb::BreakpointResolverSP CheckForOverride(Target &target, + lldb::BreakpointResolverSP initial_sp) { + return {}; + } + const std::string &GetDescription() { return m_desc; } + protected: + Target &m_target; + std::string m_desc; + }; + + uint64_t AddBreakpointResolverOverride(BreakpointResolverOverride *override) { + static uint64_t g_override_id = 1; + uint64_t id_used = g_override_id; + m_breakpoint_overrides.emplace(g_override_id, + std::unique_ptr<BreakpointResolverOverride>(override)); + g_override_id++; + return id_used; + } + + uint64_t AddBreakpointResolverOverride(llvm::StringRef class_name, + StructuredData::DictionarySP args_data_sp, llvm::StringRef description); + + + bool RemoveBreakpointResolverOverride(uint64_t override_id) { + size_t removed = m_breakpoint_overrides.erase(override_id); + return removed == 1; + } + + void ClearBreakpointResolverOverrides() { + m_breakpoint_overrides.clear(); + } + + lldb::BreakpointResolverSP CheckBreakpointOverrides(lldb::BreakpointResolverSP original_sp) + { + for (auto const &elem : m_breakpoint_overrides) { + lldb::BreakpointResolverSP overriden_sp; + overriden_sp = elem.second->CheckForOverride(*this, original_sp); + if (overriden_sp) + return overriden_sp; + } + return {}; + } + // Describe the + void DescribeBreakpointOverrides(Stream &stream, std::vector<uint64_t> idxs) { + if (m_breakpoint_overrides.size() == 0) { + stream << "No overrides.\n"; + return; + } + // FIXME: Is there some good way to flow the description? + stream << "ID Description\n"; + stream << "------ -----------\n"; + + auto begin = idxs.begin(); + auto end = idxs.end(); + bool empty = idxs.empty(); + for (auto const &elem : m_breakpoint_overrides) { + if (empty || std::find(begin, end, elem.first) != end) + stream.Format("{0,-6} {1}", elem.first, elem.second->GetDescription()); + else + stream.Format("{0,6} is not a breakpoint override index", elem.first); + } + } // The flag 'end_to_end', default to true, signifies that the operation is // performed end to end, for both the debugger and the debuggee. @@ -2019,6 +2102,9 @@ class Target : public std::enable_shared_from_this<Target>, using BreakpointNameList = std::map<ConstString, std::unique_ptr<BreakpointName>>; BreakpointNameList m_breakpoint_names; + + std::map<uint64_t, std::unique_ptr<BreakpointResolverOverride>> m_breakpoint_overrides; + lldb::BreakpointSP m_last_created_breakpoint; WatchpointList m_watchpoint_list; diff --git a/lldb/source/API/SBStructuredData.cpp b/lldb/source/API/SBStructuredData.cpp index 8e2c18ed42b47..971e079723ba4 100644 --- a/lldb/source/API/SBStructuredData.cpp +++ b/lldb/source/API/SBStructuredData.cpp @@ -77,6 +77,10 @@ operator=(const lldb::SBStructuredData &rhs) { 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); diff --git a/lldb/source/API/SBTarget.cpp b/lldb/source/API/SBTarget.cpp index a3b500f9011c3..8d34dc80a95ea 100644 --- a/lldb/source/API/SBTarget.cpp +++ b/lldb/source/API/SBTarget.cpp @@ -40,6 +40,7 @@ #include "lldb/Core/Section.h" #include "lldb/Core/StructuredDataImpl.h" #include "lldb/Host/Host.h" +#include "lldb/Interpreter/Interfaces/ScriptedBreakpointInterface.h" #include "lldb/Interpreter/Interfaces/ScriptedFrameProviderInterface.h" #include "lldb/Symbol/DeclVendor.h" #include "lldb/Symbol/ObjectFile.h" @@ -679,6 +680,28 @@ size_t SBTarget::ReadMemory(const SBAddress addr, void *buf, size_t size, return bytes_read; } +uint64_t SBTarget::AddBreakpointOverride(const char *class_name, + const char *description, SBStructuredData &args_data) { + if (TargetSP target_sp = GetSP()) { + StructuredDataImpl impl; + args_data.CopyImpl(impl); + ScriptedBreakpointResolverOverride *new_override + = new ScriptedBreakpointResolverOverride(*target_sp.get(), + std::string(description), std::string(class_name), impl); + return target_sp->AddBreakpointResolverOverride(new_override); + } + return 0; +} + +bool SBTarget::RemoveBreakpointOverride(uint64_t id) { + if (TargetSP target_sp = GetSP()) { + return target_sp->RemoveBreakpointResolverOverride(id); + } + return false; +} + + + SBBreakpoint SBTarget::BreakpointCreateByLocation(const char *file, uint32_t line) { LLDB_INSTRUMENT_VA(this, file, line); diff --git a/lldb/source/Breakpoint/BreakpointResolverScripted.cpp b/lldb/source/Breakpoint/BreakpointResolverScripted.cpp index 373bd74d24b67..8c324dac51a9c 100644 --- a/lldb/source/Breakpoint/BreakpointResolverScripted.cpp +++ b/lldb/source/Breakpoint/BreakpointResolverScripted.cpp @@ -30,13 +30,23 @@ BreakpointResolverScripted::BreakpointResolverScripted( lldb::SearchDepth depth, const StructuredDataImpl &args_data) : BreakpointResolver(bkpt, BreakpointResolver::PythonResolver), m_class_name(std::string(class_name)), m_depth(depth), m_args(args_data) { - CreateImplementationIfNeeded(bkpt); + if (bkpt) + CreateImplementationIfNeeded(bkpt); } void BreakpointResolverScripted::CreateImplementationIfNeeded( BreakpointSP breakpoint_sp) { - if (m_interface_sp) + // This version has to be called with a valid breakpoint_sp + // But the interface might have been made before we sent the breakpoint to + // the interface. If so, do that here: + assert(breakpoint_sp); + if (m_interface_sp) { + if (!m_breakpoint_sent) { + m_interface_sp->SetBreakpoint(breakpoint_sp); + m_breakpoint_sent = true; + } return; + } if (m_class_name.empty()) return; @@ -45,7 +55,21 @@ void BreakpointResolverScripted::CreateImplementationIfNeeded( return; TargetSP target_sp = breakpoint_sp->GetTargetSP(); - ScriptInterpreter *script_interp = target_sp->GetDebugger() + if (target_sp) + CreateImplementationIfNeeded(*target_sp.get(), breakpoint_sp); +} + +void BreakpointResolverScripted::CreateImplementationIfNeeded(Target &target, + BreakpointSP breakpoint_sp) { + if (m_interface_sp) { + if (!m_breakpoint_sent && breakpoint_sp) { + m_interface_sp->SetBreakpoint(breakpoint_sp); + m_breakpoint_sent = true; + } + return; + } + + ScriptInterpreter *script_interp = target.GetDebugger() .GetScriptInterpreter(); if (!script_interp) return; @@ -66,18 +90,34 @@ void BreakpointResolverScripted::CreateImplementationIfNeeded( m_interface_sp.reset(); m_error = Status::FromError(obj_or_err.takeError()); return; - } - + } StructuredData::ObjectSP object_sp = *obj_or_err; if (!object_sp || !object_sp->IsValid()) { m_error = Status::FromErrorStringWithFormat( "ScriptedBreakpoint::%s () - ERROR: %s", __FUNCTION__, "Failed to create valid script object"); } + if (breakpoint_sp) + m_breakpoint_sent = true; +} + +bool BreakpointResolverScripted::OverridesResolver(Target &target, + BreakpointResolverSP original_sp) { + // At this point neither resolver has been assigned a breakpoint, so pass + // in an empty one. + CreateImplementationIfNeeded(target, {}); + if (!m_interface_sp) + return false; + + StructuredData::ObjectSP serialized_sp = + original_sp->SerializeToStructuredData(); + StructuredDataImpl impl(serialized_sp); + return m_interface_sp->OverridesResolver(target, impl); } void BreakpointResolverScripted::NotifyBreakpointSet() { CreateImplementationIfNeeded(GetBreakpoint()); + } BreakpointResolverSP BreakpointResolverScripted::CreateFromStructuredData( diff --git a/lldb/source/Commands/CommandObjectBreakpoint.cpp b/lldb/source/Commands/CommandObjectBreakpoint.cpp index bb71055ebb3cb..080e6ce828151 100644 --- a/lldb/source/Commands/CommandObjectBreakpoint.cpp +++ b/lldb/source/Commands/CommandObjectBreakpoint.cpp @@ -3584,6 +3584,222 @@ class CommandObjectBreakpointWrite : public CommandObjectParsed { CommandOptions m_options; }; +#pragma mark override add +#define LLDB_OPTIONS_breakpoint_override_add +#include "CommandOptions.inc" + +class CommandObjectBreakpointOverrideAdd : public CommandObjectParsed { +public: + CommandObjectBreakpointOverrideAdd(CommandInterpreter &interpreter) + : CommandObjectParsed( + interpreter, "breakpoint override add", + "Add a scripted breakpoint override resolver.", nullptr), + m_python_class_options("breakpoint override resolver", true, 'P') { + // We're picking up all the normal options, commands and disable. + m_all_options.Append(&m_python_class_options, + LLDB_OPT_SET_1 | LLDB_OPT_SET_2, LLDB_OPT_SET_1); + m_all_options.Append(&m_dummy_options, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1); + m_all_options.Append(&m_options, llvm::ArrayRef<llvm::StringRef>()); + m_all_options.Finalize(); + } + + ~CommandObjectBreakpointOverrideAdd() override = default; + + class CommandOptions : public OptionGroup { + public: + CommandOptions() = default; + + ~CommandOptions() override = default; + + Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg, + ExecutionContext *execution_context) override { + Status error; + const int short_option = GetDefinitions()[option_idx].short_option; + + switch (short_option) { + case 'd': + m_description.assign(std::string(option_arg)); + break; + default: + llvm_unreachable("Unimplemented option"); + } + + return error; + } + + void OptionParsingStarting(ExecutionContext *execution_context) override { + m_description.clear(); + } + + llvm::ArrayRef<OptionDefinition> GetDefinitions() override { + return llvm::ArrayRef(g_breakpoint_override_add_options); + } + + // Instance variables to hold the values for command options. + + std::string m_description; + }; + Options *GetOptions() override { return &m_all_options; } + +protected: + void DoExecute(Args &command, CommandReturnObject &result) override { + Target &target = + m_dummy_options.m_use_dummy ? GetDummyTarget() : GetTarget(); + uint64_t id = target.AddBreakpointResolverOverride( + m_python_class_options.GetName(), + m_python_class_options.GetStructuredData(), m_options.m_description); + result.AppendMessageWithFormatv("{0}", id); + result.SetStatus(eReturnStatusSuccessFinishResult); + } + +private: + BreakpointDummyOptionGroup m_dummy_options; + OptionGroupPythonClassWithDict m_python_class_options; + CommandOptions m_options; + OptionGroupOptions m_all_options; +}; + +class CommandObjectBreakpointOverrideDelete : public CommandObjectParsed { +public: + CommandObjectBreakpointOverrideDelete(CommandInterpreter &interpreter) + : CommandObjectParsed( + interpreter, "breakpoint override delete", + "Add a scripted breakpoint override resolver.", nullptr) { + AddSimpleArgumentList(eArgTypeIndex, eArgRepeatOptional); + m_all_options.Append(&m_dummy_options, LLDB_OPT_SET_1, LLDB_OPT_SET_1); + m_all_options.Finalize(); + } + + ~CommandObjectBreakpointOverrideDelete() override = default; + +protected: + void DoExecute(Args &command, CommandReturnObject &result) override { + Target &target = + m_dummy_options.m_use_dummy ? GetDummyTarget() : GetTarget(); + + const size_t argc = command.GetArgumentCount(); + if (argc == 0) { + if(m_interpreter.Confirm("Delete all breakpoint overrides?", false)) { + target.ClearBreakpointResolverOverrides(); + } + result.SetStatus(eReturnStatusSuccessFinishNoResult); + return; + } + + for (auto &entry : command.entries()) { + uint64_t id; + bool success; + if (!entry.ref().getAsInteger(0, id)) + success = target.RemoveBreakpointResolverOverride(id); + else { + result.AppendErrorWithFormatv("Index not an integer: {0}", entry.ref()); + result.SetStatus(eReturnStatusFailed); + return; + } + if (!success) { + result.AppendErrorWithFormatv("Cannot delete override: {0}", id); + result.SetStatus(eReturnStatusFailed); + return; + } + } + result.SetStatus(eReturnStatusSuccessFinishNoResult); + } + +private: + BreakpointDummyOptionGroup m_dummy_options; + OptionGroupOptions m_all_options; +}; + +class CommandObjectBreakpointOverrideList : public CommandObjectParsed { +public: + CommandObjectBreakpointOverrideList(CommandInterpreter &interpreter) + : CommandObjectParsed( + interpreter, "breakpoint override list", + "List the current scripted breakpoint override resolvers.", + nullptr) { + AddSimpleArgumentList(eArgTypeIndex, eArgRepeatOptional); + m_all_options.Append(&m_dummy_options, LLDB_OPT_SET_1, LLDB_OPT_SET_1); + m_all_options.Finalize(); + } + + ~CommandObjectBreakpointOverrideList() override = default; + +protected: + void DoExecute(Args &command, CommandReturnObject &result) override { + Target &target = + m_dummy_options.m_use_dummy ? GetDummyTarget() : GetTarget(); + + const size_t argc = command.GetArgumentCount(); + std::vector<uint64_t> idxs; + if (argc != 0) { + for (auto &entry : command.entries()) { + uint64_t id; + bool success; + if (entry.ref().getAsInteger(0, id)) + idxs.push_back(id); + else { + result.AppendErrorWithFormatv("Index not an integer: {0}", entry.ref()); + result.SetStatus(eReturnStatusFailed); + return; + } + } + } + target.DescribeBreakpointOverrides(result.GetOutputStream(), idxs); + result.SetStatus(eReturnStatusSuccessFinishNoResult); + } + +private: + BreakpointDummyOptionGroup m_dummy_options; + OptionGroupOptions m_all_options; +}; +class CommandObjectBreakpointOverride : public CommandObjectMultiword { +public: + CommandObjectBreakpointOverride(CommandInterpreter &interpreter) + : CommandObjectMultiword( + interpreter, "override", "Commands to manage breakpoint override resolvers") { + + + SetHelpLong( + R"( +Breakpoint override resolvers allow you to intercept breakpoint requests and +re-implement them using a custom breakpoint resolver. Override resolvers are +implemented by a scripted breakpoint resolver that implements the +'overrides_resolver' interface. It takes an SBStructuredData with the +serialized form of the original breakpoint resolver. If it returns true, then +the provided resolver will be substituted for the one lldb would have produced +by default. + +Add new override resolvers using: + + (lldb) breakpoint override add -c class_name + +This returns the ID of the resolver you added. + +List the currently added override resolvers using: + + (lldb) breakpoint override list + +Delete an added resolver using: + + (lldb) breakpoint override delete <id> + +)"); + CommandObjectSP add_command_object( + new CommandObjectBreakpointOverrideAdd(interpreter)); + CommandObjectSP delete_command_object( + new CommandObjectBreakpointOverrideDelete(interpreter)); + CommandObjectSP list_command_object( + new CommandObjectBreakpointOverrideList(interpreter)); + + LoadSubCommand("add", add_command_object); + LoadSubCommand("delete", delete_command_object); + LoadSubCommand("list", list_command_object); + } + + ~CommandObjectBreakpointOverride() override = default; +}; + + // CommandObjectMultiwordBreakpoint #pragma mark MultiwordBreakpoint @@ -3617,6 +3833,8 @@ CommandObjectMultiwordBreakpoint::CommandObjectMultiwordBreakpoint( new CommandObjectBreakpointWrite(interpreter)); CommandObjectSP read_command_object( new CommandObjectBreakpointRead(interpreter)); + CommandObjectSP override_command_object( + new CommandObjectBreakpointOverride(interpreter)); list_command_object->SetCommandName("breakpoint list"); enable_command_object->SetCommandName("breakpoint enable"); @@ -3630,6 +3848,7 @@ CommandObjectMultiwordBreakpoint::CommandObjectMultiwordBreakpoint( name_command_object->SetCommandName("breakpoint name"); write_command_object->SetCommandName("breakpoint write"); read_command_object->SetCommandName("breakpoint read"); + override_command_object->SetCommandName("breakpoint override"); LoadSubCommand("list", list_command_object); LoadSubCommand("enable", enable_command_object); @@ -3643,6 +3862,7 @@ CommandObjectMultiwordBreakpoint::CommandObjectMultiwordBreakpoint( LoadSubCommand("name", name_command_object); LoadSubCommand("write", write_command_object); LoadSubCommand("read", read_command_object); + LoadSubCommand("override", override_command_object); } CommandObjectMultiwordBreakpoint::~CommandObjectMultiwordBreakpoint() = default; diff --git a/lldb/source/Commands/Options.td b/lldb/source/Commands/Options.td index 12e06d4f8b2ad..d2147ef5e54f7 100644 --- a/lldb/source/Commands/Options.td +++ b/lldb/source/Commands/Options.td @@ -482,6 +482,10 @@ let Command = "breakpoint add scripted" in { "repeat this option multiple times to specify multiple shared libraries.">; } +let Command = "breakpoint override add" in { + def breakpoint_override_add_description : Option<"description", "d">, + Desc<"Description string for this override resolver">, Arg<"HelpText">; +} let Command = "breakpoint clear" in { def breakpoint_clear_file : Option<"file", "f">, diff --git a/lldb/source/Interpreter/Interfaces/CMakeLists.txt b/lldb/source/Interpreter/Interfaces/CMakeLists.txt index 14fcc71fd9a71..93418bb4897bc 100644 --- a/lldb/source/Interpreter/Interfaces/CMakeLists.txt +++ b/lldb/source/Interpreter/Interfaces/CMakeLists.txt @@ -1,5 +1,6 @@ add_lldb_library(lldbInterpreterInterfaces NO_PLUGIN_DEPENDENCIES ScriptedInterfaceUsages.cpp + ScriptedBreakpointInterface.cpp ADDITIONAL_HEADER_DIRS ${LLDB_INCLUDE_DIR}/lldb/Interpreter/Interfaces diff --git a/lldb/source/Interpreter/Interfaces/ScriptedBreakpointInterface.cpp b/lldb/source/Interpreter/Interfaces/ScriptedBreakpointInterface.cpp new file mode 100644 index 0000000000000..5afc6af8a1e1e --- /dev/null +++ b/lldb/source/Interpreter/Interfaces/ScriptedBreakpointInterface.cpp @@ -0,0 +1,23 @@ +//===----------------------------------------------------------------------===// +// +// 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/Interpreter/Interfaces/ScriptedBreakpointInterface.h" +#include "lldb/Breakpoint/Breakpoint.h" +#include "lldb/Breakpoint/BreakpointResolverScripted.h" + +namespace lldb_private { +lldb::BreakpointResolverSP ScriptedBreakpointResolverOverride::CheckForOverride( + Target &target, lldb::BreakpointResolverSP initial_sp) { + lldb::BreakpointResolverSP candidate_sp(new BreakpointResolverScripted( + {}, m_class_name, initial_sp->GetDepth(), + m_args_data)); + if (candidate_sp->OverridesResolver(target, initial_sp)) + return candidate_sp; + return {}; +} +} diff --git a/lldb/source/Interpreter/ScriptInterpreter.cpp b/lldb/source/Interpreter/ScriptInterpreter.cpp index b00f4db528ce3..c97ab55141ca3 100644 --- a/lldb/source/Interpreter/ScriptInterpreter.cpp +++ b/lldb/source/Interpreter/ScriptInterpreter.cpp @@ -163,6 +163,11 @@ lldb::StackFrameListSP ScriptInterpreter::GetOpaqueTypeFromSBFrameList( return frame_list.m_opaque_sp; } +lldb::TargetSP ScriptInterpreter::GetOpaqueTypeFromSBTarget( + const lldb::SBTarget &target) const { + return target.m_opaque_sp; +} + lldb::ValueObjectSP ScriptInterpreter::GetOpaqueTypeFromSBValue(const lldb::SBValue &value) const { if (!value.m_opaque_sp) diff --git a/lldb/source/Plugins/ScriptInterpreter/Python/Interfaces/ScriptedBreakpointPythonInterface.cpp b/lldb/source/Plugins/ScriptInterpreter/Python/Interfaces/ScriptedBreakpointPythonInterface.cpp index 71e5585f7b8df..0dc98f842a9b5 100644 --- a/lldb/source/Plugins/ScriptInterpreter/Python/Interfaces/ScriptedBreakpointPythonInterface.cpp +++ b/lldb/source/Plugins/ScriptInterpreter/Python/Interfaces/ScriptedBreakpointPythonInterface.cpp @@ -6,6 +6,8 @@ // //===----------------------------------------------------------------------===// +#include "lldb/Breakpoint/Breakpoint.h" +#include "lldb/Breakpoint/BreakpointResolverScripted.h" #include "lldb/Core/PluginManager.h" #include "lldb/Symbol/SymbolContext.h" #include "lldb/Target/ExecutionContext.h" @@ -35,6 +37,35 @@ ScriptedBreakpointPythonInterface::CreatePluginObject( break_sp, args_sp); } +bool ScriptedBreakpointPythonInterface::OverridesResolver(Target &target, + StructuredDataImpl &resolver_data) { + Status error; + + TargetSP target_sp = target.shared_from_this(); + + StructuredData::ObjectSP obj = Dispatch("overrides_resolver", error, + target_sp, resolver_data); + + if (!ScriptedInterface::CheckStructuredDataObject(LLVM_PRETTY_FUNCTION, obj, + error)) { + Log *log = GetLog(LLDBLog::Script); + LLDB_LOG(log, "Error calling overrides_resolver method: {1}", error); + return false; + } + return obj->GetBooleanValue(); +} + +void ScriptedBreakpointPythonInterface::SetBreakpoint(lldb::BreakpointSP break_sp) +{ + Status error; + StructuredData::ObjectSP obj = Dispatch("set_breakpoint", error, break_sp); + if (!ScriptedInterface::CheckStructuredDataObject(LLVM_PRETTY_FUNCTION, obj, + error)) { + Log *log = GetLog(LLDBLog::Script); + LLDB_LOG(log, "Error calling set_breakpoint method: {1}", error); + } +} + bool ScriptedBreakpointPythonInterface::ResolverCallback( SymbolContext sym_ctx) { Status error; diff --git a/lldb/source/Plugins/ScriptInterpreter/Python/Interfaces/ScriptedBreakpointPythonInterface.h b/lldb/source/Plugins/ScriptInterpreter/Python/Interfaces/ScriptedBreakpointPythonInterface.h index 34e63792fb257..edeeec7ba4e73 100644 --- a/lldb/source/Plugins/ScriptInterpreter/Python/Interfaces/ScriptedBreakpointPythonInterface.h +++ b/lldb/source/Plugins/ScriptInterpreter/Python/Interfaces/ScriptedBreakpointPythonInterface.h @@ -13,8 +13,8 @@ #include "lldb/Interpreter/Interfaces/ScriptedBreakpointInterface.h" #include "ScriptedPythonInterface.h" - namespace lldb_private { + class ScriptedBreakpointPythonInterface : public ScriptedBreakpointInterface, public ScriptedPythonInterface, public PluginInterface { @@ -30,6 +30,9 @@ class ScriptedBreakpointPythonInterface : public ScriptedBreakpointInterface, return llvm::SmallVector<AbstractMethodRequirement>({{"__callback__", 2}}); } + bool OverridesResolver(Target &target, StructuredDataImpl &resolver_data) override; + void SetBreakpoint(lldb::BreakpointSP break_sp) override; + bool ResolverCallback(SymbolContext sym_ctx) override; lldb::SearchDepth GetDepth() override; std::optional<std::string> GetShortHelp() override; diff --git a/lldb/source/Plugins/ScriptInterpreter/Python/Interfaces/ScriptedPythonInterface.cpp b/lldb/source/Plugins/ScriptInterpreter/Python/Interfaces/ScriptedPythonInterface.cpp index 68aea7d223f7b..6243f103c547d 100644 --- a/lldb/source/Plugins/ScriptInterpreter/Python/Interfaces/ScriptedPythonInterface.cpp +++ b/lldb/source/Plugins/ScriptInterpreter/Python/Interfaces/ScriptedPythonInterface.cpp @@ -287,6 +287,21 @@ ScriptedPythonInterface::ExtractValueFromPythonObject<lldb::ValueObjectSP>( return m_interpreter.GetOpaqueTypeFromSBValue(*sb_value); } +template <> +lldb::TargetSP +ScriptedPythonInterface::ExtractValueFromPythonObject<lldb::TargetSP>( + python::PythonObject &p, Status &error) { + lldb::SBTarget *sb_target = reinterpret_cast<lldb::SBTarget *>( + python::LLDBSWIGPython_CastPyObjectToSBTarget(p.get())); + if (!sb_target) { + error = Status::FromErrorStringWithFormat( + "couldn't cast lldb::SBTarget to lldb::TargetSP"); + return {}; + } + + return m_interpreter.GetOpaqueTypeFromSBTarget(*sb_target); +} + template <> lldb::ValueObjectListSP ScriptedPythonInterface::ExtractValueFromPythonObject<lldb::ValueObjectListSP>( diff --git a/lldb/source/Plugins/ScriptInterpreter/Python/Interfaces/ScriptedPythonInterface.h b/lldb/source/Plugins/ScriptInterpreter/Python/Interfaces/ScriptedPythonInterface.h index 37597d059ca90..54f4843485651 100644 --- a/lldb/source/Plugins/ScriptInterpreter/Python/Interfaces/ScriptedPythonInterface.h +++ b/lldb/source/Plugins/ScriptInterpreter/Python/Interfaces/ScriptedPythonInterface.h @@ -654,7 +654,7 @@ class ScriptedPythonInterface : virtual public ScriptedInterface { python::PythonObject Transform(lldb::ValueObjectSP arg) { return python::SWIGBridge::ToSWIGWrapper(arg); } - + template <typename T, typename U> void ReverseTransform(T &original_arg, U transformed_arg, Status &error) { // If U is not a PythonObject, don't touch it! @@ -818,6 +818,11 @@ lldb::ValueObjectSP ScriptedPythonInterface::ExtractValueFromPythonObject<lldb::ValueObjectSP>( python::PythonObject &p, Status &error); +template <> +lldb::TargetSP +ScriptedPythonInterface::ExtractValueFromPythonObject<lldb::TargetSP>( + python::PythonObject &p, Status &error); + template <> lldb::ValueObjectListSP ScriptedPythonInterface::ExtractValueFromPythonObject<lldb::ValueObjectListSP>( diff --git a/lldb/source/Plugins/ScriptInterpreter/Python/SWIGPythonBridge.h b/lldb/source/Plugins/ScriptInterpreter/Python/SWIGPythonBridge.h index 16ad895ee9f26..f69ac10c9d445 100644 --- a/lldb/source/Plugins/ScriptInterpreter/Python/SWIGPythonBridge.h +++ b/lldb/source/Plugins/ScriptInterpreter/Python/SWIGPythonBridge.h @@ -269,6 +269,7 @@ void *LLDBSWIGPython_CastPyObjectToSBValueList(PyObject *data); void *LLDBSWIGPython_CastPyObjectToSBMemoryRegionInfo(PyObject *data); void *LLDBSWIGPython_CastPyObjectToSBExecutionContext(PyObject *data); void *LLDBSWIGPython_CastPyObjectToSBFrameList(PyObject *data); +void *LLDBSWIGPython_CastPyObjectToSBTarget(PyObject *data); } // namespace python } // namespace lldb_private diff --git a/lldb/source/Target/Target.cpp b/lldb/source/Target/Target.cpp index e2bae8fae1a26..ba7a597af2364 100644 --- a/lldb/source/Target/Target.cpp +++ b/lldb/source/Target/Target.cpp @@ -238,6 +238,10 @@ void Target::PrimeFromDummyTarget(Target &target) { for (const auto &bp_name_entry : target.m_breakpoint_names) { AddBreakpointName(std::make_unique<BreakpointName>(*bp_name_entry.second)); } + + for (auto const &elem : target.m_breakpoint_overrides) { + AddBreakpointResolverOverride(elem.second->CopyIntoNewTarget(*this)); + } m_frame_recognizer_manager_up = std::make_unique<StackFrameRecognizerManager>( *target.m_frame_recognizer_manager_up); @@ -798,6 +802,14 @@ BreakpointSP Target::CreateBreakpoint(SearchFilterSP &filter_sp, bool resolve_indirect_symbols) { BreakpointSP bp_sp; if (filter_sp && resolver_sp) { + // Now check whether there are any "Breakpoint Overrides" registered, and + // if there are see if one of them want to handle this request instead. + // But we don't allow overrides for internal breakpoints: + if (!internal) { + BreakpointResolverSP overridden_sp = CheckBreakpointOverrides(resolver_sp); + if (overridden_sp) + resolver_sp = overridden_sp; + } const bool hardware = request_hardware || GetRequireHardwareBreakpoints(); bp_sp.reset(new Breakpoint(*this, filter_sp, resolver_sp, hardware, resolve_indirect_symbols)); @@ -931,6 +943,18 @@ void Target::GetBreakpointNames(std::vector<std::string> &names) { llvm::sort(names); } +uint64_t Target::AddBreakpointResolverOverride(llvm::StringRef class_name, + StructuredData::DictionarySP args_data_sp, llvm::StringRef description) { + StructuredDataImpl impl; + impl.SetObjectSP(args_data_sp); + + ScriptedBreakpointResolverOverride *new_override + = new ScriptedBreakpointResolverOverride(*this, + std::string(description), std::string(class_name), impl); + return AddBreakpointResolverOverride(new_override); +} + + bool Target::ProcessIsValid() { return (m_process_sp && m_process_sp->IsAlive()); } diff --git a/lldb/test/API/functionalities/breakpoint/scripted_bkpt/overrides_resolver/Makefile b/lldb/test/API/functionalities/breakpoint/scripted_bkpt/overrides_resolver/Makefile new file mode 100644 index 0000000000000..695335e068c0c --- /dev/null +++ b/lldb/test/API/functionalities/breakpoint/scripted_bkpt/overrides_resolver/Makefile @@ -0,0 +1,4 @@ +C_SOURCES := main.c +CFLAGS_EXTRAS := -std=c99 + +include Makefile.rules diff --git a/lldb/test/API/functionalities/breakpoint/scripted_bkpt/overrides_resolver/TestOverridesResolver.py b/lldb/test/API/functionalities/breakpoint/scripted_bkpt/overrides_resolver/TestOverridesResolver.py new file mode 100644 index 0000000000000..2625b97952b71 --- /dev/null +++ b/lldb/test/API/functionalities/breakpoint/scripted_bkpt/overrides_resolver/TestOverridesResolver.py @@ -0,0 +1,124 @@ +""" +Test the OverridesResolver feature of scripted breakpoints +""" + +import os +import lldb +import lldbsuite.test.lldbutil as lldbutil +from lldbsuite.test.decorators import * +from lldbsuite.test.lldbtest import * + + +class TestOverridesResolver(TestBase): + NO_DEBUG_INFO_TESTCASE = True + + @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24528") + def test_overrides_resolver_resolver_python(self): + """Use facade breakpoints to emulate hitting some locations""" + self.build() + self.do_test(True) + + def test_overrides_resolver_resolver_cmd(self): + """Use facade breakpoints to emulate hitting some locations""" + self.build() + self.do_test(True) + + def make_target_and_import(self): + target = lldbutil.run_to_breakpoint_make_target(self) + self.import_resolver_script() + return target + + def import_resolver_script(self): + interp = self.dbg.GetCommandInterpreter() + error = lldb.SBError() + + script_name = os.path.join(self.getSourceDir(), "bkpt_resolver.py") + + command = "command script import " + script_name + self.runCmd(command) + + def do_test(self, use_cmd): + """This reads in a python file and sets a breakpoint using it.""" + alternate_location = "stop_here_instead" + target = self.make_target_and_import() + help_text = "SOME HELP TEXT" + class_name = "bkpt_resolver.OverrideExample" + key = "symbol" + value = "stop_here_instead" + + if use_cmd: + result = lldb.SBCommandReturnObject() + self.ci.HandleCommand( + f"breakpoint override add -P {class_name} -k {key} -v {value} -d '{help_text}'", + result + ) + self.assertCommandReturn(result, "breakpoint override worked") + override_id = int(result.GetOutput()) + else: + extra_args = lldb.SBStructuredData() + json_str = '{"' + key + '":"' + value + '"}' + extra_args.SetFromJSON(json_str) + override_id = target.AddBreakpointOverride( + class_name, + help_text, + extra_args + ) + + # Check the override listing, make sure our new entry is present: + self.expect("breakpoint override list", substrs=[str(override_id), help_text]) + + # Now make a breakpoint by file and line: + # FIXME: Use source_line to find this line number: + bkpt = target.BreakpointCreateByLocation( + "main.c", + line_number("main.c", "I am in the stop symbol") + ) + self.assertEqual(bkpt.GetNumLocations(), 1, "We make one location") + # Now continue and we'll hit this breakpoint but not in the + # right place: + (target, process, thread, bkpt) = lldbutil.run_to_breakpoint_do_run( + self, target, bkpt + ) + # This location should be bkpt_no.1: + self.assertEqual( + thread.stop_reason_data[0], bkpt.GetID(), "Hit the right breakpoint" + ) + self.assertEqual(thread.stop_reason_data[1], 1, "First location hit is 1") + func_name = thread.frames[0].name + self.assertEqual( + func_name, + alternate_location, + "Stopped at overridden location") + + # Now set a source name breakpoint, that should not get overridden, and + # when we continue we should hit it: + name_bkpt = target.BreakpointCreateByName("change_him") + self.assertGreater(name_bkpt.GetNumLocations(), 0, "Found locations") + threads = lldbutil.continue_to_breakpoint(process, name_bkpt) + self.assertEqual(len(threads), 1, "Hit our name breakpoint") + func_name = threads[0].frames[0].name + self.assertEqual(func_name, "change_him", "Stopped in the right place") + + # Now delete the override and make sure we hit newly set + # source breakpoints: + if use_cmd: + self.runCmd(f"breakpoint override delete {override_id}") + else: + self.assertTrue( + target.DeleteBreakpointOverride(override_id), + "Delete the right one" + ) + + # FIXME use source_line: + new_bkpt = target.BreakpointCreateByLocation( + "main.c", + line_number("main.c", "return 0") + ) + self.assertEqual(new_bkpt.num_locations, 1, "Made breakpoint") + threads = lldbutil.continue_to_breakpoint(process, new_bkpt) + self.assertEqual(len(threads), 1, "Hit our new breakpoint") + func_name = threads[0].frames[0].name + self.assertEqual(func_name, "main", "Stopped in unchanged location") + + + diff --git a/lldb/test/API/functionalities/breakpoint/scripted_bkpt/overrides_resolver/bkpt_resolver.py b/lldb/test/API/functionalities/breakpoint/scripted_bkpt/overrides_resolver/bkpt_resolver.py new file mode 100644 index 0000000000000..7977a97a38564 --- /dev/null +++ b/lldb/test/API/functionalities/breakpoint/scripted_bkpt/overrides_resolver/bkpt_resolver.py @@ -0,0 +1,38 @@ +import lldb + + +class OverrideExample: + def __init__(self, bkpt: lldb.SBBreakpoint, extra_args : lldb.SBStructuredData, dict): + self.bkpt = bkpt + self.extra_args = extra_args + self.set_bkpt = False + symbol_value = extra_args.GetValueForKey("symbol") + self.alternate_loc = symbol_value.GetStringValue(1000) + + def __callback__(self, sym_ctx : lldb.SBSymbolContext): + """This callback only sets a breakpoint in one place, + no matter what file and line you ask for""" + if self.set_bkpt == True: + return + # FIXME: Do this better... + alternate_sym_list = sym_ctx.module.FindFunctions(self.alternate_loc) + if len(alternate_sym_list.symbols) == 0: + return + alternate_sym = alternate_sym_list.symbols[0] + start_addr = alternate_sym.addr + self.bkpt.AddLocation(start_addr) + self.set_bkpt = True + + def get_short_help(self): + return f"I am an override resolver, resolving to {self.alternate_loc}." + + def set_breakpoint(self, bkpt: lldb.SBBreakpoint): + self.bkpt = bkpt + + def overrides_resolver(self, target: lldb.SBTarget, initial_resolver: lldb.SBStructuredData): + strm = lldb.SBStream() + initial_resolver.GetAsJSON(strm) + type = initial_resolver.GetValueForKey("Type").GetStringValue(1000) + if type == "FileAndLine": + return True + return False diff --git a/lldb/test/API/functionalities/breakpoint/scripted_bkpt/overrides_resolver/main.c b/lldb/test/API/functionalities/breakpoint/scripted_bkpt/overrides_resolver/main.c new file mode 100644 index 0000000000000..8a081bda83d14 --- /dev/null +++ b/lldb/test/API/functionalities/breakpoint/scripted_bkpt/overrides_resolver/main.c @@ -0,0 +1,22 @@ +#include <stdio.h> + +int g_change_me = 0; + +int change_him() { return ++g_change_me; } + +void stop_here_instead() { + printf("Stopped here instead?\n"); +} + +int stop_symbol() { + static int s_cnt = 0; + printf("I am in the stop symbol: %d\n", s_cnt++); + stop_here_instead(); + return s_cnt; +} + +int main() { + stop_symbol(); + change_him(); + return 0; +} diff --git a/lldb/unittests/ScriptInterpreter/Python/PythonTestSuite.cpp b/lldb/unittests/ScriptInterpreter/Python/PythonTestSuite.cpp index 5694aeeff3e5b..1ed6bee384a84 100644 --- a/lldb/unittests/ScriptInterpreter/Python/PythonTestSuite.cpp +++ b/lldb/unittests/ScriptInterpreter/Python/PythonTestSuite.cpp @@ -171,6 +171,11 @@ lldb_private::python::LLDBSWIGPython_CastPyObjectToSBFrameList(PyObject *data) { return nullptr; } +void * +lldb_private::python::LLDBSWIGPython_CastPyObjectToSBTarget(PyObject *data) { + return nullptr; +} + lldb::ValueObjectSP lldb_private::python::SWIGBridge::LLDBSWIGPython_GetValueObjectSPFromSBValue( void *data) { >From 78aa17fae181b7d8b67de9a420c1de693afdb34d Mon Sep 17 00:00:00 2001 From: Jim Ingham <[email protected]> Date: Fri, 1 May 2026 17:45:45 -0700 Subject: [PATCH 2/3] Formatting --- lldb/ScriptedBreakpointInterface.cpp | 10 ++-- lldb/include/lldb/API/SBStructuredData.h | 2 +- lldb/include/lldb/API/SBTarget.h | 7 +-- .../lldb/Breakpoint/BreakpointResolver.h | 9 ++-- .../Breakpoint/BreakpointResolverScripted.h | 10 ++-- .../Interfaces/ScriptedBreakpointInterface.h | 26 +++++----- .../lldb/Interpreter/ScriptInterpreter.h | 3 +- lldb/include/lldb/Target/Target.h | 50 +++++++++---------- lldb/source/API/SBTarget.cpp | 16 +++--- .../Breakpoint/BreakpointResolverScripted.cpp | 21 ++++---- .../Commands/CommandObjectBreakpoint.cpp | 36 ++++++------- .../ScriptedBreakpointInterface.cpp | 7 ++- .../ScriptedBreakpointPythonInterface.cpp | 18 +++---- .../ScriptedBreakpointPythonInterface.h | 3 +- .../Interfaces/ScriptedPythonInterface.h | 2 +- lldb/source/Target/Target.cpp | 20 ++++---- .../TestOverridesResolver.py | 25 +++------- .../overrides_resolver/bkpt_resolver.py | 14 ++++-- .../scripted_bkpt/overrides_resolver/main.c | 4 +- 19 files changed, 140 insertions(+), 143 deletions(-) diff --git a/lldb/ScriptedBreakpointInterface.cpp b/lldb/ScriptedBreakpointInterface.cpp index 66c482b69af9a..71ff2989ec088 100644 --- a/lldb/ScriptedBreakpointInterface.cpp +++ b/lldb/ScriptedBreakpointInterface.cpp @@ -12,12 +12,12 @@ namespace lldb_private { lldb::BreakpointResolverSP ScriptedBreakpointResolverOverride::CheckForOverride( - lldb::BreakpointResolverSP initial_sp) { - lldb::BreakpointResolverSP candidate_sp(new BreakpointResolverScripted( - initial_sp->GetBreakpoint(), m_class_name, initial_sp->GetDepth(), - m_args_data)); + lldb::BreakpointResolverSP initial_sp) { + lldb::BreakpointResolverSP candidate_sp( + new BreakpointResolverScripted(initial_sp->GetBreakpoint(), m_class_name, + initial_sp->GetDepth(), m_args_data)); if (candidate_sp->OverridesResolver(initial_sp)) return candidate_sp; return {}; } -} +} // namespace lldb_private diff --git a/lldb/include/lldb/API/SBStructuredData.h b/lldb/include/lldb/API/SBStructuredData.h index d7f2a539210af..0e3a3150fddc1 100644 --- a/lldb/include/lldb/API/SBStructuredData.h +++ b/lldb/include/lldb/API/SBStructuredData.h @@ -137,7 +137,7 @@ class SBStructuredData { /// Change the type to generic and overwrite the previous data with the new /// value. void SetGenericValue(SBScriptObject value); - + #ifndef SWIG void CopyImpl(lldb_private::StructuredDataImpl &new_impl); #endif diff --git a/lldb/include/lldb/API/SBTarget.h b/lldb/include/lldb/API/SBTarget.h index e859e04f72489..cc3a39adee4ac 100644 --- a/lldb/include/lldb/API/SBTarget.h +++ b/lldb/include/lldb/API/SBTarget.h @@ -637,10 +637,11 @@ class LLDB_API SBTarget { /// The amount of data read in host bytes. size_t ReadMemory(const SBAddress addr, void *buf, size_t size, lldb::SBError &error); - + uint64_t AddBreakpointOverride(const char *class_name, - const char *description, SBStructuredData &args_data); - + const char *description, + SBStructuredData &args_data); + bool RemoveBreakpointOverride(uint64_t id); lldb::SBBreakpoint BreakpointCreateByLocation(const char *file, diff --git a/lldb/include/lldb/Breakpoint/BreakpointResolver.h b/lldb/include/lldb/Breakpoint/BreakpointResolver.h index df94086c76122..064e370d08a40 100644 --- a/lldb/include/lldb/Breakpoint/BreakpointResolver.h +++ b/lldb/include/lldb/Breakpoint/BreakpointResolver.h @@ -112,13 +112,14 @@ class BreakpointResolver : public Searcher { virtual StructuredData::ObjectSP SerializeToStructuredData() { return StructuredData::ObjectSP(); } - - /// The resolver_sp won't have had its breakpoint set by the time we are + + /// The resolver_sp won't have had its breakpoint set by the time we are /// checking the Override, but it might need to access the Target, so we pass /// that in here. - virtual bool OverridesResolver(Target &target, lldb::BreakpointResolverSP resolver_sp) { + virtual bool OverridesResolver(Target &target, + lldb::BreakpointResolverSP resolver_sp) { return false; - } + } static const char *GetSerializationKey() { return "BKPTResolver"; } diff --git a/lldb/include/lldb/Breakpoint/BreakpointResolverScripted.h b/lldb/include/lldb/Breakpoint/BreakpointResolverScripted.h index ed931316cfc46..739eaabf4ad29 100644 --- a/lldb/include/lldb/Breakpoint/BreakpointResolverScripted.h +++ b/lldb/include/lldb/Breakpoint/BreakpointResolverScripted.h @@ -62,14 +62,14 @@ class BreakpointResolverScripted : public BreakpointResolver { lldb::BreakpointResolverSP CopyForBreakpoint(lldb::BreakpointSP &breakpoint) override; - + // OverridesResolver will get called before this resolver has been assigned a - // breakpoint. You should only need to see the resolver to know whether you + // breakpoint. You should only need to see the resolver to know whether you // want to override it, but you may need to check something about the target, // which you would normally get to from the breakpoint, so we pass it in here. - bool OverridesResolver(Target &target, - lldb::BreakpointResolverSP original_sp) override; - + bool OverridesResolver(Target &target, + lldb::BreakpointResolverSP original_sp) override; + protected: void NotifyBreakpointSet() override; private: diff --git a/lldb/include/lldb/Interpreter/Interfaces/ScriptedBreakpointInterface.h b/lldb/include/lldb/Interpreter/Interfaces/ScriptedBreakpointInterface.h index 83cf93c997c24..ba4875609ca14 100644 --- a/lldb/include/lldb/Interpreter/Interfaces/ScriptedBreakpointInterface.h +++ b/lldb/include/lldb/Interpreter/Interfaces/ScriptedBreakpointInterface.h @@ -18,25 +18,27 @@ namespace lldb_private { class ScriptedBreakpointResolverOverride : public Target::BreakpointResolverOverride { public: - ScriptedBreakpointResolverOverride(Target &target, const std::string &description, - const std::string &class_name, StructuredDataImpl &args_data) - : Target::BreakpointResolverOverride(target, description), - m_args_data(args_data), m_class_name(class_name) {} + ScriptedBreakpointResolverOverride(Target &target, + const std::string &description, + const std::string &class_name, + StructuredDataImpl &args_data) + : Target::BreakpointResolverOverride(target, description), + m_args_data(args_data), m_class_name(class_name) {} BreakpointResolverOverride *CopyIntoNewTarget(Target &target) override { return new ScriptedBreakpointResolverOverride(target, m_desc, m_class_name, - m_args_data); + m_args_data); } - lldb::BreakpointResolverSP CheckForOverride(Target &target, - lldb::BreakpointResolverSP initial_sp) override; + lldb::BreakpointResolverSP + CheckForOverride(Target &target, + lldb::BreakpointResolverSP initial_sp) override; private: StructuredDataImpl m_args_data; std::string m_class_name; }; - class ScriptedBreakpointInterface : public ScriptedInterface { public: virtual llvm::Expected<StructuredData::GenericSP> @@ -59,13 +61,13 @@ class ScriptedBreakpointInterface : public ScriptedInterface { lldb::DescriptionLevel level) { return {}; } - + virtual void SetBreakpoint(lldb::BreakpointSP break_sp) {} - - virtual bool OverridesResolver(Target &target, StructuredDataImpl &original_resolver) { + + virtual bool OverridesResolver(Target &target, + StructuredDataImpl &original_resolver) { return false; } - }; } // namespace lldb_private diff --git a/lldb/include/lldb/Interpreter/ScriptInterpreter.h b/lldb/include/lldb/Interpreter/ScriptInterpreter.h index 6c213ab179830..58af82fb48390 100644 --- a/lldb/include/lldb/Interpreter/ScriptInterpreter.h +++ b/lldb/include/lldb/Interpreter/ScriptInterpreter.h @@ -661,8 +661,7 @@ class ScriptInterpreter : public PluginInterface { lldb::ValueObjectSP GetOpaqueTypeFromSBValue(const lldb::SBValue &value) const; - lldb::TargetSP - GetOpaqueTypeFromSBTarget(const lldb::SBTarget &target) const; + lldb::TargetSP GetOpaqueTypeFromSBTarget(const lldb::SBTarget &target) const; protected: Debugger &m_debugger; diff --git a/lldb/include/lldb/Target/Target.h b/lldb/include/lldb/Target/Target.h index 9cb7fdccd5d24..bf30e176f0f41 100644 --- a/lldb/include/lldb/Target/Target.h +++ b/lldb/include/lldb/Target/Target.h @@ -38,8 +38,8 @@ #include "lldb/Utility/Broadcaster.h" #include "lldb/Utility/LLDBAssert.h" #include "lldb/Utility/RealpathPrefixes.h" -#include "lldb/Utility/StructuredData.h" #include "lldb/Utility/Stream.h" +#include "lldb/Utility/StructuredData.h" #include "lldb/Utility/Timeout.h" #include "lldb/lldb-public.h" #include "llvm/ADT/MapVector.h" @@ -998,7 +998,7 @@ class Target : public std::enable_shared_from_this<Target>, /// Resets the hit count of all breakpoints. void ResetBreakpointHitCounts(); - + // This callout implements the "Resolver Override". When we have determined // the Resolver for a given breakpoint, we pass each of the registered // overrides the "natural" resolver, and then we will use whatever resolver @@ -1009,49 +1009,49 @@ class Target : public std::enable_shared_from_this<Target>, // the original one. // This is the abstract version of the override. Particular implementations - // e.g. the scripted + // e.g. the scripted class BreakpointResolverOverride { public: BreakpointResolverOverride(Target &target, const std::string &description) : m_target(target), m_desc(description) {} - + virtual BreakpointResolverOverride *CopyIntoNewTarget(Target &target) = 0; virtual ~BreakpointResolverOverride() {} - virtual lldb::BreakpointResolverSP CheckForOverride(Target &target, - lldb::BreakpointResolverSP initial_sp) { + virtual lldb::BreakpointResolverSP + CheckForOverride(Target &target, lldb::BreakpointResolverSP initial_sp) { return {}; } const std::string &GetDescription() { return m_desc; } + protected: Target &m_target; std::string m_desc; }; - + uint64_t AddBreakpointResolverOverride(BreakpointResolverOverride *override) { static uint64_t g_override_id = 1; uint64_t id_used = g_override_id; - m_breakpoint_overrides.emplace(g_override_id, - std::unique_ptr<BreakpointResolverOverride>(override)); + m_breakpoint_overrides.emplace( + g_override_id, std::unique_ptr<BreakpointResolverOverride>(override)); g_override_id++; return id_used; } - - uint64_t AddBreakpointResolverOverride(llvm::StringRef class_name, - StructuredData::DictionarySP args_data_sp, llvm::StringRef description); - + uint64_t + AddBreakpointResolverOverride(llvm::StringRef class_name, + StructuredData::DictionarySP args_data_sp, + llvm::StringRef description); + bool RemoveBreakpointResolverOverride(uint64_t override_id) { size_t removed = m_breakpoint_overrides.erase(override_id); return removed == 1; } - - void ClearBreakpointResolverOverrides() { - m_breakpoint_overrides.clear(); - } - - lldb::BreakpointResolverSP CheckBreakpointOverrides(lldb::BreakpointResolverSP original_sp) - { + + void ClearBreakpointResolverOverrides() { m_breakpoint_overrides.clear(); } + + lldb::BreakpointResolverSP + CheckBreakpointOverrides(lldb::BreakpointResolverSP original_sp) { for (auto const &elem : m_breakpoint_overrides) { lldb::BreakpointResolverSP overriden_sp; overriden_sp = elem.second->CheckForOverride(*this, original_sp); @@ -1061,7 +1061,7 @@ class Target : public std::enable_shared_from_this<Target>, return {}; } - // Describe the + // Describe the void DescribeBreakpointOverrides(Stream &stream, std::vector<uint64_t> idxs) { if (m_breakpoint_overrides.size() == 0) { stream << "No overrides.\n"; @@ -1070,7 +1070,7 @@ class Target : public std::enable_shared_from_this<Target>, // FIXME: Is there some good way to flow the description? stream << "ID Description\n"; stream << "------ -----------\n"; - + auto begin = idxs.begin(); auto end = idxs.end(); bool empty = idxs.empty(); @@ -1080,7 +1080,7 @@ class Target : public std::enable_shared_from_this<Target>, else stream.Format("{0,6} is not a breakpoint override index", elem.first); } - } + } // The flag 'end_to_end', default to true, signifies that the operation is // performed end to end, for both the debugger and the debuggee. @@ -2102,9 +2102,9 @@ class Target : public std::enable_shared_from_this<Target>, using BreakpointNameList = std::map<ConstString, std::unique_ptr<BreakpointName>>; BreakpointNameList m_breakpoint_names; - - std::map<uint64_t, std::unique_ptr<BreakpointResolverOverride>> m_breakpoint_overrides; + std::map<uint64_t, std::unique_ptr<BreakpointResolverOverride>> + m_breakpoint_overrides; lldb::BreakpointSP m_last_created_breakpoint; WatchpointList m_watchpoint_list; diff --git a/lldb/source/API/SBTarget.cpp b/lldb/source/API/SBTarget.cpp index 8d34dc80a95ea..356e81667abb7 100644 --- a/lldb/source/API/SBTarget.cpp +++ b/lldb/source/API/SBTarget.cpp @@ -680,17 +680,19 @@ size_t SBTarget::ReadMemory(const SBAddress addr, void *buf, size_t size, return bytes_read; } -uint64_t SBTarget::AddBreakpointOverride(const char *class_name, - const char *description, SBStructuredData &args_data) { +uint64_t SBTarget::AddBreakpointOverride(const char *class_name, + const char *description, + SBStructuredData &args_data) { if (TargetSP target_sp = GetSP()) { StructuredDataImpl impl; args_data.CopyImpl(impl); - ScriptedBreakpointResolverOverride *new_override - = new ScriptedBreakpointResolverOverride(*target_sp.get(), - std::string(description), std::string(class_name), impl); + ScriptedBreakpointResolverOverride *new_override = + new ScriptedBreakpointResolverOverride(*target_sp.get(), + std::string(description), + std::string(class_name), impl); return target_sp->AddBreakpointResolverOverride(new_override); } - return 0; + return 0; } bool SBTarget::RemoveBreakpointOverride(uint64_t id) { @@ -700,8 +702,6 @@ bool SBTarget::RemoveBreakpointOverride(uint64_t id) { return false; } - - SBBreakpoint SBTarget::BreakpointCreateByLocation(const char *file, uint32_t line) { LLDB_INSTRUMENT_VA(this, file, line); diff --git a/lldb/source/Breakpoint/BreakpointResolverScripted.cpp b/lldb/source/Breakpoint/BreakpointResolverScripted.cpp index 8c324dac51a9c..84d918029faf8 100644 --- a/lldb/source/Breakpoint/BreakpointResolverScripted.cpp +++ b/lldb/source/Breakpoint/BreakpointResolverScripted.cpp @@ -59,8 +59,8 @@ void BreakpointResolverScripted::CreateImplementationIfNeeded( CreateImplementationIfNeeded(*target_sp.get(), breakpoint_sp); } -void BreakpointResolverScripted::CreateImplementationIfNeeded(Target &target, - BreakpointSP breakpoint_sp) { +void BreakpointResolverScripted::CreateImplementationIfNeeded( + Target &target, BreakpointSP breakpoint_sp) { if (m_interface_sp) { if (!m_breakpoint_sent && breakpoint_sp) { m_interface_sp->SetBreakpoint(breakpoint_sp); @@ -68,9 +68,9 @@ void BreakpointResolverScripted::CreateImplementationIfNeeded(Target &target, } return; } - - ScriptInterpreter *script_interp = target.GetDebugger() - .GetScriptInterpreter(); + + ScriptInterpreter *script_interp = + target.GetDebugger().GetScriptInterpreter(); if (!script_interp) return; @@ -90,7 +90,7 @@ void BreakpointResolverScripted::CreateImplementationIfNeeded(Target &target, m_interface_sp.reset(); m_error = Status::FromError(obj_or_err.takeError()); return; - } + } StructuredData::ObjectSP object_sp = *obj_or_err; if (!object_sp || !object_sp->IsValid()) { m_error = Status::FromErrorStringWithFormat( @@ -101,15 +101,15 @@ void BreakpointResolverScripted::CreateImplementationIfNeeded(Target &target, m_breakpoint_sent = true; } -bool BreakpointResolverScripted::OverridesResolver(Target &target, - BreakpointResolverSP original_sp) { +bool BreakpointResolverScripted::OverridesResolver( + Target &target, BreakpointResolverSP original_sp) { // At this point neither resolver has been assigned a breakpoint, so pass // in an empty one. CreateImplementationIfNeeded(target, {}); if (!m_interface_sp) return false; - - StructuredData::ObjectSP serialized_sp = + + StructuredData::ObjectSP serialized_sp = original_sp->SerializeToStructuredData(); StructuredDataImpl impl(serialized_sp); return m_interface_sp->OverridesResolver(target, impl); @@ -117,7 +117,6 @@ bool BreakpointResolverScripted::OverridesResolver(Target &target, void BreakpointResolverScripted::NotifyBreakpointSet() { CreateImplementationIfNeeded(GetBreakpoint()); - } BreakpointResolverSP BreakpointResolverScripted::CreateFromStructuredData( diff --git a/lldb/source/Commands/CommandObjectBreakpoint.cpp b/lldb/source/Commands/CommandObjectBreakpoint.cpp index 080e6ce828151..8e631515189ab 100644 --- a/lldb/source/Commands/CommandObjectBreakpoint.cpp +++ b/lldb/source/Commands/CommandObjectBreakpoint.cpp @@ -3591,9 +3591,9 @@ class CommandObjectBreakpointWrite : public CommandObjectParsed { class CommandObjectBreakpointOverrideAdd : public CommandObjectParsed { public: CommandObjectBreakpointOverrideAdd(CommandInterpreter &interpreter) - : CommandObjectParsed( - interpreter, "breakpoint override add", - "Add a scripted breakpoint override resolver.", nullptr), + : CommandObjectParsed(interpreter, "breakpoint override add", + "Add a scripted breakpoint override resolver.", + nullptr), m_python_class_options("breakpoint override resolver", true, 'P') { // We're picking up all the normal options, commands and disable. m_all_options.Append(&m_python_class_options, @@ -3646,7 +3646,7 @@ class CommandObjectBreakpointOverrideAdd : public CommandObjectParsed { Target &target = m_dummy_options.m_use_dummy ? GetDummyTarget() : GetTarget(); uint64_t id = target.AddBreakpointResolverOverride( - m_python_class_options.GetName(), + m_python_class_options.GetName(), m_python_class_options.GetStructuredData(), m_options.m_description); result.AppendMessageWithFormatv("{0}", id); result.SetStatus(eReturnStatusSuccessFinishResult); @@ -3662,9 +3662,9 @@ class CommandObjectBreakpointOverrideAdd : public CommandObjectParsed { class CommandObjectBreakpointOverrideDelete : public CommandObjectParsed { public: CommandObjectBreakpointOverrideDelete(CommandInterpreter &interpreter) - : CommandObjectParsed( - interpreter, "breakpoint override delete", - "Add a scripted breakpoint override resolver.", nullptr) { + : CommandObjectParsed(interpreter, "breakpoint override delete", + "Add a scripted breakpoint override resolver.", + nullptr) { AddSimpleArgumentList(eArgTypeIndex, eArgRepeatOptional); m_all_options.Append(&m_dummy_options, LLDB_OPT_SET_1, LLDB_OPT_SET_1); m_all_options.Finalize(); @@ -3676,10 +3676,10 @@ class CommandObjectBreakpointOverrideDelete : public CommandObjectParsed { void DoExecute(Args &command, CommandReturnObject &result) override { Target &target = m_dummy_options.m_use_dummy ? GetDummyTarget() : GetTarget(); - + const size_t argc = command.GetArgumentCount(); if (argc == 0) { - if(m_interpreter.Confirm("Delete all breakpoint overrides?", false)) { + if (m_interpreter.Confirm("Delete all breakpoint overrides?", false)) { target.ClearBreakpointResolverOverrides(); } result.SetStatus(eReturnStatusSuccessFinishNoResult); @@ -3700,7 +3700,7 @@ class CommandObjectBreakpointOverrideDelete : public CommandObjectParsed { result.AppendErrorWithFormatv("Cannot delete override: {0}", id); result.SetStatus(eReturnStatusFailed); return; - } + } } result.SetStatus(eReturnStatusSuccessFinishNoResult); } @@ -3715,7 +3715,7 @@ class CommandObjectBreakpointOverrideList : public CommandObjectParsed { CommandObjectBreakpointOverrideList(CommandInterpreter &interpreter) : CommandObjectParsed( interpreter, "breakpoint override list", - "List the current scripted breakpoint override resolvers.", + "List the current scripted breakpoint override resolvers.", nullptr) { AddSimpleArgumentList(eArgTypeIndex, eArgRepeatOptional); m_all_options.Append(&m_dummy_options, LLDB_OPT_SET_1, LLDB_OPT_SET_1); @@ -3728,7 +3728,7 @@ class CommandObjectBreakpointOverrideList : public CommandObjectParsed { void DoExecute(Args &command, CommandReturnObject &result) override { Target &target = m_dummy_options.m_use_dummy ? GetDummyTarget() : GetTarget(); - + const size_t argc = command.GetArgumentCount(); std::vector<uint64_t> idxs; if (argc != 0) { @@ -3738,7 +3738,8 @@ class CommandObjectBreakpointOverrideList : public CommandObjectParsed { if (entry.ref().getAsInteger(0, id)) idxs.push_back(id); else { - result.AppendErrorWithFormatv("Index not an integer: {0}", entry.ref()); + result.AppendErrorWithFormatv("Index not an integer: {0}", + entry.ref()); result.SetStatus(eReturnStatusFailed); return; } @@ -3756,11 +3757,11 @@ class CommandObjectBreakpointOverride : public CommandObjectMultiword { public: CommandObjectBreakpointOverride(CommandInterpreter &interpreter) : CommandObjectMultiword( - interpreter, "override", "Commands to manage breakpoint override resolvers") { - - + interpreter, "override", + "Commands to manage breakpoint override resolvers") { + SetHelpLong( - R"( + R"( Breakpoint override resolvers allow you to intercept breakpoint requests and re-implement them using a custom breakpoint resolver. Override resolvers are implemented by a scripted breakpoint resolver that implements the @@ -3799,7 +3800,6 @@ Delete an added resolver using: ~CommandObjectBreakpointOverride() override = default; }; - // CommandObjectMultiwordBreakpoint #pragma mark MultiwordBreakpoint diff --git a/lldb/source/Interpreter/Interfaces/ScriptedBreakpointInterface.cpp b/lldb/source/Interpreter/Interfaces/ScriptedBreakpointInterface.cpp index 5afc6af8a1e1e..77381a2a76995 100644 --- a/lldb/source/Interpreter/Interfaces/ScriptedBreakpointInterface.cpp +++ b/lldb/source/Interpreter/Interfaces/ScriptedBreakpointInterface.cpp @@ -12,12 +12,11 @@ namespace lldb_private { lldb::BreakpointResolverSP ScriptedBreakpointResolverOverride::CheckForOverride( - Target &target, lldb::BreakpointResolverSP initial_sp) { + Target &target, lldb::BreakpointResolverSP initial_sp) { lldb::BreakpointResolverSP candidate_sp(new BreakpointResolverScripted( - {}, m_class_name, initial_sp->GetDepth(), - m_args_data)); + {}, m_class_name, initial_sp->GetDepth(), m_args_data)); if (candidate_sp->OverridesResolver(target, initial_sp)) return candidate_sp; return {}; } -} +} // namespace lldb_private diff --git a/lldb/source/Plugins/ScriptInterpreter/Python/Interfaces/ScriptedBreakpointPythonInterface.cpp b/lldb/source/Plugins/ScriptInterpreter/Python/Interfaces/ScriptedBreakpointPythonInterface.cpp index 0dc98f842a9b5..e93e51eae8c3c 100644 --- a/lldb/source/Plugins/ScriptInterpreter/Python/Interfaces/ScriptedBreakpointPythonInterface.cpp +++ b/lldb/source/Plugins/ScriptInterpreter/Python/Interfaces/ScriptedBreakpointPythonInterface.cpp @@ -37,14 +37,14 @@ ScriptedBreakpointPythonInterface::CreatePluginObject( break_sp, args_sp); } -bool ScriptedBreakpointPythonInterface::OverridesResolver(Target &target, - StructuredDataImpl &resolver_data) { +bool ScriptedBreakpointPythonInterface::OverridesResolver( + Target &target, StructuredDataImpl &resolver_data) { Status error; - + TargetSP target_sp = target.shared_from_this(); - - StructuredData::ObjectSP obj = Dispatch("overrides_resolver", error, - target_sp, resolver_data); + + StructuredData::ObjectSP obj = + Dispatch("overrides_resolver", error, target_sp, resolver_data); if (!ScriptedInterface::CheckStructuredDataObject(LLVM_PRETTY_FUNCTION, obj, error)) { @@ -55,11 +55,11 @@ bool ScriptedBreakpointPythonInterface::OverridesResolver(Target &target, return obj->GetBooleanValue(); } -void ScriptedBreakpointPythonInterface::SetBreakpoint(lldb::BreakpointSP break_sp) -{ +void ScriptedBreakpointPythonInterface::SetBreakpoint( + lldb::BreakpointSP break_sp) { Status error; StructuredData::ObjectSP obj = Dispatch("set_breakpoint", error, break_sp); - if (!ScriptedInterface::CheckStructuredDataObject(LLVM_PRETTY_FUNCTION, obj, + if (!ScriptedInterface::CheckStructuredDataObject(LLVM_PRETTY_FUNCTION, obj, error)) { Log *log = GetLog(LLDBLog::Script); LLDB_LOG(log, "Error calling set_breakpoint method: {1}", error); diff --git a/lldb/source/Plugins/ScriptInterpreter/Python/Interfaces/ScriptedBreakpointPythonInterface.h b/lldb/source/Plugins/ScriptInterpreter/Python/Interfaces/ScriptedBreakpointPythonInterface.h index edeeec7ba4e73..56b80fd863939 100644 --- a/lldb/source/Plugins/ScriptInterpreter/Python/Interfaces/ScriptedBreakpointPythonInterface.h +++ b/lldb/source/Plugins/ScriptInterpreter/Python/Interfaces/ScriptedBreakpointPythonInterface.h @@ -30,7 +30,8 @@ class ScriptedBreakpointPythonInterface : public ScriptedBreakpointInterface, return llvm::SmallVector<AbstractMethodRequirement>({{"__callback__", 2}}); } - bool OverridesResolver(Target &target, StructuredDataImpl &resolver_data) override; + bool OverridesResolver(Target &target, + StructuredDataImpl &resolver_data) override; void SetBreakpoint(lldb::BreakpointSP break_sp) override; bool ResolverCallback(SymbolContext sym_ctx) override; diff --git a/lldb/source/Plugins/ScriptInterpreter/Python/Interfaces/ScriptedPythonInterface.h b/lldb/source/Plugins/ScriptInterpreter/Python/Interfaces/ScriptedPythonInterface.h index 54f4843485651..637ca1b2ab1f9 100644 --- a/lldb/source/Plugins/ScriptInterpreter/Python/Interfaces/ScriptedPythonInterface.h +++ b/lldb/source/Plugins/ScriptInterpreter/Python/Interfaces/ScriptedPythonInterface.h @@ -654,7 +654,7 @@ class ScriptedPythonInterface : virtual public ScriptedInterface { python::PythonObject Transform(lldb::ValueObjectSP arg) { return python::SWIGBridge::ToSWIGWrapper(arg); } - + template <typename T, typename U> void ReverseTransform(T &original_arg, U transformed_arg, Status &error) { // If U is not a PythonObject, don't touch it! diff --git a/lldb/source/Target/Target.cpp b/lldb/source/Target/Target.cpp index ba7a597af2364..7267aaac4a69f 100644 --- a/lldb/source/Target/Target.cpp +++ b/lldb/source/Target/Target.cpp @@ -238,7 +238,7 @@ void Target::PrimeFromDummyTarget(Target &target) { for (const auto &bp_name_entry : target.m_breakpoint_names) { AddBreakpointName(std::make_unique<BreakpointName>(*bp_name_entry.second)); } - + for (auto const &elem : target.m_breakpoint_overrides) { AddBreakpointResolverOverride(elem.second->CopyIntoNewTarget(*this)); } @@ -806,7 +806,8 @@ BreakpointSP Target::CreateBreakpoint(SearchFilterSP &filter_sp, // if there are see if one of them want to handle this request instead. // But we don't allow overrides for internal breakpoints: if (!internal) { - BreakpointResolverSP overridden_sp = CheckBreakpointOverrides(resolver_sp); + BreakpointResolverSP overridden_sp = + CheckBreakpointOverrides(resolver_sp); if (overridden_sp) resolver_sp = overridden_sp; } @@ -943,18 +944,19 @@ void Target::GetBreakpointNames(std::vector<std::string> &names) { llvm::sort(names); } -uint64_t Target::AddBreakpointResolverOverride(llvm::StringRef class_name, - StructuredData::DictionarySP args_data_sp, llvm::StringRef description) { +uint64_t +Target::AddBreakpointResolverOverride(llvm::StringRef class_name, + StructuredData::DictionarySP args_data_sp, + llvm::StringRef description) { StructuredDataImpl impl; impl.SetObjectSP(args_data_sp); - - ScriptedBreakpointResolverOverride *new_override - = new ScriptedBreakpointResolverOverride(*this, - std::string(description), std::string(class_name), impl); + + ScriptedBreakpointResolverOverride *new_override = + new ScriptedBreakpointResolverOverride(*this, std::string(description), + std::string(class_name), impl); return AddBreakpointResolverOverride(new_override); } - bool Target::ProcessIsValid() { return (m_process_sp && m_process_sp->IsAlive()); } diff --git a/lldb/test/API/functionalities/breakpoint/scripted_bkpt/overrides_resolver/TestOverridesResolver.py b/lldb/test/API/functionalities/breakpoint/scripted_bkpt/overrides_resolver/TestOverridesResolver.py index 2625b97952b71..308e243c715a3 100644 --- a/lldb/test/API/functionalities/breakpoint/scripted_bkpt/overrides_resolver/TestOverridesResolver.py +++ b/lldb/test/API/functionalities/breakpoint/scripted_bkpt/overrides_resolver/TestOverridesResolver.py @@ -50,18 +50,16 @@ def do_test(self, use_cmd): result = lldb.SBCommandReturnObject() self.ci.HandleCommand( f"breakpoint override add -P {class_name} -k {key} -v {value} -d '{help_text}'", - result + result, ) self.assertCommandReturn(result, "breakpoint override worked") override_id = int(result.GetOutput()) else: extra_args = lldb.SBStructuredData() - json_str = '{"' + key + '":"' + value + '"}' + json_str = '{"' + key + '":"' + value + '"}' extra_args.SetFromJSON(json_str) override_id = target.AddBreakpointOverride( - class_name, - help_text, - extra_args + class_name, help_text, extra_args ) # Check the override listing, make sure our new entry is present: @@ -70,8 +68,7 @@ def do_test(self, use_cmd): # Now make a breakpoint by file and line: # FIXME: Use source_line to find this line number: bkpt = target.BreakpointCreateByLocation( - "main.c", - line_number("main.c", "I am in the stop symbol") + "main.c", line_number("main.c", "I am in the stop symbol") ) self.assertEqual(bkpt.GetNumLocations(), 1, "We make one location") # Now continue and we'll hit this breakpoint but not in the @@ -86,9 +83,8 @@ def do_test(self, use_cmd): self.assertEqual(thread.stop_reason_data[1], 1, "First location hit is 1") func_name = thread.frames[0].name self.assertEqual( - func_name, - alternate_location, - "Stopped at overridden location") + func_name, alternate_location, "Stopped at overridden location" + ) # Now set a source name breakpoint, that should not get overridden, and # when we continue we should hit it: @@ -105,20 +101,15 @@ def do_test(self, use_cmd): self.runCmd(f"breakpoint override delete {override_id}") else: self.assertTrue( - target.DeleteBreakpointOverride(override_id), - "Delete the right one" + target.DeleteBreakpointOverride(override_id), "Delete the right one" ) # FIXME use source_line: new_bkpt = target.BreakpointCreateByLocation( - "main.c", - line_number("main.c", "return 0") + "main.c", line_number("main.c", "return 0") ) self.assertEqual(new_bkpt.num_locations, 1, "Made breakpoint") threads = lldbutil.continue_to_breakpoint(process, new_bkpt) self.assertEqual(len(threads), 1, "Hit our new breakpoint") func_name = threads[0].frames[0].name self.assertEqual(func_name, "main", "Stopped in unchanged location") - - - diff --git a/lldb/test/API/functionalities/breakpoint/scripted_bkpt/overrides_resolver/bkpt_resolver.py b/lldb/test/API/functionalities/breakpoint/scripted_bkpt/overrides_resolver/bkpt_resolver.py index 7977a97a38564..a25442f5c01d6 100644 --- a/lldb/test/API/functionalities/breakpoint/scripted_bkpt/overrides_resolver/bkpt_resolver.py +++ b/lldb/test/API/functionalities/breakpoint/scripted_bkpt/overrides_resolver/bkpt_resolver.py @@ -2,16 +2,18 @@ class OverrideExample: - def __init__(self, bkpt: lldb.SBBreakpoint, extra_args : lldb.SBStructuredData, dict): + def __init__( + self, bkpt: lldb.SBBreakpoint, extra_args: lldb.SBStructuredData, dict + ): self.bkpt = bkpt self.extra_args = extra_args self.set_bkpt = False symbol_value = extra_args.GetValueForKey("symbol") self.alternate_loc = symbol_value.GetStringValue(1000) - def __callback__(self, sym_ctx : lldb.SBSymbolContext): + def __callback__(self, sym_ctx: lldb.SBSymbolContext): """This callback only sets a breakpoint in one place, - no matter what file and line you ask for""" + no matter what file and line you ask for""" if self.set_bkpt == True: return # FIXME: Do this better... @@ -22,14 +24,16 @@ def __callback__(self, sym_ctx : lldb.SBSymbolContext): start_addr = alternate_sym.addr self.bkpt.AddLocation(start_addr) self.set_bkpt = True - + def get_short_help(self): return f"I am an override resolver, resolving to {self.alternate_loc}." def set_breakpoint(self, bkpt: lldb.SBBreakpoint): self.bkpt = bkpt - def overrides_resolver(self, target: lldb.SBTarget, initial_resolver: lldb.SBStructuredData): + def overrides_resolver( + self, target: lldb.SBTarget, initial_resolver: lldb.SBStructuredData + ): strm = lldb.SBStream() initial_resolver.GetAsJSON(strm) type = initial_resolver.GetValueForKey("Type").GetStringValue(1000) diff --git a/lldb/test/API/functionalities/breakpoint/scripted_bkpt/overrides_resolver/main.c b/lldb/test/API/functionalities/breakpoint/scripted_bkpt/overrides_resolver/main.c index 8a081bda83d14..b9fc619f46ff1 100644 --- a/lldb/test/API/functionalities/breakpoint/scripted_bkpt/overrides_resolver/main.c +++ b/lldb/test/API/functionalities/breakpoint/scripted_bkpt/overrides_resolver/main.c @@ -4,9 +4,7 @@ int g_change_me = 0; int change_him() { return ++g_change_me; } -void stop_here_instead() { - printf("Stopped here instead?\n"); -} +void stop_here_instead() { printf("Stopped here instead?\n"); } int stop_symbol() { static int s_cnt = 0; >From bcf7230fa7d184fd1bdb724b51914c602424fff2 Mon Sep 17 00:00:00 2001 From: Jim Ingham <[email protected]> Date: Mon, 4 May 2026 09:32:25 -0700 Subject: [PATCH 3/3] Remove unused variable declaration. --- lldb/source/Commands/CommandObjectBreakpoint.cpp | 1 - 1 file changed, 1 deletion(-) diff --git a/lldb/source/Commands/CommandObjectBreakpoint.cpp b/lldb/source/Commands/CommandObjectBreakpoint.cpp index 8e631515189ab..3afa3b718dd9a 100644 --- a/lldb/source/Commands/CommandObjectBreakpoint.cpp +++ b/lldb/source/Commands/CommandObjectBreakpoint.cpp @@ -3734,7 +3734,6 @@ class CommandObjectBreakpointOverrideList : public CommandObjectParsed { if (argc != 0) { for (auto &entry : command.entries()) { uint64_t id; - bool success; if (entry.ref().getAsInteger(0, id)) idxs.push_back(id); else { _______________________________________________ lldb-commits mailing list [email protected] https://lists.llvm.org/cgi-bin/mailman/listinfo/lldb-commits
