Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 1 | //===-- SBBreakpoint.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/API/SBBreakpoint.h" |
| 11 | #include "lldb/API/SBBreakpointLocation.h" |
| 12 | #include "lldb/API/SBDebugger.h" |
Greg Clayton | c7f5d5c | 2010-07-23 23:33:17 +0000 | [diff] [blame] | 13 | #include "lldb/API/SBEvent.h" |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 14 | #include "lldb/API/SBProcess.h" |
Caroline Tice | 98f930f | 2010-09-20 05:20:02 +0000 | [diff] [blame] | 15 | #include "lldb/API/SBStream.h" |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 16 | #include "lldb/API/SBThread.h" |
| 17 | |
| 18 | #include "lldb/Breakpoint/Breakpoint.h" |
| 19 | #include "lldb/Breakpoint/BreakpointLocation.h" |
| 20 | #include "lldb/Breakpoint/StoppointCallbackContext.h" |
| 21 | #include "lldb/Core/Address.h" |
| 22 | #include "lldb/Core/Stream.h" |
| 23 | #include "lldb/Core/StreamFile.h" |
| 24 | #include "lldb/Target/Process.h" |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 25 | #include "lldb/Target/Target.h" |
Jim Ingham | 8e5e38f | 2010-06-18 01:47:08 +0000 | [diff] [blame] | 26 | #include "lldb/Target/Thread.h" |
| 27 | #include "lldb/Target/ThreadSpec.h" |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 28 | |
| 29 | |
| 30 | #include "lldb/lldb-enumerations.h" |
| 31 | |
| 32 | using namespace lldb; |
| 33 | using namespace lldb_private; |
| 34 | |
| 35 | struct CallbackData |
| 36 | { |
| 37 | SBBreakpoint::BreakpointHitCallback callback; |
| 38 | void *callback_baton; |
| 39 | }; |
| 40 | |
| 41 | class SBBreakpointCallbackBaton : public Baton |
| 42 | { |
| 43 | public: |
| 44 | |
| 45 | SBBreakpointCallbackBaton (SBBreakpoint::BreakpointHitCallback callback, void *baton) : |
| 46 | Baton (new CallbackData) |
| 47 | { |
| 48 | CallbackData *data = (CallbackData *)m_data; |
| 49 | data->callback = callback; |
| 50 | data->callback_baton = baton; |
| 51 | } |
| 52 | |
| 53 | virtual ~SBBreakpointCallbackBaton() |
| 54 | { |
| 55 | CallbackData *data = (CallbackData *)m_data; |
| 56 | |
| 57 | if (data) |
| 58 | { |
| 59 | delete data; |
| 60 | m_data = NULL; |
| 61 | } |
| 62 | } |
| 63 | }; |
| 64 | |
| 65 | |
| 66 | SBBreakpoint::SBBreakpoint () : |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 67 | m_opaque_sp () |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 68 | { |
| 69 | } |
| 70 | |
| 71 | SBBreakpoint::SBBreakpoint (const SBBreakpoint& rhs) : |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 72 | m_opaque_sp (rhs.m_opaque_sp) |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 73 | { |
| 74 | } |
| 75 | |
| 76 | |
| 77 | SBBreakpoint::SBBreakpoint (const lldb::BreakpointSP &bp_sp) : |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 78 | m_opaque_sp (bp_sp) |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 79 | { |
| 80 | } |
| 81 | |
| 82 | SBBreakpoint::~SBBreakpoint() |
| 83 | { |
| 84 | } |
| 85 | |
| 86 | const SBBreakpoint & |
| 87 | SBBreakpoint::operator = (const SBBreakpoint& rhs) |
| 88 | { |
| 89 | if (this != &rhs) |
| 90 | { |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 91 | m_opaque_sp = rhs.m_opaque_sp; |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 92 | } |
| 93 | return *this; |
| 94 | } |
| 95 | |
| 96 | break_id_t |
| 97 | SBBreakpoint::GetID () const |
| 98 | { |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 99 | if (m_opaque_sp) |
| 100 | return m_opaque_sp->GetID(); |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 101 | return LLDB_INVALID_BREAK_ID; |
| 102 | } |
| 103 | |
| 104 | |
| 105 | bool |
| 106 | SBBreakpoint::IsValid() const |
| 107 | { |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 108 | return m_opaque_sp; |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 109 | } |
| 110 | |
| 111 | void |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 112 | SBBreakpoint::ClearAllBreakpointSites () |
| 113 | { |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 114 | if (m_opaque_sp) |
| 115 | m_opaque_sp->ClearAllBreakpointSites (); |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 116 | } |
| 117 | |
| 118 | SBBreakpointLocation |
| 119 | SBBreakpoint::FindLocationByAddress (addr_t vm_addr) |
| 120 | { |
| 121 | SBBreakpointLocation sb_bp_location; |
| 122 | |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 123 | if (m_opaque_sp) |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 124 | { |
| 125 | if (vm_addr != LLDB_INVALID_ADDRESS) |
| 126 | { |
| 127 | Address address; |
Greg Clayton | eea2640 | 2010-09-14 23:36:40 +0000 | [diff] [blame] | 128 | Target &target = m_opaque_sp->GetTarget(); |
| 129 | if (target.GetSectionLoadList().ResolveLoadAddress (vm_addr, address) == false) |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 130 | { |
| 131 | address.SetSection (NULL); |
| 132 | address.SetOffset (vm_addr); |
| 133 | } |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 134 | sb_bp_location.SetLocation (m_opaque_sp->FindLocationByAddress (address)); |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 135 | } |
| 136 | } |
| 137 | return sb_bp_location; |
| 138 | } |
| 139 | |
| 140 | break_id_t |
| 141 | SBBreakpoint::FindLocationIDByAddress (addr_t vm_addr) |
| 142 | { |
| 143 | break_id_t lldb_id = (break_id_t) 0; |
| 144 | |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 145 | if (m_opaque_sp) |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 146 | { |
| 147 | if (vm_addr != LLDB_INVALID_ADDRESS) |
| 148 | { |
| 149 | Address address; |
Greg Clayton | eea2640 | 2010-09-14 23:36:40 +0000 | [diff] [blame] | 150 | Target &target = m_opaque_sp->GetTarget(); |
| 151 | if (target.GetSectionLoadList().ResolveLoadAddress (vm_addr, address) == false) |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 152 | { |
| 153 | address.SetSection (NULL); |
| 154 | address.SetOffset (vm_addr); |
| 155 | } |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 156 | lldb_id = m_opaque_sp->FindLocationIDByAddress (address); |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 157 | } |
| 158 | } |
| 159 | |
| 160 | return lldb_id; |
| 161 | } |
| 162 | |
| 163 | SBBreakpointLocation |
| 164 | SBBreakpoint::FindLocationByID (break_id_t bp_loc_id) |
| 165 | { |
| 166 | SBBreakpointLocation sb_bp_location; |
| 167 | |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 168 | if (m_opaque_sp) |
| 169 | sb_bp_location.SetLocation (m_opaque_sp->FindLocationByID (bp_loc_id)); |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 170 | |
| 171 | return sb_bp_location; |
| 172 | } |
| 173 | |
| 174 | SBBreakpointLocation |
| 175 | SBBreakpoint::GetLocationAtIndex (uint32_t index) |
| 176 | { |
| 177 | SBBreakpointLocation sb_bp_location; |
| 178 | |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 179 | if (m_opaque_sp) |
| 180 | sb_bp_location.SetLocation (m_opaque_sp->GetLocationAtIndex (index)); |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 181 | |
| 182 | return sb_bp_location; |
| 183 | } |
| 184 | |
| 185 | void |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 186 | SBBreakpoint::SetEnabled (bool enable) |
| 187 | { |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 188 | if (m_opaque_sp) |
| 189 | m_opaque_sp->SetEnabled (enable); |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 190 | } |
| 191 | |
| 192 | bool |
| 193 | SBBreakpoint::IsEnabled () |
| 194 | { |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 195 | if (m_opaque_sp) |
| 196 | return m_opaque_sp->IsEnabled(); |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 197 | else |
| 198 | return false; |
| 199 | } |
| 200 | |
| 201 | void |
Greg Clayton | 54e7afa | 2010-07-09 20:39:50 +0000 | [diff] [blame] | 202 | SBBreakpoint::SetIgnoreCount (uint32_t count) |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 203 | { |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 204 | if (m_opaque_sp) |
| 205 | m_opaque_sp->SetIgnoreCount (count); |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 206 | } |
| 207 | |
Jim Ingham | e374083 | 2010-10-22 01:15:49 +0000 | [diff] [blame^] | 208 | void |
| 209 | SBBreakpoint::SetCondition (const char *condition) |
| 210 | { |
| 211 | m_opaque_sp->SetCondition (condition); |
| 212 | } |
| 213 | |
| 214 | const char * |
| 215 | SBBreakpoint::GetCondition () |
| 216 | { |
| 217 | return m_opaque_sp->GetConditionText (); |
| 218 | } |
| 219 | |
Greg Clayton | 54e7afa | 2010-07-09 20:39:50 +0000 | [diff] [blame] | 220 | uint32_t |
Greg Clayton | c7f5d5c | 2010-07-23 23:33:17 +0000 | [diff] [blame] | 221 | SBBreakpoint::GetHitCount () const |
| 222 | { |
| 223 | if (m_opaque_sp) |
| 224 | return m_opaque_sp->GetHitCount(); |
| 225 | else |
| 226 | return 0; |
| 227 | } |
| 228 | |
| 229 | uint32_t |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 230 | SBBreakpoint::GetIgnoreCount () const |
| 231 | { |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 232 | if (m_opaque_sp) |
| 233 | return m_opaque_sp->GetIgnoreCount(); |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 234 | else |
| 235 | return 0; |
| 236 | } |
| 237 | |
| 238 | void |
| 239 | SBBreakpoint::SetThreadID (tid_t sb_thread_id) |
| 240 | { |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 241 | if (m_opaque_sp) |
| 242 | m_opaque_sp->SetThreadID (sb_thread_id); |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 243 | } |
| 244 | |
| 245 | tid_t |
| 246 | SBBreakpoint::GetThreadID () |
| 247 | { |
| 248 | tid_t lldb_thread_id = LLDB_INVALID_THREAD_ID; |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 249 | if (m_opaque_sp) |
| 250 | lldb_thread_id = m_opaque_sp->GetThreadID(); |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 251 | |
| 252 | return lldb_thread_id; |
| 253 | } |
| 254 | |
Jim Ingham | 8e5e38f | 2010-06-18 01:47:08 +0000 | [diff] [blame] | 255 | void |
| 256 | SBBreakpoint::SetThreadIndex (uint32_t index) |
| 257 | { |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 258 | if (m_opaque_sp) |
| 259 | m_opaque_sp->GetOptions()->GetThreadSpec()->SetIndex (index); |
Jim Ingham | 8e5e38f | 2010-06-18 01:47:08 +0000 | [diff] [blame] | 260 | } |
| 261 | |
| 262 | uint32_t |
| 263 | SBBreakpoint::GetThreadIndex() const |
| 264 | { |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 265 | if (m_opaque_sp) |
Jim Ingham | 8e5e38f | 2010-06-18 01:47:08 +0000 | [diff] [blame] | 266 | { |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 267 | const ThreadSpec *thread_spec = m_opaque_sp->GetOptions()->GetThreadSpec(); |
Jim Ingham | 8e5e38f | 2010-06-18 01:47:08 +0000 | [diff] [blame] | 268 | if (thread_spec == NULL) |
| 269 | return 0; |
| 270 | else |
| 271 | return thread_spec->GetIndex(); |
| 272 | } |
| 273 | return 0; |
| 274 | } |
| 275 | |
| 276 | |
| 277 | void |
| 278 | SBBreakpoint::SetThreadName (const char *thread_name) |
| 279 | { |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 280 | if (m_opaque_sp) |
| 281 | m_opaque_sp->GetOptions()->GetThreadSpec()->SetName (thread_name); |
Jim Ingham | 8e5e38f | 2010-06-18 01:47:08 +0000 | [diff] [blame] | 282 | } |
| 283 | |
| 284 | const char * |
| 285 | SBBreakpoint::GetThreadName () const |
| 286 | { |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 287 | if (m_opaque_sp) |
Jim Ingham | 8e5e38f | 2010-06-18 01:47:08 +0000 | [diff] [blame] | 288 | { |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 289 | const ThreadSpec *thread_spec = m_opaque_sp->GetOptions()->GetThreadSpec(); |
Jim Ingham | 8e5e38f | 2010-06-18 01:47:08 +0000 | [diff] [blame] | 290 | if (thread_spec == NULL) |
| 291 | return NULL; |
| 292 | else |
| 293 | return thread_spec->GetName(); |
| 294 | } |
| 295 | return NULL; |
| 296 | } |
| 297 | |
| 298 | void |
| 299 | SBBreakpoint::SetQueueName (const char *queue_name) |
| 300 | { |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 301 | if (m_opaque_sp) |
| 302 | m_opaque_sp->GetOptions()->GetThreadSpec()->SetQueueName (queue_name); |
Jim Ingham | 8e5e38f | 2010-06-18 01:47:08 +0000 | [diff] [blame] | 303 | } |
| 304 | |
| 305 | const char * |
| 306 | SBBreakpoint::GetQueueName () const |
| 307 | { |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 308 | if (m_opaque_sp) |
Jim Ingham | 8e5e38f | 2010-06-18 01:47:08 +0000 | [diff] [blame] | 309 | { |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 310 | const ThreadSpec *thread_spec = m_opaque_sp->GetOptions()->GetThreadSpec(); |
Jim Ingham | 8e5e38f | 2010-06-18 01:47:08 +0000 | [diff] [blame] | 311 | if (thread_spec == NULL) |
| 312 | return NULL; |
| 313 | else |
| 314 | return thread_spec->GetQueueName(); |
| 315 | } |
| 316 | return NULL; |
| 317 | } |
| 318 | |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 319 | size_t |
| 320 | SBBreakpoint::GetNumResolvedLocations() const |
| 321 | { |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 322 | if (m_opaque_sp) |
| 323 | return m_opaque_sp->GetNumResolvedLocations(); |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 324 | else |
| 325 | return 0; |
| 326 | } |
| 327 | |
| 328 | size_t |
| 329 | SBBreakpoint::GetNumLocations() const |
| 330 | { |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 331 | if (m_opaque_sp) |
| 332 | return m_opaque_sp->GetNumLocations(); |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 333 | else |
| 334 | return 0; |
| 335 | } |
| 336 | |
Caroline Tice | 98f930f | 2010-09-20 05:20:02 +0000 | [diff] [blame] | 337 | bool |
Greg Clayton | d8c6253 | 2010-10-07 04:19:01 +0000 | [diff] [blame] | 338 | SBBreakpoint::GetDescription (SBStream &s) |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 339 | { |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 340 | if (m_opaque_sp) |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 341 | { |
Greg Clayton | d8c6253 | 2010-10-07 04:19:01 +0000 | [diff] [blame] | 342 | s.Printf("SBBreakpoint: id = %i, ", m_opaque_sp->GetID()); |
| 343 | m_opaque_sp->GetResolverDescription (s.get()); |
| 344 | m_opaque_sp->GetFilterDescription (s.get()); |
| 345 | const size_t num_locations = m_opaque_sp->GetNumLocations (); |
| 346 | s.Printf(", locations = %zu", num_locations); |
| 347 | return true; |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 348 | } |
Greg Clayton | d8c6253 | 2010-10-07 04:19:01 +0000 | [diff] [blame] | 349 | s.Printf ("No value"); |
| 350 | return false; |
Caroline Tice | 98f930f | 2010-09-20 05:20:02 +0000 | [diff] [blame] | 351 | } |
| 352 | |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 353 | bool |
| 354 | SBBreakpoint::PrivateBreakpointHitCallback |
| 355 | ( |
| 356 | void *baton, |
| 357 | StoppointCallbackContext *ctx, |
| 358 | lldb::user_id_t break_id, |
| 359 | lldb::user_id_t break_loc_id |
| 360 | ) |
| 361 | { |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 362 | BreakpointSP bp_sp(ctx->exe_ctx.target->GetBreakpointList().FindBreakpointByID(break_id)); |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 363 | if (baton && bp_sp) |
| 364 | { |
| 365 | CallbackData *data = (CallbackData *)baton; |
| 366 | lldb_private::Breakpoint *bp = bp_sp.get(); |
| 367 | if (bp && data->callback) |
| 368 | { |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 369 | if (ctx->exe_ctx.process) |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 370 | { |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 371 | SBProcess sb_process (ctx->exe_ctx.process->GetSP()); |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 372 | SBThread sb_thread; |
| 373 | SBBreakpointLocation sb_location; |
| 374 | assert (bp_sp); |
| 375 | sb_location.SetLocation (bp_sp->FindLocationByID (break_loc_id)); |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 376 | if (ctx->exe_ctx.thread) |
| 377 | sb_thread.SetThread(ctx->exe_ctx.thread->GetSP()); |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 378 | |
| 379 | return data->callback (data->callback_baton, |
| 380 | sb_process, |
| 381 | sb_thread, |
| 382 | sb_location); |
| 383 | } |
| 384 | } |
| 385 | } |
| 386 | return true; // Return true if we should stop at this breakpoint |
| 387 | } |
| 388 | |
| 389 | void |
| 390 | SBBreakpoint::SetCallback (BreakpointHitCallback callback, void *baton) |
| 391 | { |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 392 | if (m_opaque_sp.get()) |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 393 | { |
| 394 | BatonSP baton_sp(new SBBreakpointCallbackBaton (callback, baton)); |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 395 | m_opaque_sp->SetCallback (SBBreakpoint::PrivateBreakpointHitCallback, baton_sp, false); |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 396 | } |
| 397 | } |
| 398 | |
| 399 | |
| 400 | lldb_private::Breakpoint * |
| 401 | SBBreakpoint::operator->() const |
| 402 | { |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 403 | return m_opaque_sp.get(); |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 404 | } |
| 405 | |
| 406 | lldb_private::Breakpoint * |
| 407 | SBBreakpoint::get() const |
| 408 | { |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 409 | return m_opaque_sp.get(); |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 410 | } |
| 411 | |
| 412 | lldb::BreakpointSP & |
| 413 | SBBreakpoint::operator *() |
| 414 | { |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 415 | return m_opaque_sp; |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 416 | } |
| 417 | |
| 418 | const lldb::BreakpointSP & |
| 419 | SBBreakpoint::operator *() const |
| 420 | { |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 421 | return m_opaque_sp; |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 422 | } |
| 423 | |
Greg Clayton | c7f5d5c | 2010-07-23 23:33:17 +0000 | [diff] [blame] | 424 | BreakpointEventType |
| 425 | SBBreakpoint::GetBreakpointEventTypeFromEvent (const SBEvent& event) |
| 426 | { |
| 427 | if (event.IsValid()) |
| 428 | return Breakpoint::BreakpointEventData::GetBreakpointEventTypeFromEvent (event.GetSP()); |
| 429 | return eBreakpointEventTypeInvalidType; |
| 430 | } |
| 431 | |
| 432 | SBBreakpoint |
| 433 | SBBreakpoint::GetBreakpointFromEvent (const lldb::SBEvent& event) |
| 434 | { |
| 435 | SBBreakpoint sb_breakpoint; |
| 436 | if (event.IsValid()) |
| 437 | sb_breakpoint.m_opaque_sp = Breakpoint::BreakpointEventData::GetBreakpointFromEvent (event.GetSP()); |
| 438 | return sb_breakpoint; |
| 439 | } |
| 440 | |
| 441 | SBBreakpointLocation |
| 442 | SBBreakpoint::GetBreakpointLocationAtIndexFromEvent (const lldb::SBEvent& event, uint32_t loc_idx) |
| 443 | { |
| 444 | SBBreakpointLocation sb_breakpoint_loc; |
| 445 | if (event.IsValid()) |
| 446 | sb_breakpoint_loc.SetLocation (Breakpoint::BreakpointEventData::GetBreakpointLocationAtIndexFromEvent (event.GetSP(), loc_idx)); |
| 447 | return sb_breakpoint_loc; |
| 448 | } |
| 449 | |
| 450 | |