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