================
@@ -998,6 +999,88 @@ 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);
+ }
----------------
JDevlieghere wrote:
Should we emit a newline here?
https://github.com/llvm/llvm-project/pull/195392
_______________________________________________
lldb-commits mailing list
[email protected]
https://lists.llvm.org/cgi-bin/mailman/listinfo/lldb-commits
