BreakpointLocationList.h revision 314564
1//===-- BreakpointLocationList.h --------------------------------*- 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#ifndef liblldb_BreakpointLocationList_h_ 11#define liblldb_BreakpointLocationList_h_ 12 13// C Includes 14// C++ Includes 15#include <map> 16#include <mutex> 17#include <vector> 18 19// Other libraries and framework includes 20// Project includes 21#include "lldb/Core/Address.h" 22#include "lldb/Utility/Iterable.h" 23#include "lldb/lldb-private.h" 24 25namespace lldb_private { 26 27//---------------------------------------------------------------------- 28/// @class BreakpointLocationList BreakpointLocationList.h 29/// "lldb/Breakpoint/BreakpointLocationList.h" 30/// @brief This class is used by Breakpoint to manage a list of breakpoint 31/// locations, 32// each breakpoint location in the list 33/// has a unique ID, and is unique by Address as well. 34//---------------------------------------------------------------------- 35 36class BreakpointLocationList { 37 // Only Breakpoints can make the location list, or add elements to it. 38 // This is not just some random collection of locations. Rather, the act of 39 // adding the location 40 // to this list sets its ID, and implicitly all the locations have the same 41 // breakpoint ID as 42 // well. If you need a generic container for breakpoint locations, use 43 // BreakpointLocationCollection. 44 friend class Breakpoint; 45 46public: 47 virtual ~BreakpointLocationList(); 48 49 //------------------------------------------------------------------ 50 /// Standard "Dump" method. At present it does nothing. 51 //------------------------------------------------------------------ 52 void Dump(Stream *s) const; 53 54 //------------------------------------------------------------------ 55 /// Returns a shared pointer to the breakpoint location at address 56 /// \a addr - const version. 57 /// 58 /// @param[in] addr 59 /// The address to look for. 60 /// 61 /// @result 62 /// A shared pointer to the breakpoint. May contain a nullptr 63 /// pointer if the breakpoint doesn't exist. 64 //------------------------------------------------------------------ 65 const lldb::BreakpointLocationSP FindByAddress(const Address &addr) const; 66 67 //------------------------------------------------------------------ 68 /// Returns a shared pointer to the breakpoint location with id 69 /// \a breakID, const version. 70 /// 71 /// @param[in] breakID 72 /// The breakpoint location ID to seek for. 73 /// 74 /// @result 75 /// A shared pointer to the breakpoint. May contain a nullptr 76 /// pointer if the breakpoint doesn't exist. 77 //------------------------------------------------------------------ 78 lldb::BreakpointLocationSP FindByID(lldb::break_id_t breakID) const; 79 80 //------------------------------------------------------------------ 81 /// Returns the breakpoint location id to the breakpoint location 82 /// at address \a addr. 83 /// 84 /// @param[in] addr 85 /// The address to match. 86 /// 87 /// @result 88 /// The ID of the breakpoint location, or LLDB_INVALID_BREAK_ID. 89 //------------------------------------------------------------------ 90 lldb::break_id_t FindIDByAddress(const Address &addr); 91 92 //------------------------------------------------------------------ 93 /// Returns a breakpoint location list of the breakpoint locations 94 /// in the module \a module. This list is allocated, and owned by 95 /// the caller. 96 /// 97 /// @param[in] module 98 /// The module to seek in. 99 /// 100 /// @param[in] 101 /// A breakpoint collection that gets any breakpoint locations 102 /// that match \a module appended to. 103 /// 104 /// @result 105 /// The number of matches 106 //------------------------------------------------------------------ 107 size_t FindInModule(Module *module, 108 BreakpointLocationCollection &bp_loc_list); 109 110 //------------------------------------------------------------------ 111 /// Returns a shared pointer to the breakpoint location with 112 /// index \a i. 113 /// 114 /// @param[in] i 115 /// The breakpoint location index to seek for. 116 /// 117 /// @result 118 /// A shared pointer to the breakpoint. May contain a nullptr 119 /// pointer if the breakpoint doesn't exist. 120 //------------------------------------------------------------------ 121 lldb::BreakpointLocationSP GetByIndex(size_t i); 122 123 //------------------------------------------------------------------ 124 /// Returns a shared pointer to the breakpoint location with index 125 /// \a i, const version. 126 /// 127 /// @param[in] i 128 /// The breakpoint location index to seek for. 129 /// 130 /// @result 131 /// A shared pointer to the breakpoint. May contain a nullptr 132 /// pointer if the breakpoint doesn't exist. 133 //------------------------------------------------------------------ 134 const lldb::BreakpointLocationSP GetByIndex(size_t i) const; 135 136 //------------------------------------------------------------------ 137 /// Removes all the locations in this list from their breakpoint site 138 /// owners list. 139 //------------------------------------------------------------------ 140 void ClearAllBreakpointSites(); 141 142 //------------------------------------------------------------------ 143 /// Tells all the breakpoint locations in this list to attempt to 144 /// resolve any possible breakpoint sites. 145 //------------------------------------------------------------------ 146 void ResolveAllBreakpointSites(); 147 148 //------------------------------------------------------------------ 149 /// Returns the number of breakpoint locations in this list with 150 /// resolved breakpoints. 151 /// 152 /// @result 153 /// Number of qualifying breakpoint locations. 154 //------------------------------------------------------------------ 155 size_t GetNumResolvedLocations() const; 156 157 //------------------------------------------------------------------ 158 /// Returns the number hit count of all locations in this list. 159 /// 160 /// @result 161 /// Hit count of all locations in this list. 162 //------------------------------------------------------------------ 163 uint32_t GetHitCount() const; 164 165 //------------------------------------------------------------------ 166 /// Enquires of the breakpoint location in this list with ID \a 167 /// breakID whether we should stop. 168 /// 169 /// @param[in] context 170 /// This contains the information about this stop. 171 /// 172 /// @param[in] breakID 173 /// This break ID that we hit. 174 /// 175 /// @return 176 /// \b true if we should stop, \b false otherwise. 177 //------------------------------------------------------------------ 178 bool ShouldStop(StoppointCallbackContext *context, lldb::break_id_t breakID); 179 180 //------------------------------------------------------------------ 181 /// Returns the number of elements in this breakpoint location list. 182 /// 183 /// @result 184 /// The number of elements. 185 //------------------------------------------------------------------ 186 size_t GetSize() const { return m_locations.size(); } 187 188 //------------------------------------------------------------------ 189 /// Print a description of the breakpoint locations in this list to 190 /// the stream \a s. 191 /// 192 /// @param[in] s 193 /// The stream to which to print the description. 194 /// 195 /// @param[in] level 196 /// The description level that indicates the detail level to 197 /// provide. 198 /// 199 /// @see lldb::DescriptionLevel 200 //------------------------------------------------------------------ 201 void GetDescription(Stream *s, lldb::DescriptionLevel level); 202 203protected: 204 //------------------------------------------------------------------ 205 /// This is the standard constructor. 206 /// 207 /// It creates an empty breakpoint location list. It is protected 208 /// here because only Breakpoints are allowed to create the 209 /// breakpoint location list. 210 //------------------------------------------------------------------ 211 BreakpointLocationList(Breakpoint &owner); 212 213 //------------------------------------------------------------------ 214 /// Add the breakpoint \a bp_loc_sp to the list. 215 /// 216 /// @param[in] bp_sp 217 /// Shared pointer to the breakpoint location that will get 218 /// added to the list. 219 /// 220 /// @result 221 /// Returns breakpoint location id. 222 //------------------------------------------------------------------ 223 lldb::BreakpointLocationSP Create(const Address &addr, 224 bool resolve_indirect_symbols); 225 226 void StartRecordingNewLocations(BreakpointLocationCollection &new_locations); 227 228 void StopRecordingNewLocations(); 229 230 lldb::BreakpointLocationSP AddLocation(const Address &addr, 231 bool resolve_indirect_symbols, 232 bool *new_location = nullptr); 233 234 void SwapLocation(lldb::BreakpointLocationSP to_location_sp, 235 lldb::BreakpointLocationSP from_location_sp); 236 237 bool RemoveLocation(const lldb::BreakpointLocationSP &bp_loc_sp); 238 239 void RemoveInvalidLocations(const ArchSpec &arch); 240 241 void Compact(); 242 243 typedef std::vector<lldb::BreakpointLocationSP> collection; 244 typedef std::map<lldb_private::Address, lldb::BreakpointLocationSP, 245 Address::ModulePointerAndOffsetLessThanFunctionObject> 246 addr_map; 247 248 Breakpoint &m_owner; 249 collection m_locations; // Vector of locations, sorted by ID 250 addr_map m_address_to_location; 251 mutable std::recursive_mutex m_mutex; 252 lldb::break_id_t m_next_id; 253 BreakpointLocationCollection *m_new_location_recorder; 254 255public: 256 typedef AdaptedIterable<collection, lldb::BreakpointLocationSP, 257 vector_adapter> 258 BreakpointLocationIterable; 259 260 BreakpointLocationIterable BreakpointLocations() { 261 return BreakpointLocationIterable(m_locations); 262 } 263}; 264 265} // namespace lldb_private 266 267#endif // liblldb_BreakpointLocationList_h_ 268