blob: c6966145e42beb510299ac2e756148a7326746c2 [file] [log] [blame]
//===-- BreakpointSiteList.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/Breakpoint/BreakpointSiteList.h"
#include "lldb/Utility/Stream.h"
#include <algorithm>
using namespace lldb;
using namespace lldb_private;
BreakpointSiteList::BreakpointSiteList() : m_mutex(), m_bp_site_list() {}
BreakpointSiteList::~BreakpointSiteList() = default;
// Add breakpoint site to the list. However, if the element already exists in
// the list, then we don't add it, and return LLDB_INVALID_BREAK_ID.
lldb::break_id_t BreakpointSiteList::Add(const BreakpointSiteSP &bp) {
lldb::addr_t bp_site_load_addr = bp->GetLoadAddress();
std::lock_guard<std::recursive_mutex> guard(m_mutex);
collection::iterator iter = m_bp_site_list.find(bp_site_load_addr);
if (iter == m_bp_site_list.end()) {
m_bp_site_list.insert(iter, collection::value_type(bp_site_load_addr, bp));
return bp->GetID();
} else {
return LLDB_INVALID_BREAK_ID;
}
}
bool BreakpointSiteList::ShouldStop(StoppointCallbackContext *context,
lldb::break_id_t site_id) {
BreakpointSiteSP site_sp(FindByID(site_id));
if (site_sp) {
// Let the BreakpointSite decide if it should stop here (could not have
// reached it's target hit count yet, or it could have a callback that
// decided it shouldn't stop (shared library loads/unloads).
return site_sp->ShouldStop(context);
}
// We should stop here since this BreakpointSite isn't valid anymore or it
// doesn't exist.
return true;
}
lldb::break_id_t BreakpointSiteList::FindIDByAddress(lldb::addr_t addr) {
BreakpointSiteSP bp = FindByAddress(addr);
if (bp) {
// DBLogIf(PD_LOG_BREAKPOINTS, "BreakpointSiteList::%s ( addr = 0x%8.8"
// PRIx64 " ) => %u", __FUNCTION__, (uint64_t)addr, bp->GetID());
return bp.get()->GetID();
}
// DBLogIf(PD_LOG_BREAKPOINTS, "BreakpointSiteList::%s ( addr = 0x%8.8"
// PRIx64
// " ) => NONE", __FUNCTION__, (uint64_t)addr);
return LLDB_INVALID_BREAK_ID;
}
bool BreakpointSiteList::Remove(lldb::break_id_t break_id) {
std::lock_guard<std::recursive_mutex> guard(m_mutex);
collection::iterator pos = GetIDIterator(break_id); // Predicate
if (pos != m_bp_site_list.end()) {
m_bp_site_list.erase(pos);
return true;
}
return false;
}
bool BreakpointSiteList::RemoveByAddress(lldb::addr_t address) {
std::lock_guard<std::recursive_mutex> guard(m_mutex);
collection::iterator pos = m_bp_site_list.find(address);
if (pos != m_bp_site_list.end()) {
m_bp_site_list.erase(pos);
return true;
}
return false;
}
class BreakpointSiteIDMatches {
public:
BreakpointSiteIDMatches(lldb::break_id_t break_id) : m_break_id(break_id) {}
bool operator()(std::pair<lldb::addr_t, BreakpointSiteSP> val_pair) const {
return m_break_id == val_pair.second->GetID();
}
private:
const lldb::break_id_t m_break_id;
};
BreakpointSiteList::collection::iterator
BreakpointSiteList::GetIDIterator(lldb::break_id_t break_id) {
std::lock_guard<std::recursive_mutex> guard(m_mutex);
return std::find_if(m_bp_site_list.begin(),
m_bp_site_list.end(), // Search full range
BreakpointSiteIDMatches(break_id)); // Predicate
}
BreakpointSiteList::collection::const_iterator
BreakpointSiteList::GetIDConstIterator(lldb::break_id_t break_id) const {
std::lock_guard<std::recursive_mutex> guard(m_mutex);
return std::find_if(m_bp_site_list.begin(),
m_bp_site_list.end(), // Search full range
BreakpointSiteIDMatches(break_id)); // Predicate
}
BreakpointSiteSP BreakpointSiteList::FindByID(lldb::break_id_t break_id) {
std::lock_guard<std::recursive_mutex> guard(m_mutex);
BreakpointSiteSP stop_sp;
collection::iterator pos = GetIDIterator(break_id);
if (pos != m_bp_site_list.end())
stop_sp = pos->second;
return stop_sp;
}
const BreakpointSiteSP
BreakpointSiteList::FindByID(lldb::break_id_t break_id) const {
std::lock_guard<std::recursive_mutex> guard(m_mutex);
BreakpointSiteSP stop_sp;
collection::const_iterator pos = GetIDConstIterator(break_id);
if (pos != m_bp_site_list.end())
stop_sp = pos->second;
return stop_sp;
}
BreakpointSiteSP BreakpointSiteList::FindByAddress(lldb::addr_t addr) {
BreakpointSiteSP found_sp;
std::lock_guard<std::recursive_mutex> guard(m_mutex);
collection::iterator iter = m_bp_site_list.find(addr);
if (iter != m_bp_site_list.end())
found_sp = iter->second;
return found_sp;
}
bool BreakpointSiteList::BreakpointSiteContainsBreakpoint(
lldb::break_id_t bp_site_id, lldb::break_id_t bp_id) {
std::lock_guard<std::recursive_mutex> guard(m_mutex);
collection::const_iterator pos = GetIDConstIterator(bp_site_id);
if (pos != m_bp_site_list.end())
return pos->second->IsBreakpointAtThisSite(bp_id);
return false;
}
void BreakpointSiteList::Dump(Stream *s) const {
s->Printf("%p: ", static_cast<const void *>(this));
// s->Indent();
s->Printf("BreakpointSiteList with %u BreakpointSites:\n",
(uint32_t)m_bp_site_list.size());
s->IndentMore();
collection::const_iterator pos;
collection::const_iterator end = m_bp_site_list.end();
for (pos = m_bp_site_list.begin(); pos != end; ++pos)
pos->second->Dump(s);
s->IndentLess();
}
void BreakpointSiteList::ForEach(
std::function<void(BreakpointSite *)> const &callback) {
std::lock_guard<std::recursive_mutex> guard(m_mutex);
for (auto pair : m_bp_site_list)
callback(pair.second.get());
}
bool BreakpointSiteList::FindInRange(lldb::addr_t lower_bound,
lldb::addr_t upper_bound,
BreakpointSiteList &bp_site_list) const {
if (lower_bound > upper_bound)
return false;
std::lock_guard<std::recursive_mutex> guard(m_mutex);
collection::const_iterator lower, upper, pos;
lower = m_bp_site_list.lower_bound(lower_bound);
if (lower == m_bp_site_list.end() || (*lower).first >= upper_bound)
return false;
// This is one tricky bit. The breakpoint might overlap the bottom end of
// the range. So we grab the breakpoint prior to the lower bound, and check
// that that + its byte size isn't in our range.
if (lower != m_bp_site_list.begin()) {
collection::const_iterator prev_pos = lower;
prev_pos--;
const BreakpointSiteSP &prev_bp = (*prev_pos).second;
if (prev_bp->GetLoadAddress() + prev_bp->GetByteSize() > lower_bound)
bp_site_list.Add(prev_bp);
}
upper = m_bp_site_list.upper_bound(upper_bound);
for (pos = lower; pos != upper; pos++) {
bp_site_list.Add((*pos).second);
}
return true;
}