contrib/llvm/tools/lldb/source/Breakpoint/BreakpointSiteList.cpp

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