lldb/source/Breakpoint/BreakpointSite.cpp

   1 //===-- BreakpointSite.cpp ------------------------------------------------===//
   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 <cinttypes>
  10
  11 #include "lldb/Breakpoint/BreakpointSite.h"
  12
  13 #include "lldb/Breakpoint/Breakpoint.h"
  14 #include "lldb/Breakpoint/BreakpointLocation.h"
  15 #include "lldb/Utility/Stream.h"
  16
  17 using namespace lldb;
  18 using namespace lldb_private;
  19
  20 BreakpointSite::BreakpointSite(const BreakpointLocationSP &constituent,
  21                                lldb::addr_t addr, bool use_hardware)
  22     : StoppointSite(GetNextID(), addr, 0, use_hardware),
  23       m_type(eSoftware), // Process subclasses need to set this correctly using
  24                          // SetType()
  25       m_saved_opcode(), m_trap_opcode(),
  26       m_enabled(false) // Need to create it disabled, so the first enable turns
  27                        // it on.
  28 {
  29   m_constituents.Add(constituent);
  30 }
  31
  32 BreakpointSite::~BreakpointSite() {
  33   BreakpointLocationSP bp_loc_sp;
  34   const size_t constituent_count = m_constituents.GetSize();
  35   for (size_t i = 0; i < constituent_count; i++) {
  36     m_constituents.GetByIndex(i)->ClearBreakpointSite();
  37   }
  38 }
  39
  40 break_id_t BreakpointSite::GetNextID() {
  41   static break_id_t g_next_id = 0;
  42   return ++g_next_id;
  43 }
  44
  45 // RETURNS - true if we should stop at this breakpoint, false if we
  46 // should continue.
  47
  48 bool BreakpointSite::ShouldStop(StoppointCallbackContext *context) {
  49   m_hit_counter.Increment();
  50   // ShouldStop can do a lot of work, and might even come back and hit
  51   // this breakpoint site again.  So don't hold the m_constituents_mutex the
  52   // whole while.  Instead make a local copy of the collection and call
  53   // ShouldStop on the copy.
  54   BreakpointLocationCollection constituents_copy;
  55   {
  56     std::lock_guard<std::recursive_mutex> guard(m_constituents_mutex);
  57     constituents_copy = m_constituents;
  58   }
  59   return constituents_copy.ShouldStop(context);
  60 }
  61
  62 bool BreakpointSite::IsBreakpointAtThisSite(lldb::break_id_t bp_id) {
  63   std::lock_guard<std::recursive_mutex> guard(m_constituents_mutex);
  64   const size_t constituent_count = m_constituents.GetSize();
  65   for (size_t i = 0; i < constituent_count; i++) {
  66     if (m_constituents.GetByIndex(i)->GetBreakpoint().GetID() == bp_id)
  67       return true;
  68   }
  69   return false;
  70 }
  71
  72 void BreakpointSite::Dump(Stream *s) const {
  73   if (s == nullptr)
  74     return;
  75
  76   s->Printf("BreakpointSite %u: addr = 0x%8.8" PRIx64
  77             "  type = %s breakpoint  hit_count = %-4u",
  78             GetID(), (uint64_t)m_addr, IsHardware() ? "hardware" : "software",
  79             GetHitCount());
  80 }
  81
  82 void BreakpointSite::GetDescription(Stream *s, lldb::DescriptionLevel level) {
  83   std::lock_guard<std::recursive_mutex> guard(m_constituents_mutex);
  84   if (level != lldb::eDescriptionLevelBrief)
  85     s->Printf("breakpoint site: %d at 0x%8.8" PRIx64, GetID(),
  86               GetLoadAddress());
  87   m_constituents.GetDescription(s, level);
  88 }
  89
  90 std::optional<uint32_t> BreakpointSite::GetSuggestedStackFrameIndex() {
  91
  92   std::optional<uint32_t> result;
  93   std::lock_guard<std::recursive_mutex> guard(m_constituents_mutex);
  94   for (BreakpointLocationSP loc_sp : m_constituents.BreakpointLocations()) {
  95     std::optional<uint32_t> loc_frame_index =
  96         loc_sp->GetSuggestedStackFrameIndex();
  97     if (loc_frame_index) {
  98       if (result)
  99         result = std::max(*loc_frame_index, *result);
 100       else
 101         result = loc_frame_index;
 102     }
 103   }
 104   return result;
 105 }
 106
 107 bool BreakpointSite::IsInternal() const { return m_constituents.IsInternal(); }
 108
 109 uint8_t *BreakpointSite::GetTrapOpcodeBytes() { return &m_trap_opcode[0]; }
 110
 111 const uint8_t *BreakpointSite::GetTrapOpcodeBytes() const {
 112   return &m_trap_opcode[0];
 113 }
 114
 115 size_t BreakpointSite::GetTrapOpcodeMaxByteSize() const {
 116   return sizeof(m_trap_opcode);
 117 }
 118
 119 bool BreakpointSite::SetTrapOpcode(const uint8_t *trap_opcode,
 120                                    uint32_t trap_opcode_size) {
 121   if (trap_opcode_size > 0 && trap_opcode_size <= sizeof(m_trap_opcode)) {
 122     m_byte_size = trap_opcode_size;
 123     ::memcpy(m_trap_opcode, trap_opcode, trap_opcode_size);
 124     return true;
 125   }
 126   m_byte_size = 0;
 127   return false;
 128 }
 129
 130 uint8_t *BreakpointSite::GetSavedOpcodeBytes() { return &m_saved_opcode[0]; }
 131
 132 const uint8_t *BreakpointSite::GetSavedOpcodeBytes() const {
 133   return &m_saved_opcode[0];
 134 }
 135
 136 bool BreakpointSite::IsEnabled() const { return m_enabled; }
 137
 138 void BreakpointSite::SetEnabled(bool enabled) { m_enabled = enabled; }
 139
 140 void BreakpointSite::AddConstituent(const BreakpointLocationSP &constituent) {
 141   std::lock_guard<std::recursive_mutex> guard(m_constituents_mutex);
 142   m_constituents.Add(constituent);
 143 }
 144
 145 size_t BreakpointSite::RemoveConstituent(lldb::break_id_t break_id,
 146                                          lldb::break_id_t break_loc_id) {
 147   std::lock_guard<std::recursive_mutex> guard(m_constituents_mutex);
 148   m_constituents.Remove(break_id, break_loc_id);
 149   return m_constituents.GetSize();
 150 }
 151
 152 size_t BreakpointSite::GetNumberOfConstituents() {
 153   std::lock_guard<std::recursive_mutex> guard(m_constituents_mutex);
 154   return m_constituents.GetSize();
 155 }
 156
 157 BreakpointLocationSP BreakpointSite::GetConstituentAtIndex(size_t index) {
 158   std::lock_guard<std::recursive_mutex> guard(m_constituents_mutex);
 159   return m_constituents.GetByIndex(index);
 160 }
 161
 162 bool BreakpointSite::ValidForThisThread(Thread &thread) {
 163   std::lock_guard<std::recursive_mutex> guard(m_constituents_mutex);
 164   return m_constituents.ValidForThisThread(thread);
 165 }
 166
 167 void BreakpointSite::BumpHitCounts() {
 168   std::lock_guard<std::recursive_mutex> guard(m_constituents_mutex);
 169   for (BreakpointLocationSP loc_sp : m_constituents.BreakpointLocations()) {
 170     loc_sp->BumpHitCount();
 171   }
 172 }
 173
 174 bool BreakpointSite::IntersectsRange(lldb::addr_t addr, size_t size,
 175                                      lldb::addr_t *intersect_addr,
 176                                      size_t *intersect_size,
 177                                      size_t *opcode_offset) const {
 178   // The function should be called only for software breakpoints.
 179   lldbassert(GetType() == Type::eSoftware);
 180
 181   if (m_byte_size == 0)
 182     return false;
 183
 184   const lldb::addr_t bp_end_addr = m_addr + m_byte_size;
 185   const lldb::addr_t end_addr = addr + size;
 186   // Is the breakpoint end address before the passed in start address?
 187   if (bp_end_addr <= addr)
 188     return false;
 189
 190   // Is the breakpoint start address after passed in end address?
 191   if (end_addr <= m_addr)
 192     return false;
 193
 194   if (intersect_addr || intersect_size || opcode_offset) {
 195     if (m_addr < addr) {
 196       if (intersect_addr)
 197         *intersect_addr = addr;
 198       if (intersect_size)
 199         *intersect_size =
 200             std::min<lldb::addr_t>(bp_end_addr, end_addr) - addr;
 201       if (opcode_offset)
 202         *opcode_offset = addr - m_addr;
 203     } else {
 204       if (intersect_addr)
 205         *intersect_addr = m_addr;
 206       if (intersect_size)
 207         *intersect_size =
 208             std::min<lldb::addr_t>(bp_end_addr, end_addr) - m_addr;
 209       if (opcode_offset)
 210         *opcode_offset = 0;
 211     }
 212   }
 213   return true;
 214 }
 215
 216 size_t BreakpointSite::CopyConstituentsList(
 217     BreakpointLocationCollection &out_collection) {
 218   std::lock_guard<std::recursive_mutex> guard(m_constituents_mutex);
 219   for (BreakpointLocationSP loc_sp : m_constituents.BreakpointLocations()) {
 220     out_collection.Add(loc_sp);
 221   }
 222   return out_collection.GetSize();
 223 }