llvm/lldb/source/Breakpoint/WatchpointList.cpp

//===-- WatchpointList.cpp --------------------------------------*- C++ -*-===//
//
// 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/WatchpointList.h"
#include "lldb/Breakpoint/Watchpoint.h"

using namespace lldb;
using namespace lldb_private;

WatchpointList::WatchpointList()
    : m_watchpoints(), m_mutex(), m_next_wp_id(0) {}

WatchpointList::~WatchpointList() {}

// Add a watchpoint to the list.
lldb::watch_id_t WatchpointList::Add(const WatchpointSP &wp_sp, bool notify) {
  std::lock_guard<std::recursive_mutex> guard(m_mutex);
  wp_sp->SetID(++m_next_wp_id);
  m_watchpoints.push_back(wp_sp);
  if (notify) {
    if (wp_sp->GetTarget().EventTypeHasListeners(
            Target::eBroadcastBitWatchpointChanged))
      wp_sp->GetTarget().BroadcastEvent(Target::eBroadcastBitWatchpointChanged,
                                        new Watchpoint::WatchpointEventData(
                                            eWatchpointEventTypeAdded, wp_sp));
  }
  return wp_sp->GetID();
}

void WatchpointList::Dump(Stream *s) const {
  DumpWithLevel(s, lldb::eDescriptionLevelBrief);
}

void WatchpointList::DumpWithLevel(
    Stream *s, lldb::DescriptionLevel description_level) const {
  std::lock_guard<std::recursive_mutex> guard(m_mutex);
  s->Printf("%p: ", static_cast<const void *>(this));
  // s->Indent();
  s->Printf("WatchpointList with %" PRIu64 " Watchpoints:\n",
            (uint64_t)m_watchpoints.size());
  s->IndentMore();
  wp_collection::const_iterator pos, end = m_watchpoints.end();
  for (pos = m_watchpoints.begin(); pos != end; ++pos)
    (*pos)->DumpWithLevel(s, description_level);
  s->IndentLess();
}

const WatchpointSP WatchpointList::FindByAddress(lldb::addr_t addr) const {
  WatchpointSP wp_sp;
  std::lock_guard<std::recursive_mutex> guard(m_mutex);
  if (!m_watchpoints.empty()) {
    wp_collection::const_iterator pos, end = m_watchpoints.end();
    for (pos = m_watchpoints.begin(); pos != end; ++pos) {
      lldb::addr_t wp_addr = (*pos)->GetLoadAddress();
      uint32_t wp_bytesize = (*pos)->GetByteSize();
      if ((wp_addr <= addr) && ((wp_addr + wp_bytesize) > addr)) {
        wp_sp = *pos;
        break;
      }
    }
  }

  return wp_sp;
}

const WatchpointSP WatchpointList::FindBySpec(std::string spec) const {
  WatchpointSP wp_sp;
  std::lock_guard<std::recursive_mutex> guard(m_mutex);
  if (!m_watchpoints.empty()) {
    wp_collection::const_iterator pos, end = m_watchpoints.end();
    for (pos = m_watchpoints.begin(); pos != end; ++pos)
      if ((*pos)->GetWatchSpec() == spec) {
        wp_sp = *pos;
        break;
      }
  }

  return wp_sp;
}

class WatchpointIDMatches {
public:
  WatchpointIDMatches(lldb::watch_id_t watch_id) : m_watch_id(watch_id) {}

  bool operator()(const WatchpointSP &wp) const {
    return m_watch_id == wp->GetID();
  }

private:
  const lldb::watch_id_t m_watch_id;
};

WatchpointList::wp_collection::iterator
WatchpointList::GetIDIterator(lldb::watch_id_t watch_id) {
  return std::find_if(m_watchpoints.begin(),
                      m_watchpoints.end(),            // Search full range
                      WatchpointIDMatches(watch_id)); // Predicate
}

WatchpointList::wp_collection::const_iterator
WatchpointList::GetIDConstIterator(lldb::watch_id_t watch_id) const {
  return std::find_if(m_watchpoints.begin(),
                      m_watchpoints.end(),            // Search full range
                      WatchpointIDMatches(watch_id)); // Predicate
}

WatchpointSP WatchpointList::FindByID(lldb::watch_id_t watch_id) const {
  WatchpointSP wp_sp;
  std::lock_guard<std::recursive_mutex> guard(m_mutex);
  wp_collection::const_iterator pos = GetIDConstIterator(watch_id);
  if (pos != m_watchpoints.end())
    wp_sp = *pos;

  return wp_sp;
}

lldb::watch_id_t WatchpointList::FindIDByAddress(lldb::addr_t addr) {
  WatchpointSP wp_sp = FindByAddress(addr);
  if (wp_sp) {
    return wp_sp->GetID();
  }
  return LLDB_INVALID_WATCH_ID;
}

lldb::watch_id_t WatchpointList::FindIDBySpec(std::string spec) {
  WatchpointSP wp_sp = FindBySpec(spec);
  if (wp_sp) {
    return wp_sp->GetID();
  }
  return LLDB_INVALID_WATCH_ID;
}

WatchpointSP WatchpointList::GetByIndex(uint32_t i) {
  std::lock_guard<std::recursive_mutex> guard(m_mutex);
  WatchpointSP wp_sp;
  if (i < m_watchpoints.size()) {
    wp_collection::const_iterator pos = m_watchpoints.begin();
    std::advance(pos, i);
    wp_sp = *pos;
  }
  return wp_sp;
}

const WatchpointSP WatchpointList::GetByIndex(uint32_t i) const {
  std::lock_guard<std::recursive_mutex> guard(m_mutex);
  WatchpointSP wp_sp;
  if (i < m_watchpoints.size()) {
    wp_collection::const_iterator pos = m_watchpoints.begin();
    std::advance(pos, i);
    wp_sp = *pos;
  }
  return wp_sp;
}

std::vector<lldb::watch_id_t> WatchpointList::GetWatchpointIDs() const {
  std::vector<lldb::watch_id_t> IDs;
  wp_collection::const_iterator pos, end = m_watchpoints.end();
  for (pos = m_watchpoints.begin(); pos != end; ++pos)
    IDs.push_back((*pos)->GetID());
  return IDs;
}

bool WatchpointList::Remove(lldb::watch_id_t watch_id, bool notify) {
  std::lock_guard<std::recursive_mutex> guard(m_mutex);
  wp_collection::iterator pos = GetIDIterator(watch_id);
  if (pos != m_watchpoints.end()) {
    WatchpointSP wp_sp = *pos;
    if (notify) {
      if (wp_sp->GetTarget().EventTypeHasListeners(
              Target::eBroadcastBitWatchpointChanged))
        wp_sp->GetTarget().BroadcastEvent(
            Target::eBroadcastBitWatchpointChanged,
            new Watchpoint::WatchpointEventData(eWatchpointEventTypeRemoved,
                                                wp_sp));
    }
    m_watchpoints.erase(pos);
    return true;
  }
  return false;
}

uint32_t WatchpointList::GetHitCount() const {
  uint32_t hit_count = 0;
  std::lock_guard<std::recursive_mutex> guard(m_mutex);
  wp_collection::const_iterator pos, end = m_watchpoints.end();
  for (pos = m_watchpoints.begin(); pos != end; ++pos)
    hit_count += (*pos)->GetHitCount();
  return hit_count;
}

bool WatchpointList::ShouldStop(StoppointCallbackContext *context,
                                lldb::watch_id_t watch_id) {

  WatchpointSP wp_sp = FindByID(watch_id);
  if (wp_sp) {
    // Let the Watchpoint 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.
    return wp_sp->ShouldStop(context);
  }
  // We should stop here since this Watchpoint isn't valid anymore or it
  // doesn't exist.
  return true;
}

void WatchpointList::GetDescription(Stream *s, lldb::DescriptionLevel level) {
  std::lock_guard<std::recursive_mutex> guard(m_mutex);
  wp_collection::iterator pos, end = m_watchpoints.end();

  for (pos = m_watchpoints.begin(); pos != end; ++pos) {
    s->Printf(" ");
    (*pos)->Dump(s);
  }
}

void WatchpointList::SetEnabledAll(bool enabled) {
  std::lock_guard<std::recursive_mutex> guard(m_mutex);

  wp_collection::iterator pos, end = m_watchpoints.end();
  for (pos = m_watchpoints.begin(); pos != end; ++pos)
    (*pos)->SetEnabled(enabled);
}

void WatchpointList::RemoveAll(bool notify) {
  std::lock_guard<std::recursive_mutex> guard(m_mutex);
  if (notify) {

    {
      wp_collection::iterator pos, end = m_watchpoints.end();
      for (pos = m_watchpoints.begin(); pos != end; ++pos) {
        if ((*pos)->GetTarget().EventTypeHasListeners(
                Target::eBroadcastBitBreakpointChanged)) {
          (*pos)->GetTarget().BroadcastEvent(
              Target::eBroadcastBitWatchpointChanged,
              new Watchpoint::WatchpointEventData(eWatchpointEventTypeRemoved,
                                                  *pos));
        }
      }
    }
  }
  m_watchpoints.clear();
}

void WatchpointList::GetListMutex(
    std::unique_lock<std::recursive_mutex> &lock) {
  lock = std::unique_lock<std::recursive_mutex>(m_mutex);
}