contrib/llvm-project/lldb/source/Breakpoint/BreakpointSiteList.cpp

   1 //===-- BreakpointSiteList.cpp ----------------------------------*- C++ -*-===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #include "lldb/Breakpoint/BreakpointSiteList.h"
  10
  11 #include "lldb/Utility/Stream.h"
  12 #include <algorithm>
  13
  14 using namespace lldb;
  15 using namespace lldb_private;
  16
  17 BreakpointSiteList::BreakpointSiteList() : m_mutex(), m_bp_site_list() {}
  18
  19 BreakpointSiteList::~BreakpointSiteList() {}
  20
  21 // Add breakpoint site to the list.  However, if the element already exists in
  22 // the list, then we don't add it, and return LLDB_INVALID_BREAK_ID.
  23
  24 lldb::break_id_t BreakpointSiteList::Add(const BreakpointSiteSP &bp) {
  25   lldb::addr_t bp_site_load_addr = bp->GetLoadAddress();
  26   std::lock_guard<std::recursive_mutex> guard(m_mutex);
  27   collection::iterator iter = m_bp_site_list.find(bp_site_load_addr);
  28
  29   if (iter == m_bp_site_list.end()) {
  30     m_bp_site_list.insert(iter, collection::value_type(bp_site_load_addr, bp));
  31     return bp->GetID();
  32   } else {
  33     return LLDB_INVALID_BREAK_ID;
  34   }
  35 }
  36
  37 bool BreakpointSiteList::ShouldStop(StoppointCallbackContext *context,
  38                                     lldb::break_id_t site_id) {
  39   BreakpointSiteSP site_sp(FindByID(site_id));
  40   if (site_sp) {
  41     // Let the BreakpointSite decide if it should stop here (could not have
  42     // reached it's target hit count yet, or it could have a callback that
  43     // decided it shouldn't stop (shared library loads/unloads).
  44     return site_sp->ShouldStop(context);
  45   }
  46   // We should stop here since this BreakpointSite isn't valid anymore or it
  47   // doesn't exist.
  48   return true;
  49 }
  50 lldb::break_id_t BreakpointSiteList::FindIDByAddress(lldb::addr_t addr) {
  51   BreakpointSiteSP bp = FindByAddress(addr);
  52   if (bp) {
  53     // DBLogIf(PD_LOG_BREAKPOINTS, "BreakpointSiteList::%s ( addr = 0x%8.8"
  54     // PRIx64 " ) => %u", __FUNCTION__, (uint64_t)addr, bp->GetID());
  55     return bp.get()->GetID();
  56   }
  57   // DBLogIf(PD_LOG_BREAKPOINTS, "BreakpointSiteList::%s ( addr = 0x%8.8"
  58   // PRIx64
  59   // " ) => NONE", __FUNCTION__, (uint64_t)addr);
  60   return LLDB_INVALID_BREAK_ID;
  61 }
  62
  63 bool BreakpointSiteList::Remove(lldb::break_id_t break_id) {
  64   std::lock_guard<std::recursive_mutex> guard(m_mutex);
  65   collection::iterator pos = GetIDIterator(break_id); // Predicate
  66   if (pos != m_bp_site_list.end()) {
  67     m_bp_site_list.erase(pos);
  68     return true;
  69   }
  70   return false;
  71 }
  72
  73 bool BreakpointSiteList::RemoveByAddress(lldb::addr_t address) {
  74   std::lock_guard<std::recursive_mutex> guard(m_mutex);
  75   collection::iterator pos = m_bp_site_list.find(address);
  76   if (pos != m_bp_site_list.end()) {
  77     m_bp_site_list.erase(pos);
  78     return true;
  79   }
  80   return false;
  81 }
  82
  83 class BreakpointSiteIDMatches {
  84 public:
  85   BreakpointSiteIDMatches(lldb::break_id_t break_id) : m_break_id(break_id) {}
  86
  87   bool operator()(std::pair<lldb::addr_t, BreakpointSiteSP> val_pair) const {
  88     return m_break_id == val_pair.second->GetID();
  89   }
  90
  91 private:
  92   const lldb::break_id_t m_break_id;
  93 };
  94
  95 BreakpointSiteList::collection::iterator
  96 BreakpointSiteList::GetIDIterator(lldb::break_id_t break_id) {
  97   std::lock_guard<std::recursive_mutex> guard(m_mutex);
  98   return std::find_if(m_bp_site_list.begin(),
  99                       m_bp_site_list.end(),               // Search full range
 100                       BreakpointSiteIDMatches(break_id)); // Predicate
 101 }
 102
 103 BreakpointSiteList::collection::const_iterator
 104 BreakpointSiteList::GetIDConstIterator(lldb::break_id_t break_id) const {
 105   std::lock_guard<std::recursive_mutex> guard(m_mutex);
 106   return std::find_if(m_bp_site_list.begin(),
 107                       m_bp_site_list.end(),               // Search full range
 108                       BreakpointSiteIDMatches(break_id)); // Predicate
 109 }
 110
 111 BreakpointSiteSP BreakpointSiteList::FindByID(lldb::break_id_t break_id) {
 112   std::lock_guard<std::recursive_mutex> guard(m_mutex);
 113   BreakpointSiteSP stop_sp;
 114   collection::iterator pos = GetIDIterator(break_id);
 115   if (pos != m_bp_site_list.end())
 116     stop_sp = pos->second;
 117
 118   return stop_sp;
 119 }
 120
 121 const BreakpointSiteSP
 122 BreakpointSiteList::FindByID(lldb::break_id_t break_id) const {
 123   std::lock_guard<std::recursive_mutex> guard(m_mutex);
 124   BreakpointSiteSP stop_sp;
 125   collection::const_iterator pos = GetIDConstIterator(break_id);
 126   if (pos != m_bp_site_list.end())
 127     stop_sp = pos->second;
 128
 129   return stop_sp;
 130 }
 131
 132 BreakpointSiteSP BreakpointSiteList::FindByAddress(lldb::addr_t addr) {
 133   BreakpointSiteSP found_sp;
 134   std::lock_guard<std::recursive_mutex> guard(m_mutex);
 135   collection::iterator iter = m_bp_site_list.find(addr);
 136   if (iter != m_bp_site_list.end())
 137     found_sp = iter->second;
 138   return found_sp;
 139 }
 140
 141 bool BreakpointSiteList::BreakpointSiteContainsBreakpoint(
 142     lldb::break_id_t bp_site_id, lldb::break_id_t bp_id) {
 143   std::lock_guard<std::recursive_mutex> guard(m_mutex);
 144   collection::const_iterator pos = GetIDConstIterator(bp_site_id);
 145   if (pos != m_bp_site_list.end())
 146     return pos->second->IsBreakpointAtThisSite(bp_id);
 147
 148   return false;
 149 }
 150
 151 void BreakpointSiteList::Dump(Stream *s) const {
 152   s->Printf("%p: ", static_cast<const void *>(this));
 153   // s->Indent();
 154   s->Printf("BreakpointSiteList with %u BreakpointSites:\n",
 155             (uint32_t)m_bp_site_list.size());
 156   s->IndentMore();
 157   collection::const_iterator pos;
 158   collection::const_iterator end = m_bp_site_list.end();
 159   for (pos = m_bp_site_list.begin(); pos != end; ++pos)
 160     pos->second->Dump(s);
 161   s->IndentLess();
 162 }
 163
 164 void BreakpointSiteList::ForEach(
 165     std::function<void(BreakpointSite *)> const &callback) {
 166   std::lock_guard<std::recursive_mutex> guard(m_mutex);
 167   for (auto pair : m_bp_site_list)
 168     callback(pair.second.get());
 169 }
 170
 171 bool BreakpointSiteList::FindInRange(lldb::addr_t lower_bound,
 172                                      lldb::addr_t upper_bound,
 173                                      BreakpointSiteList &bp_site_list) const {
 174   if (lower_bound > upper_bound)
 175     return false;
 176
 177   std::lock_guard<std::recursive_mutex> guard(m_mutex);
 178   collection::const_iterator lower, upper, pos;
 179   lower = m_bp_site_list.lower_bound(lower_bound);
 180   if (lower == m_bp_site_list.end() || (*lower).first >= upper_bound)
 181     return false;
 182
 183   // This is one tricky bit.  The breakpoint might overlap the bottom end of
 184   // the range.  So we grab the breakpoint prior to the lower bound, and check
 185   // that that + its byte size isn't in our range.
 186   if (lower != m_bp_site_list.begin()) {
 187     collection::const_iterator prev_pos = lower;
 188     prev_pos--;
 189     const BreakpointSiteSP &prev_bp = (*prev_pos).second;
 190     if (prev_bp->GetLoadAddress() + prev_bp->GetByteSize() > lower_bound)
 191       bp_site_list.Add(prev_bp);
 192   }
 193
 194   upper = m_bp_site_list.upper_bound(upper_bound);
 195
 196   for (pos = lower; pos != upper; pos++) {
 197     bp_site_list.Add((*pos).second);
 198   }
 199   return true;
 200 }