1 | //===-- Breakpoint.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 "llvm/Support/Casting.h" |
10 | |
11 | #include "lldb/Breakpoint/Breakpoint.h" |
12 | #include "lldb/Breakpoint/BreakpointLocation.h" |
13 | #include "lldb/Breakpoint/BreakpointLocationCollection.h" |
14 | #include "lldb/Breakpoint/BreakpointPrecondition.h" |
15 | #include "lldb/Breakpoint/BreakpointResolver.h" |
16 | #include "lldb/Breakpoint/BreakpointResolverFileLine.h" |
17 | #include "lldb/Core/Address.h" |
18 | #include "lldb/Core/Module.h" |
19 | #include "lldb/Core/ModuleList.h" |
20 | #include "lldb/Core/SearchFilter.h" |
21 | #include "lldb/Core/Section.h" |
22 | #include "lldb/Symbol/CompileUnit.h" |
23 | #include "lldb/Symbol/Function.h" |
24 | #include "lldb/Symbol/Symbol.h" |
25 | #include "lldb/Symbol/SymbolContext.h" |
26 | #include "lldb/Target/SectionLoadList.h" |
27 | #include "lldb/Target/Target.h" |
28 | #include "lldb/Target/ThreadSpec.h" |
29 | #include "lldb/Utility/LLDBLog.h" |
30 | #include "lldb/Utility/Log.h" |
31 | #include "lldb/Utility/Stream.h" |
32 | #include "lldb/Utility/StreamString.h" |
33 | |
34 | #include <memory> |
35 | |
36 | using namespace lldb; |
37 | using namespace lldb_private; |
38 | using namespace llvm; |
39 | |
40 | const char *Breakpoint::g_option_names[static_cast<uint32_t>( |
41 | Breakpoint::OptionNames::LastOptionName)]{"Names" , "Hardware" }; |
42 | |
43 | // Breakpoint constructor |
44 | Breakpoint::Breakpoint(Target &target, SearchFilterSP &filter_sp, |
45 | BreakpointResolverSP &resolver_sp, bool hardware, |
46 | bool resolve_indirect_symbols) |
47 | : m_hardware(hardware), m_target(target), m_filter_sp(filter_sp), |
48 | m_resolver_sp(resolver_sp), m_options(true), m_locations(*this), |
49 | m_resolve_indirect_symbols(resolve_indirect_symbols), m_hit_counter() {} |
50 | |
51 | Breakpoint::Breakpoint(Target &new_target, const Breakpoint &source_bp) |
52 | : m_hardware(source_bp.m_hardware), m_target(new_target), |
53 | m_name_list(source_bp.m_name_list), m_options(source_bp.m_options), |
54 | m_locations(*this), |
55 | m_resolve_indirect_symbols(source_bp.m_resolve_indirect_symbols), |
56 | m_hit_counter() {} |
57 | |
58 | // Destructor |
59 | Breakpoint::~Breakpoint() = default; |
60 | |
61 | BreakpointSP Breakpoint::CopyFromBreakpoint(TargetSP new_target, |
62 | const Breakpoint& bp_to_copy_from) { |
63 | if (!new_target) |
64 | return BreakpointSP(); |
65 | |
66 | BreakpointSP bp(new Breakpoint(*new_target, bp_to_copy_from)); |
67 | // Now go through and copy the filter & resolver: |
68 | bp->m_resolver_sp = bp_to_copy_from.m_resolver_sp->CopyForBreakpoint(breakpoint&: bp); |
69 | bp->m_filter_sp = bp_to_copy_from.m_filter_sp->CreateCopy(target_sp&: new_target); |
70 | return bp; |
71 | } |
72 | |
73 | // Serialization |
74 | StructuredData::ObjectSP Breakpoint::SerializeToStructuredData() { |
75 | // Serialize the resolver: |
76 | StructuredData::DictionarySP breakpoint_dict_sp( |
77 | new StructuredData::Dictionary()); |
78 | StructuredData::DictionarySP breakpoint_contents_sp( |
79 | new StructuredData::Dictionary()); |
80 | |
81 | if (!m_name_list.empty()) { |
82 | StructuredData::ArraySP names_array_sp(new StructuredData::Array()); |
83 | for (auto name : m_name_list) { |
84 | names_array_sp->AddItem( |
85 | item: StructuredData::StringSP(new StructuredData::String(name))); |
86 | } |
87 | breakpoint_contents_sp->AddItem(key: Breakpoint::GetKey(enum_value: OptionNames::Names), |
88 | value_sp: names_array_sp); |
89 | } |
90 | |
91 | breakpoint_contents_sp->AddBooleanItem( |
92 | key: Breakpoint::GetKey(enum_value: OptionNames::Hardware), value: m_hardware); |
93 | |
94 | StructuredData::ObjectSP resolver_dict_sp( |
95 | m_resolver_sp->SerializeToStructuredData()); |
96 | if (!resolver_dict_sp) |
97 | return StructuredData::ObjectSP(); |
98 | |
99 | breakpoint_contents_sp->AddItem(key: BreakpointResolver::GetSerializationKey(), |
100 | value_sp: resolver_dict_sp); |
101 | |
102 | StructuredData::ObjectSP filter_dict_sp( |
103 | m_filter_sp->SerializeToStructuredData()); |
104 | if (!filter_dict_sp) |
105 | return StructuredData::ObjectSP(); |
106 | |
107 | breakpoint_contents_sp->AddItem(key: SearchFilter::GetSerializationKey(), |
108 | value_sp: filter_dict_sp); |
109 | |
110 | StructuredData::ObjectSP options_dict_sp( |
111 | m_options.SerializeToStructuredData()); |
112 | if (!options_dict_sp) |
113 | return StructuredData::ObjectSP(); |
114 | |
115 | breakpoint_contents_sp->AddItem(key: BreakpointOptions::GetSerializationKey(), |
116 | value_sp: options_dict_sp); |
117 | |
118 | breakpoint_dict_sp->AddItem(key: GetSerializationKey(), value_sp: breakpoint_contents_sp); |
119 | return breakpoint_dict_sp; |
120 | } |
121 | |
122 | lldb::BreakpointSP Breakpoint::CreateFromStructuredData( |
123 | TargetSP target_sp, StructuredData::ObjectSP &object_data, Status &error) { |
124 | BreakpointSP result_sp; |
125 | if (!target_sp) |
126 | return result_sp; |
127 | |
128 | StructuredData::Dictionary *breakpoint_dict = object_data->GetAsDictionary(); |
129 | |
130 | if (!breakpoint_dict || !breakpoint_dict->IsValid()) { |
131 | error = Status::FromErrorString( |
132 | str: "Can't deserialize from an invalid data object." ); |
133 | return result_sp; |
134 | } |
135 | |
136 | StructuredData::Dictionary *resolver_dict; |
137 | bool success = breakpoint_dict->GetValueForKeyAsDictionary( |
138 | key: BreakpointResolver::GetSerializationKey(), result&: resolver_dict); |
139 | if (!success) { |
140 | error = Status::FromErrorString( |
141 | str: "Breakpoint data missing toplevel resolver key" ); |
142 | return result_sp; |
143 | } |
144 | |
145 | Status create_error; |
146 | BreakpointResolverSP resolver_sp = |
147 | BreakpointResolver::CreateFromStructuredData(resolver_dict: *resolver_dict, |
148 | error&: create_error); |
149 | if (create_error.Fail()) { |
150 | error = Status::FromErrorStringWithFormatv( |
151 | format: "Error creating breakpoint resolver from data: {0}." , args&: create_error); |
152 | return result_sp; |
153 | } |
154 | |
155 | StructuredData::Dictionary *filter_dict; |
156 | success = breakpoint_dict->GetValueForKeyAsDictionary( |
157 | key: SearchFilter::GetSerializationKey(), result&: filter_dict); |
158 | SearchFilterSP filter_sp; |
159 | if (!success) |
160 | filter_sp = |
161 | std::make_shared<SearchFilterForUnconstrainedSearches>(args&: target_sp); |
162 | else { |
163 | filter_sp = SearchFilter::CreateFromStructuredData(target_sp, data_dict: *filter_dict, |
164 | error&: create_error); |
165 | if (create_error.Fail()) { |
166 | error = Status::FromErrorStringWithFormat( |
167 | format: "Error creating breakpoint filter from data: %s." , |
168 | create_error.AsCString()); |
169 | return result_sp; |
170 | } |
171 | } |
172 | |
173 | std::unique_ptr<BreakpointOptions> options_up; |
174 | StructuredData::Dictionary *options_dict; |
175 | Target& target = *target_sp; |
176 | success = breakpoint_dict->GetValueForKeyAsDictionary( |
177 | key: BreakpointOptions::GetSerializationKey(), result&: options_dict); |
178 | if (success) { |
179 | options_up = BreakpointOptions::CreateFromStructuredData( |
180 | target, data_dict: *options_dict, error&: create_error); |
181 | if (create_error.Fail()) { |
182 | error = Status::FromErrorStringWithFormat( |
183 | format: "Error creating breakpoint options from data: %s." , |
184 | create_error.AsCString()); |
185 | return result_sp; |
186 | } |
187 | } |
188 | |
189 | bool hardware = false; |
190 | success = breakpoint_dict->GetValueForKeyAsBoolean( |
191 | key: Breakpoint::GetKey(enum_value: OptionNames::Hardware), result&: hardware); |
192 | |
193 | result_sp = target.CreateBreakpoint(filter_sp, resolver_sp, internal: false, |
194 | request_hardware: hardware, resolve_indirect_symbols: true); |
195 | |
196 | if (result_sp && options_up) { |
197 | result_sp->m_options = *options_up; |
198 | } |
199 | |
200 | StructuredData::Array *names_array; |
201 | success = breakpoint_dict->GetValueForKeyAsArray( |
202 | key: Breakpoint::GetKey(enum_value: OptionNames::Names), result&: names_array); |
203 | if (success && names_array) { |
204 | size_t num_names = names_array->GetSize(); |
205 | for (size_t i = 0; i < num_names; i++) { |
206 | if (std::optional<llvm::StringRef> maybe_name = |
207 | names_array->GetItemAtIndexAsString(idx: i)) |
208 | target.AddNameToBreakpoint(bp_sp&: result_sp, name: *maybe_name, error); |
209 | } |
210 | } |
211 | |
212 | return result_sp; |
213 | } |
214 | |
215 | bool Breakpoint::SerializedBreakpointMatchesNames( |
216 | StructuredData::ObjectSP &bkpt_object_sp, std::vector<std::string> &names) { |
217 | if (!bkpt_object_sp) |
218 | return false; |
219 | |
220 | StructuredData::Dictionary *bkpt_dict = bkpt_object_sp->GetAsDictionary(); |
221 | if (!bkpt_dict) |
222 | return false; |
223 | |
224 | if (names.empty()) |
225 | return true; |
226 | |
227 | StructuredData::Array *names_array; |
228 | |
229 | bool success = |
230 | bkpt_dict->GetValueForKeyAsArray(key: GetKey(enum_value: OptionNames::Names), result&: names_array); |
231 | // If there are no names, it can't match these names; |
232 | if (!success) |
233 | return false; |
234 | |
235 | size_t num_names = names_array->GetSize(); |
236 | |
237 | for (size_t i = 0; i < num_names; i++) { |
238 | std::optional<llvm::StringRef> maybe_name = |
239 | names_array->GetItemAtIndexAsString(idx: i); |
240 | if (maybe_name && llvm::is_contained(Range&: names, Element: *maybe_name)) |
241 | return true; |
242 | } |
243 | return false; |
244 | } |
245 | |
246 | const lldb::TargetSP Breakpoint::GetTargetSP() { |
247 | return m_target.shared_from_this(); |
248 | } |
249 | |
250 | bool Breakpoint::IsInternal() const { return LLDB_BREAK_ID_IS_INTERNAL(m_bid); } |
251 | |
252 | BreakpointLocationSP Breakpoint::AddLocation(const Address &addr, |
253 | bool *new_location) { |
254 | return m_locations.AddLocation(addr, resolve_indirect_symbols: m_resolve_indirect_symbols, |
255 | new_location); |
256 | } |
257 | |
258 | BreakpointLocationSP Breakpoint::FindLocationByAddress(const Address &addr) { |
259 | return m_locations.FindByAddress(addr); |
260 | } |
261 | |
262 | break_id_t Breakpoint::FindLocationIDByAddress(const Address &addr) { |
263 | return m_locations.FindIDByAddress(addr); |
264 | } |
265 | |
266 | BreakpointLocationSP Breakpoint::FindLocationByID(break_id_t bp_loc_id) { |
267 | return m_locations.FindByID(breakID: bp_loc_id); |
268 | } |
269 | |
270 | BreakpointLocationSP Breakpoint::GetLocationAtIndex(size_t index) { |
271 | return m_locations.GetByIndex(i: index); |
272 | } |
273 | |
274 | void Breakpoint::RemoveInvalidLocations(const ArchSpec &arch) { |
275 | m_locations.RemoveInvalidLocations(arch); |
276 | } |
277 | |
278 | // For each of the overall options we need to decide how they propagate to the |
279 | // location options. This will determine the precedence of options on the |
280 | // breakpoint vs. its locations. |
281 | |
282 | // Disable at the breakpoint level should override the location settings. That |
283 | // way you can conveniently turn off a whole breakpoint without messing up the |
284 | // individual settings. |
285 | |
286 | void Breakpoint::SetEnabled(bool enable) { |
287 | if (enable == m_options.IsEnabled()) |
288 | return; |
289 | |
290 | m_options.SetEnabled(enable); |
291 | if (enable) |
292 | m_locations.ResolveAllBreakpointSites(); |
293 | else |
294 | m_locations.ClearAllBreakpointSites(); |
295 | |
296 | SendBreakpointChangedEvent(eventKind: enable ? eBreakpointEventTypeEnabled |
297 | : eBreakpointEventTypeDisabled); |
298 | } |
299 | |
300 | bool Breakpoint::IsEnabled() { return m_options.IsEnabled(); } |
301 | |
302 | void Breakpoint::SetIgnoreCount(uint32_t n) { |
303 | if (m_options.GetIgnoreCount() == n) |
304 | return; |
305 | |
306 | m_options.SetIgnoreCount(n); |
307 | SendBreakpointChangedEvent(eventKind: eBreakpointEventTypeIgnoreChanged); |
308 | } |
309 | |
310 | void Breakpoint::DecrementIgnoreCount() { |
311 | uint32_t ignore = m_options.GetIgnoreCount(); |
312 | if (ignore != 0) |
313 | m_options.SetIgnoreCount(ignore - 1); |
314 | } |
315 | |
316 | uint32_t Breakpoint::GetIgnoreCount() const { |
317 | return m_options.GetIgnoreCount(); |
318 | } |
319 | |
320 | uint32_t Breakpoint::GetHitCount() const { return m_hit_counter.GetValue(); } |
321 | |
322 | void Breakpoint::ResetHitCount() { |
323 | m_hit_counter.Reset(); |
324 | m_locations.ResetHitCount(); |
325 | } |
326 | |
327 | bool Breakpoint::IsOneShot() const { return m_options.IsOneShot(); } |
328 | |
329 | void Breakpoint::SetOneShot(bool one_shot) { m_options.SetOneShot(one_shot); } |
330 | |
331 | bool Breakpoint::IsAutoContinue() const { return m_options.IsAutoContinue(); } |
332 | |
333 | void Breakpoint::SetAutoContinue(bool auto_continue) { |
334 | m_options.SetAutoContinue(auto_continue); |
335 | } |
336 | |
337 | void Breakpoint::SetThreadID(lldb::tid_t thread_id) { |
338 | if (m_options.GetThreadSpec()->GetTID() == thread_id) |
339 | return; |
340 | |
341 | m_options.GetThreadSpec()->SetTID(thread_id); |
342 | SendBreakpointChangedEvent(eventKind: eBreakpointEventTypeThreadChanged); |
343 | } |
344 | |
345 | lldb::tid_t Breakpoint::GetThreadID() const { |
346 | if (m_options.GetThreadSpecNoCreate() == nullptr) |
347 | return LLDB_INVALID_THREAD_ID; |
348 | else |
349 | return m_options.GetThreadSpecNoCreate()->GetTID(); |
350 | } |
351 | |
352 | void Breakpoint::SetThreadIndex(uint32_t index) { |
353 | if (m_options.GetThreadSpec()->GetIndex() == index) |
354 | return; |
355 | |
356 | m_options.GetThreadSpec()->SetIndex(index); |
357 | SendBreakpointChangedEvent(eventKind: eBreakpointEventTypeThreadChanged); |
358 | } |
359 | |
360 | uint32_t Breakpoint::GetThreadIndex() const { |
361 | if (m_options.GetThreadSpecNoCreate() == nullptr) |
362 | return 0; |
363 | else |
364 | return m_options.GetThreadSpecNoCreate()->GetIndex(); |
365 | } |
366 | |
367 | void Breakpoint::SetThreadName(const char *thread_name) { |
368 | if (m_options.GetThreadSpec()->GetName() != nullptr && |
369 | ::strcmp(s1: m_options.GetThreadSpec()->GetName(), s2: thread_name) == 0) |
370 | return; |
371 | |
372 | m_options.GetThreadSpec()->SetName(thread_name); |
373 | SendBreakpointChangedEvent(eventKind: eBreakpointEventTypeThreadChanged); |
374 | } |
375 | |
376 | const char *Breakpoint::GetThreadName() const { |
377 | if (m_options.GetThreadSpecNoCreate() == nullptr) |
378 | return nullptr; |
379 | else |
380 | return m_options.GetThreadSpecNoCreate()->GetName(); |
381 | } |
382 | |
383 | void Breakpoint::SetQueueName(const char *queue_name) { |
384 | if (m_options.GetThreadSpec()->GetQueueName() != nullptr && |
385 | ::strcmp(s1: m_options.GetThreadSpec()->GetQueueName(), s2: queue_name) == 0) |
386 | return; |
387 | |
388 | m_options.GetThreadSpec()->SetQueueName(queue_name); |
389 | SendBreakpointChangedEvent(eventKind: eBreakpointEventTypeThreadChanged); |
390 | } |
391 | |
392 | const char *Breakpoint::GetQueueName() const { |
393 | if (m_options.GetThreadSpecNoCreate() == nullptr) |
394 | return nullptr; |
395 | else |
396 | return m_options.GetThreadSpecNoCreate()->GetQueueName(); |
397 | } |
398 | |
399 | void Breakpoint::SetCondition(const char *condition) { |
400 | m_options.SetCondition(condition); |
401 | SendBreakpointChangedEvent(eventKind: eBreakpointEventTypeConditionChanged); |
402 | } |
403 | |
404 | const char *Breakpoint::GetConditionText() const { |
405 | return m_options.GetConditionText(); |
406 | } |
407 | |
408 | // This function is used when "baton" doesn't need to be freed |
409 | void Breakpoint::SetCallback(BreakpointHitCallback callback, void *baton, |
410 | bool is_synchronous) { |
411 | // The default "Baton" class will keep a copy of "baton" and won't free or |
412 | // delete it when it goes out of scope. |
413 | m_options.SetCallback(callback, baton_sp: std::make_shared<UntypedBaton>(args&: baton), |
414 | synchronous: is_synchronous); |
415 | |
416 | SendBreakpointChangedEvent(eventKind: eBreakpointEventTypeCommandChanged); |
417 | } |
418 | |
419 | // This function is used when a baton needs to be freed and therefore is |
420 | // contained in a "Baton" subclass. |
421 | void Breakpoint::SetCallback(BreakpointHitCallback callback, |
422 | const BatonSP &callback_baton_sp, |
423 | bool is_synchronous) { |
424 | m_options.SetCallback(callback, baton_sp: callback_baton_sp, synchronous: is_synchronous); |
425 | } |
426 | |
427 | void Breakpoint::ClearCallback() { m_options.ClearCallback(); } |
428 | |
429 | bool Breakpoint::InvokeCallback(StoppointCallbackContext *context, |
430 | break_id_t bp_loc_id) { |
431 | return m_options.InvokeCallback(context, break_id: GetID(), break_loc_id: bp_loc_id); |
432 | } |
433 | |
434 | BreakpointOptions &Breakpoint::GetOptions() { return m_options; } |
435 | |
436 | const BreakpointOptions &Breakpoint::GetOptions() const { return m_options; } |
437 | |
438 | void Breakpoint::ResolveBreakpoint() { |
439 | if (m_resolver_sp) { |
440 | ElapsedTime elapsed(m_resolve_time); |
441 | m_resolver_sp->ResolveBreakpoint(filter&: *m_filter_sp); |
442 | } |
443 | } |
444 | |
445 | void Breakpoint::ResolveBreakpointInModules( |
446 | ModuleList &module_list, BreakpointLocationCollection &new_locations) { |
447 | ElapsedTime elapsed(m_resolve_time); |
448 | m_locations.StartRecordingNewLocations(new_locations); |
449 | |
450 | m_resolver_sp->ResolveBreakpointInModules(filter&: *m_filter_sp, modules&: module_list); |
451 | |
452 | m_locations.StopRecordingNewLocations(); |
453 | } |
454 | |
455 | void Breakpoint::ResolveBreakpointInModules(ModuleList &module_list, |
456 | bool send_event) { |
457 | if (m_resolver_sp) { |
458 | // If this is not an internal breakpoint, set up to record the new |
459 | // locations, then dispatch an event with the new locations. |
460 | if (!IsInternal() && send_event) { |
461 | std::shared_ptr<BreakpointEventData> new_locations_event = |
462 | std::make_shared<BreakpointEventData>( |
463 | args: eBreakpointEventTypeLocationsAdded, args: shared_from_this()); |
464 | ResolveBreakpointInModules( |
465 | module_list, new_locations&: new_locations_event->GetBreakpointLocationCollection()); |
466 | if (new_locations_event->GetBreakpointLocationCollection().GetSize() != 0) |
467 | SendBreakpointChangedEvent(breakpoint_data_sp: new_locations_event); |
468 | } else { |
469 | ElapsedTime elapsed(m_resolve_time); |
470 | m_resolver_sp->ResolveBreakpointInModules(filter&: *m_filter_sp, modules&: module_list); |
471 | } |
472 | } |
473 | } |
474 | |
475 | void Breakpoint::ClearAllBreakpointSites() { |
476 | m_locations.ClearAllBreakpointSites(); |
477 | } |
478 | |
479 | // ModulesChanged: Pass in a list of new modules, and |
480 | |
481 | void Breakpoint::ModulesChanged(ModuleList &module_list, bool load, |
482 | bool delete_locations) { |
483 | Log *log = GetLog(mask: LLDBLog::Breakpoints); |
484 | LLDB_LOGF(log, |
485 | "Breakpoint::ModulesChanged: num_modules: %zu load: %i " |
486 | "delete_locations: %i\n" , |
487 | module_list.GetSize(), load, delete_locations); |
488 | |
489 | if (load) { |
490 | // The logic for handling new modules is: |
491 | // 1) If the filter rejects this module, then skip it. 2) Run through the |
492 | // current location list and if there are any locations |
493 | // for that module, we mark the module as "seen" and we don't try to |
494 | // re-resolve |
495 | // breakpoint locations for that module. |
496 | // However, we do add breakpoint sites to these locations if needed. |
497 | // 3) If we don't see this module in our breakpoint location list, call |
498 | // ResolveInModules. |
499 | |
500 | ModuleList new_modules; // We'll stuff the "unseen" modules in this list, |
501 | // and then resolve |
502 | // them after the locations pass. Have to do it this way because resolving |
503 | // breakpoints will add new locations potentially. |
504 | |
505 | for (ModuleSP module_sp : module_list.Modules()) { |
506 | bool seen = false; |
507 | if (!m_filter_sp->ModulePasses(module_sp)) |
508 | continue; |
509 | |
510 | BreakpointLocationCollection locations_with_no_section; |
511 | for (BreakpointLocationSP break_loc_sp : |
512 | m_locations.BreakpointLocations()) { |
513 | |
514 | // If the section for this location was deleted, that means it's Module |
515 | // has gone away but somebody forgot to tell us. Let's clean it up |
516 | // here. |
517 | Address section_addr(break_loc_sp->GetAddress()); |
518 | if (section_addr.SectionWasDeleted()) { |
519 | locations_with_no_section.Add(bp_loc_sp: break_loc_sp); |
520 | continue; |
521 | } |
522 | |
523 | if (!break_loc_sp->IsEnabled()) |
524 | continue; |
525 | |
526 | SectionSP section_sp(section_addr.GetSection()); |
527 | |
528 | // If we don't have a Section, that means this location is a raw |
529 | // address that we haven't resolved to a section yet. So we'll have to |
530 | // look in all the new modules to resolve this location. Otherwise, if |
531 | // it was set in this module, re-resolve it here. |
532 | if (section_sp && section_sp->GetModule() == module_sp) { |
533 | if (!seen) |
534 | seen = true; |
535 | |
536 | if (!break_loc_sp->ResolveBreakpointSite()) { |
537 | LLDB_LOGF(log, |
538 | "Warning: could not set breakpoint site for " |
539 | "breakpoint location %d of breakpoint %d.\n" , |
540 | break_loc_sp->GetID(), GetID()); |
541 | } |
542 | } |
543 | } |
544 | |
545 | size_t num_to_delete = locations_with_no_section.GetSize(); |
546 | |
547 | for (size_t i = 0; i < num_to_delete; i++) |
548 | m_locations.RemoveLocation(bp_loc_sp: locations_with_no_section.GetByIndex(i)); |
549 | |
550 | if (!seen) |
551 | new_modules.AppendIfNeeded(new_module: module_sp); |
552 | } |
553 | |
554 | if (new_modules.GetSize() > 0) { |
555 | ResolveBreakpointInModules(module_list&: new_modules); |
556 | } |
557 | } else { |
558 | // Go through the currently set locations and if any have breakpoints in |
559 | // the module list, then remove their breakpoint sites, and their locations |
560 | // if asked to. |
561 | |
562 | std::shared_ptr<BreakpointEventData> removed_locations_event; |
563 | if (!IsInternal()) |
564 | removed_locations_event = std::make_shared<BreakpointEventData>( |
565 | args: eBreakpointEventTypeLocationsRemoved, args: shared_from_this()); |
566 | |
567 | for (ModuleSP module_sp : module_list.Modules()) { |
568 | if (m_filter_sp->ModulePasses(module_sp)) { |
569 | size_t loc_idx = 0; |
570 | size_t num_locations = m_locations.GetSize(); |
571 | BreakpointLocationCollection locations_to_remove; |
572 | for (loc_idx = 0; loc_idx < num_locations; loc_idx++) { |
573 | BreakpointLocationSP break_loc_sp(m_locations.GetByIndex(i: loc_idx)); |
574 | SectionSP section_sp(break_loc_sp->GetAddress().GetSection()); |
575 | if (section_sp && section_sp->GetModule() == module_sp) { |
576 | // Remove this breakpoint since the shared library is unloaded, but |
577 | // keep the breakpoint location around so we always get complete |
578 | // hit count and breakpoint lifetime info |
579 | break_loc_sp->ClearBreakpointSite(); |
580 | if (removed_locations_event) { |
581 | removed_locations_event->GetBreakpointLocationCollection().Add( |
582 | bp_loc_sp: break_loc_sp); |
583 | } |
584 | if (delete_locations) |
585 | locations_to_remove.Add(bp_loc_sp: break_loc_sp); |
586 | } |
587 | } |
588 | |
589 | if (delete_locations) { |
590 | size_t num_locations_to_remove = locations_to_remove.GetSize(); |
591 | for (loc_idx = 0; loc_idx < num_locations_to_remove; loc_idx++) |
592 | m_locations.RemoveLocation(bp_loc_sp: locations_to_remove.GetByIndex(i: loc_idx)); |
593 | } |
594 | } |
595 | } |
596 | SendBreakpointChangedEvent(breakpoint_data_sp: removed_locations_event); |
597 | } |
598 | } |
599 | |
600 | static bool SymbolContextsMightBeEquivalent(SymbolContext &old_sc, |
601 | SymbolContext &new_sc) { |
602 | bool equivalent_scs = false; |
603 | |
604 | if (old_sc.module_sp.get() == new_sc.module_sp.get()) { |
605 | // If these come from the same module, we can directly compare the |
606 | // pointers: |
607 | if (old_sc.comp_unit && new_sc.comp_unit && |
608 | (old_sc.comp_unit == new_sc.comp_unit)) { |
609 | if (old_sc.function && new_sc.function && |
610 | (old_sc.function == new_sc.function)) { |
611 | equivalent_scs = true; |
612 | } |
613 | } else if (old_sc.symbol && new_sc.symbol && |
614 | (old_sc.symbol == new_sc.symbol)) { |
615 | equivalent_scs = true; |
616 | } |
617 | } else { |
618 | // Otherwise we will compare by name... |
619 | if (old_sc.comp_unit && new_sc.comp_unit) { |
620 | if (old_sc.comp_unit->GetPrimaryFile() == |
621 | new_sc.comp_unit->GetPrimaryFile()) { |
622 | // Now check the functions: |
623 | if (old_sc.function && new_sc.function && |
624 | (old_sc.function->GetName() == new_sc.function->GetName())) { |
625 | equivalent_scs = true; |
626 | } |
627 | } |
628 | } else if (old_sc.symbol && new_sc.symbol) { |
629 | if (Mangled::Compare(lhs: old_sc.symbol->GetMangled(), |
630 | rhs: new_sc.symbol->GetMangled()) == 0) { |
631 | equivalent_scs = true; |
632 | } |
633 | } |
634 | } |
635 | return equivalent_scs; |
636 | } |
637 | |
638 | void Breakpoint::ModuleReplaced(ModuleSP old_module_sp, |
639 | ModuleSP new_module_sp) { |
640 | Log *log = GetLog(mask: LLDBLog::Breakpoints); |
641 | LLDB_LOGF(log, "Breakpoint::ModulesReplaced for %s\n" , |
642 | old_module_sp->GetSpecificationDescription().c_str()); |
643 | // First find all the locations that are in the old module |
644 | |
645 | BreakpointLocationCollection old_break_locs; |
646 | for (BreakpointLocationSP break_loc_sp : m_locations.BreakpointLocations()) { |
647 | SectionSP section_sp = break_loc_sp->GetAddress().GetSection(); |
648 | if (section_sp && section_sp->GetModule() == old_module_sp) { |
649 | old_break_locs.Add(bp_loc_sp: break_loc_sp); |
650 | } |
651 | } |
652 | |
653 | size_t num_old_locations = old_break_locs.GetSize(); |
654 | |
655 | if (num_old_locations == 0) { |
656 | // There were no locations in the old module, so we just need to check if |
657 | // there were any in the new module. |
658 | ModuleList temp_list; |
659 | temp_list.Append(module_sp: new_module_sp); |
660 | ResolveBreakpointInModules(module_list&: temp_list); |
661 | } else { |
662 | // First search the new module for locations. Then compare this with the |
663 | // old list, copy over locations that "look the same" Then delete the old |
664 | // locations. Finally remember to post the creation event. |
665 | // |
666 | // Two locations are the same if they have the same comp unit & function |
667 | // (by name) and there are the same number of locations in the old function |
668 | // as in the new one. |
669 | |
670 | ModuleList temp_list; |
671 | temp_list.Append(module_sp: new_module_sp); |
672 | BreakpointLocationCollection new_break_locs; |
673 | ResolveBreakpointInModules(module_list&: temp_list, new_locations&: new_break_locs); |
674 | BreakpointLocationCollection locations_to_remove; |
675 | BreakpointLocationCollection locations_to_announce; |
676 | |
677 | size_t num_new_locations = new_break_locs.GetSize(); |
678 | |
679 | if (num_new_locations > 0) { |
680 | // Break out the case of one location -> one location since that's the |
681 | // most common one, and there's no need to build up the structures needed |
682 | // for the merge in that case. |
683 | if (num_new_locations == 1 && num_old_locations == 1) { |
684 | bool equivalent_locations = false; |
685 | SymbolContext old_sc, new_sc; |
686 | // The only way the old and new location can be equivalent is if they |
687 | // have the same amount of information: |
688 | BreakpointLocationSP old_loc_sp = old_break_locs.GetByIndex(i: 0); |
689 | BreakpointLocationSP new_loc_sp = new_break_locs.GetByIndex(i: 0); |
690 | |
691 | if (old_loc_sp->GetAddress().CalculateSymbolContext(sc: &old_sc) == |
692 | new_loc_sp->GetAddress().CalculateSymbolContext(sc: &new_sc)) { |
693 | equivalent_locations = |
694 | SymbolContextsMightBeEquivalent(old_sc, new_sc); |
695 | } |
696 | |
697 | if (equivalent_locations) { |
698 | m_locations.SwapLocation(to_location_sp: old_loc_sp, from_location_sp: new_loc_sp); |
699 | } else { |
700 | locations_to_remove.Add(bp_loc_sp: old_loc_sp); |
701 | locations_to_announce.Add(bp_loc_sp: new_loc_sp); |
702 | } |
703 | } else { |
704 | // We don't want to have to keep computing the SymbolContexts for these |
705 | // addresses over and over, so lets get them up front: |
706 | |
707 | typedef std::map<lldb::break_id_t, SymbolContext> IDToSCMap; |
708 | IDToSCMap old_sc_map; |
709 | for (size_t idx = 0; idx < num_old_locations; idx++) { |
710 | SymbolContext sc; |
711 | BreakpointLocationSP bp_loc_sp = old_break_locs.GetByIndex(i: idx); |
712 | lldb::break_id_t loc_id = bp_loc_sp->GetID(); |
713 | bp_loc_sp->GetAddress().CalculateSymbolContext(sc: &old_sc_map[loc_id]); |
714 | } |
715 | |
716 | std::map<lldb::break_id_t, SymbolContext> new_sc_map; |
717 | for (size_t idx = 0; idx < num_new_locations; idx++) { |
718 | SymbolContext sc; |
719 | BreakpointLocationSP bp_loc_sp = new_break_locs.GetByIndex(i: idx); |
720 | lldb::break_id_t loc_id = bp_loc_sp->GetID(); |
721 | bp_loc_sp->GetAddress().CalculateSymbolContext(sc: &new_sc_map[loc_id]); |
722 | } |
723 | // Take an element from the old Symbol Contexts |
724 | while (old_sc_map.size() > 0) { |
725 | lldb::break_id_t old_id = old_sc_map.begin()->first; |
726 | SymbolContext &old_sc = old_sc_map.begin()->second; |
727 | |
728 | // Count the number of entries equivalent to this SC for the old |
729 | // list: |
730 | std::vector<lldb::break_id_t> old_id_vec; |
731 | old_id_vec.push_back(x: old_id); |
732 | |
733 | IDToSCMap::iterator tmp_iter; |
734 | for (tmp_iter = ++old_sc_map.begin(); tmp_iter != old_sc_map.end(); |
735 | tmp_iter++) { |
736 | if (SymbolContextsMightBeEquivalent(old_sc, new_sc&: tmp_iter->second)) |
737 | old_id_vec.push_back(x: tmp_iter->first); |
738 | } |
739 | |
740 | // Now find all the equivalent locations in the new list. |
741 | std::vector<lldb::break_id_t> new_id_vec; |
742 | for (tmp_iter = new_sc_map.begin(); tmp_iter != new_sc_map.end(); |
743 | tmp_iter++) { |
744 | if (SymbolContextsMightBeEquivalent(old_sc, new_sc&: tmp_iter->second)) |
745 | new_id_vec.push_back(x: tmp_iter->first); |
746 | } |
747 | |
748 | // Alright, if we have the same number of potentially equivalent |
749 | // locations in the old and new modules, we'll just map them one to |
750 | // one in ascending ID order (assuming the resolver's order would |
751 | // match the equivalent ones. Otherwise, we'll dump all the old ones, |
752 | // and just take the new ones, erasing the elements from both maps as |
753 | // we go. |
754 | |
755 | if (old_id_vec.size() == new_id_vec.size()) { |
756 | llvm::sort(C&: old_id_vec); |
757 | llvm::sort(C&: new_id_vec); |
758 | size_t num_elements = old_id_vec.size(); |
759 | for (size_t idx = 0; idx < num_elements; idx++) { |
760 | BreakpointLocationSP old_loc_sp = |
761 | old_break_locs.FindByIDPair(break_id: GetID(), break_loc_id: old_id_vec[idx]); |
762 | BreakpointLocationSP new_loc_sp = |
763 | new_break_locs.FindByIDPair(break_id: GetID(), break_loc_id: new_id_vec[idx]); |
764 | m_locations.SwapLocation(to_location_sp: old_loc_sp, from_location_sp: new_loc_sp); |
765 | old_sc_map.erase(x: old_id_vec[idx]); |
766 | new_sc_map.erase(x: new_id_vec[idx]); |
767 | } |
768 | } else { |
769 | for (lldb::break_id_t old_id : old_id_vec) { |
770 | locations_to_remove.Add( |
771 | bp_loc_sp: old_break_locs.FindByIDPair(break_id: GetID(), break_loc_id: old_id)); |
772 | old_sc_map.erase(x: old_id); |
773 | } |
774 | for (lldb::break_id_t new_id : new_id_vec) { |
775 | locations_to_announce.Add( |
776 | bp_loc_sp: new_break_locs.FindByIDPair(break_id: GetID(), break_loc_id: new_id)); |
777 | new_sc_map.erase(x: new_id); |
778 | } |
779 | } |
780 | } |
781 | } |
782 | } |
783 | |
784 | // Now remove the remaining old locations, and cons up a removed locations |
785 | // event. Note, we don't put the new locations that were swapped with an |
786 | // old location on the locations_to_remove list, so we don't need to worry |
787 | // about telling the world about removing a location we didn't tell them |
788 | // about adding. |
789 | |
790 | std::shared_ptr<BreakpointEventData> removed_locations_event; |
791 | if (!IsInternal()) |
792 | removed_locations_event = std::make_shared<BreakpointEventData>( |
793 | args: eBreakpointEventTypeLocationsRemoved, args: shared_from_this()); |
794 | |
795 | for (BreakpointLocationSP loc_sp : |
796 | locations_to_remove.BreakpointLocations()) { |
797 | m_locations.RemoveLocation(bp_loc_sp: loc_sp); |
798 | if (removed_locations_event) |
799 | removed_locations_event->GetBreakpointLocationCollection().Add(bp_loc_sp: loc_sp); |
800 | } |
801 | SendBreakpointChangedEvent(breakpoint_data_sp: removed_locations_event); |
802 | |
803 | // And announce the new ones. |
804 | |
805 | if (!IsInternal()) { |
806 | std::shared_ptr<BreakpointEventData> added_locations_event = |
807 | std::make_shared<BreakpointEventData>( |
808 | args: eBreakpointEventTypeLocationsAdded, args: shared_from_this()); |
809 | for (BreakpointLocationSP loc_sp : |
810 | locations_to_announce.BreakpointLocations()) |
811 | added_locations_event->GetBreakpointLocationCollection().Add(bp_loc_sp: loc_sp); |
812 | |
813 | SendBreakpointChangedEvent(breakpoint_data_sp: added_locations_event); |
814 | } |
815 | m_locations.Compact(); |
816 | } |
817 | } |
818 | |
819 | void Breakpoint::Dump(Stream *) {} |
820 | |
821 | size_t Breakpoint::GetNumResolvedLocations() const { |
822 | // Return the number of breakpoints that are actually resolved and set down |
823 | // in the inferior process. |
824 | return m_locations.GetNumResolvedLocations(); |
825 | } |
826 | |
827 | bool Breakpoint::HasResolvedLocations() const { |
828 | return GetNumResolvedLocations() > 0; |
829 | } |
830 | |
831 | size_t Breakpoint::GetNumLocations() const { return m_locations.GetSize(); } |
832 | |
833 | void Breakpoint::AddName(llvm::StringRef new_name) { |
834 | m_name_list.insert(x: new_name.str()); |
835 | } |
836 | |
837 | void Breakpoint::GetDescription(Stream *s, lldb::DescriptionLevel level, |
838 | bool show_locations) { |
839 | assert(s != nullptr); |
840 | |
841 | if (!m_kind_description.empty()) { |
842 | if (level == eDescriptionLevelBrief) { |
843 | s->PutCString(cstr: GetBreakpointKind()); |
844 | return; |
845 | } else |
846 | s->Printf(format: "Kind: %s\n" , GetBreakpointKind()); |
847 | } |
848 | |
849 | const size_t num_locations = GetNumLocations(); |
850 | const size_t num_resolved_locations = GetNumResolvedLocations(); |
851 | |
852 | // They just made the breakpoint, they don't need to be told HOW they made |
853 | // it... Also, we'll print the breakpoint number differently depending on |
854 | // whether there is 1 or more locations. |
855 | if (level != eDescriptionLevelInitial) { |
856 | s->Printf(format: "%i: " , GetID()); |
857 | GetResolverDescription(s); |
858 | GetFilterDescription(s); |
859 | } |
860 | |
861 | switch (level) { |
862 | case lldb::eDescriptionLevelBrief: |
863 | case lldb::eDescriptionLevelFull: |
864 | if (num_locations > 0) { |
865 | s->Printf(format: ", locations = %" PRIu64, (uint64_t)num_locations); |
866 | if (num_resolved_locations > 0) |
867 | s->Printf(format: ", resolved = %" PRIu64 ", hit count = %d" , |
868 | (uint64_t)num_resolved_locations, GetHitCount()); |
869 | } else { |
870 | // Don't print the pending notification for exception resolvers since we |
871 | // don't generally know how to set them until the target is run. |
872 | if (m_resolver_sp->getResolverID() != |
873 | BreakpointResolver::ExceptionResolver) |
874 | s->Printf(format: ", locations = 0 (pending)" ); |
875 | } |
876 | |
877 | m_options.GetDescription(s, level); |
878 | |
879 | if (m_precondition_sp) |
880 | m_precondition_sp->GetDescription(stream&: *s, level); |
881 | |
882 | if (level == lldb::eDescriptionLevelFull) { |
883 | if (!m_name_list.empty()) { |
884 | s->EOL(); |
885 | s->Indent(); |
886 | s->Printf(format: "Names:" ); |
887 | s->EOL(); |
888 | s->IndentMore(); |
889 | for (const std::string &name : m_name_list) { |
890 | s->Indent(); |
891 | s->Printf(format: "%s\n" , name.c_str()); |
892 | } |
893 | s->IndentLess(); |
894 | } |
895 | s->IndentLess(); |
896 | s->EOL(); |
897 | } |
898 | break; |
899 | |
900 | case lldb::eDescriptionLevelInitial: |
901 | s->Printf(format: "Breakpoint %i: " , GetID()); |
902 | if (num_locations == 0) { |
903 | s->Printf(format: "no locations (pending)." ); |
904 | } else if (num_locations == 1 && !show_locations) { |
905 | // There is only one location, so we'll just print that location |
906 | // information. |
907 | GetLocationAtIndex(index: 0)->GetDescription(s, level); |
908 | } else { |
909 | s->Printf(format: "%" PRIu64 " locations." , static_cast<uint64_t>(num_locations)); |
910 | } |
911 | s->EOL(); |
912 | break; |
913 | |
914 | case lldb::eDescriptionLevelVerbose: |
915 | // Verbose mode does a debug dump of the breakpoint |
916 | Dump(s); |
917 | s->EOL(); |
918 | // s->Indent(); |
919 | m_options.GetDescription(s, level); |
920 | break; |
921 | |
922 | default: |
923 | break; |
924 | } |
925 | |
926 | // The brief description is just the location name (1.2 or whatever). That's |
927 | // pointless to show in the breakpoint's description, so suppress it. |
928 | if (show_locations && level != lldb::eDescriptionLevelBrief) { |
929 | s->IndentMore(); |
930 | for (size_t i = 0; i < num_locations; ++i) { |
931 | BreakpointLocation *loc = GetLocationAtIndex(index: i).get(); |
932 | loc->GetDescription(s, level); |
933 | s->EOL(); |
934 | } |
935 | s->IndentLess(); |
936 | } |
937 | } |
938 | |
939 | void Breakpoint::GetResolverDescription(Stream *s) { |
940 | if (m_resolver_sp) |
941 | m_resolver_sp->GetDescription(s); |
942 | } |
943 | |
944 | bool Breakpoint::GetMatchingFileLine(ConstString filename, |
945 | uint32_t line_number, |
946 | BreakpointLocationCollection &loc_coll) { |
947 | // TODO: To be correct, this method needs to fill the breakpoint location |
948 | // collection |
949 | // with the location IDs which match the filename and line_number. |
950 | // |
951 | |
952 | if (m_resolver_sp) { |
953 | BreakpointResolverFileLine *resolverFileLine = |
954 | dyn_cast<BreakpointResolverFileLine>(Val: m_resolver_sp.get()); |
955 | |
956 | // TODO: Handle SourceLocationSpec column information |
957 | if (resolverFileLine && |
958 | resolverFileLine->m_location_spec.GetFileSpec().GetFilename() == |
959 | filename && |
960 | resolverFileLine->m_location_spec.GetLine() == line_number) { |
961 | return true; |
962 | } |
963 | } |
964 | return false; |
965 | } |
966 | |
967 | void Breakpoint::GetFilterDescription(Stream *s) { |
968 | m_filter_sp->GetDescription(s); |
969 | } |
970 | |
971 | bool Breakpoint::EvaluatePrecondition(StoppointCallbackContext &context) { |
972 | if (!m_precondition_sp) |
973 | return true; |
974 | |
975 | return m_precondition_sp->EvaluatePrecondition(context); |
976 | } |
977 | |
978 | void Breakpoint::SendBreakpointChangedEvent( |
979 | lldb::BreakpointEventType eventKind) { |
980 | if (!IsInternal() && GetTarget().EventTypeHasListeners( |
981 | event_type: Target::eBroadcastBitBreakpointChanged)) { |
982 | std::shared_ptr<BreakpointEventData> data = |
983 | std::make_shared<BreakpointEventData>(args&: eventKind, args: shared_from_this()); |
984 | |
985 | GetTarget().BroadcastEvent(event_type: Target::eBroadcastBitBreakpointChanged, event_data_sp: data); |
986 | } |
987 | } |
988 | |
989 | void Breakpoint::SendBreakpointChangedEvent( |
990 | const lldb::EventDataSP &breakpoint_data_sp) { |
991 | if (!breakpoint_data_sp) |
992 | return; |
993 | |
994 | if (!IsInternal() && |
995 | GetTarget().EventTypeHasListeners(event_type: Target::eBroadcastBitBreakpointChanged)) |
996 | GetTarget().BroadcastEvent(event_type: Target::eBroadcastBitBreakpointChanged, |
997 | event_data_sp: breakpoint_data_sp); |
998 | } |
999 | |
1000 | const char *Breakpoint::BreakpointEventTypeAsCString(BreakpointEventType type) { |
1001 | switch (type) { |
1002 | case eBreakpointEventTypeInvalidType: return "invalid" ; |
1003 | case eBreakpointEventTypeAdded: return "breakpoint added" ; |
1004 | case eBreakpointEventTypeRemoved: return "breakpoint removed" ; |
1005 | case eBreakpointEventTypeLocationsAdded: return "locations added" ; |
1006 | case eBreakpointEventTypeLocationsRemoved: return "locations removed" ; |
1007 | case eBreakpointEventTypeLocationsResolved: return "locations resolved" ; |
1008 | case eBreakpointEventTypeEnabled: return "breakpoint enabled" ; |
1009 | case eBreakpointEventTypeDisabled: return "breakpoint disabled" ; |
1010 | case eBreakpointEventTypeCommandChanged: return "command changed" ; |
1011 | case eBreakpointEventTypeConditionChanged: return "condition changed" ; |
1012 | case eBreakpointEventTypeIgnoreChanged: return "ignore count changed" ; |
1013 | case eBreakpointEventTypeThreadChanged: return "thread changed" ; |
1014 | case eBreakpointEventTypeAutoContinueChanged: return "autocontinue changed" ; |
1015 | }; |
1016 | llvm_unreachable("Fully covered switch above!" ); |
1017 | } |
1018 | |
1019 | Log *Breakpoint::BreakpointEventData::GetLogChannel() { |
1020 | return GetLog(mask: LLDBLog::Breakpoints); |
1021 | } |
1022 | |
1023 | Breakpoint::BreakpointEventData::BreakpointEventData( |
1024 | BreakpointEventType sub_type, const BreakpointSP &new_breakpoint_sp) |
1025 | : m_breakpoint_event(sub_type), m_new_breakpoint_sp(new_breakpoint_sp) {} |
1026 | |
1027 | Breakpoint::BreakpointEventData::~BreakpointEventData() = default; |
1028 | |
1029 | llvm::StringRef Breakpoint::BreakpointEventData::GetFlavorString() { |
1030 | return "Breakpoint::BreakpointEventData" ; |
1031 | } |
1032 | |
1033 | llvm::StringRef Breakpoint::BreakpointEventData::GetFlavor() const { |
1034 | return BreakpointEventData::GetFlavorString(); |
1035 | } |
1036 | |
1037 | BreakpointSP Breakpoint::BreakpointEventData::GetBreakpoint() const { |
1038 | return m_new_breakpoint_sp; |
1039 | } |
1040 | |
1041 | BreakpointEventType |
1042 | Breakpoint::BreakpointEventData::GetBreakpointEventType() const { |
1043 | return m_breakpoint_event; |
1044 | } |
1045 | |
1046 | void Breakpoint::BreakpointEventData::Dump(Stream *s) const { |
1047 | if (!s) |
1048 | return; |
1049 | BreakpointEventType event_type = GetBreakpointEventType(); |
1050 | break_id_t bkpt_id = GetBreakpoint()->GetID(); |
1051 | s->Format(format: "bkpt: {0} type: {1}" , args&: bkpt_id, |
1052 | args: BreakpointEventTypeAsCString(type: event_type)); |
1053 | } |
1054 | |
1055 | const Breakpoint::BreakpointEventData * |
1056 | Breakpoint::BreakpointEventData::GetEventDataFromEvent(const Event *event) { |
1057 | if (event) { |
1058 | const EventData *event_data = event->GetData(); |
1059 | if (event_data && |
1060 | event_data->GetFlavor() == BreakpointEventData::GetFlavorString()) |
1061 | return static_cast<const BreakpointEventData *>(event->GetData()); |
1062 | } |
1063 | return nullptr; |
1064 | } |
1065 | |
1066 | BreakpointEventType |
1067 | Breakpoint::BreakpointEventData::GetBreakpointEventTypeFromEvent( |
1068 | const EventSP &event_sp) { |
1069 | const BreakpointEventData *data = GetEventDataFromEvent(event: event_sp.get()); |
1070 | |
1071 | if (data == nullptr) |
1072 | return eBreakpointEventTypeInvalidType; |
1073 | else |
1074 | return data->GetBreakpointEventType(); |
1075 | } |
1076 | |
1077 | BreakpointSP Breakpoint::BreakpointEventData::GetBreakpointFromEvent( |
1078 | const EventSP &event_sp) { |
1079 | BreakpointSP bp_sp; |
1080 | |
1081 | const BreakpointEventData *data = GetEventDataFromEvent(event: event_sp.get()); |
1082 | if (data) |
1083 | bp_sp = data->m_new_breakpoint_sp; |
1084 | |
1085 | return bp_sp; |
1086 | } |
1087 | |
1088 | size_t Breakpoint::BreakpointEventData::GetNumBreakpointLocationsFromEvent( |
1089 | const EventSP &event_sp) { |
1090 | const BreakpointEventData *data = GetEventDataFromEvent(event: event_sp.get()); |
1091 | if (data) |
1092 | return data->m_locations.GetSize(); |
1093 | |
1094 | return 0; |
1095 | } |
1096 | |
1097 | lldb::BreakpointLocationSP |
1098 | Breakpoint::BreakpointEventData::GetBreakpointLocationAtIndexFromEvent( |
1099 | const lldb::EventSP &event_sp, uint32_t bp_loc_idx) { |
1100 | lldb::BreakpointLocationSP bp_loc_sp; |
1101 | |
1102 | const BreakpointEventData *data = GetEventDataFromEvent(event: event_sp.get()); |
1103 | if (data) { |
1104 | bp_loc_sp = data->m_locations.GetByIndex(i: bp_loc_idx); |
1105 | } |
1106 | |
1107 | return bp_loc_sp; |
1108 | } |
1109 | |
1110 | json::Value Breakpoint::GetStatistics() { |
1111 | json::Object bp; |
1112 | bp.try_emplace(K: "id" , Args: GetID()); |
1113 | bp.try_emplace(K: "resolveTime" , Args: m_resolve_time.get().count()); |
1114 | bp.try_emplace(K: "numLocations" , Args: (int64_t)GetNumLocations()); |
1115 | bp.try_emplace(K: "numResolvedLocations" , Args: (int64_t)GetNumResolvedLocations()); |
1116 | bp.try_emplace(K: "hitCount" , Args: (int64_t)GetHitCount()); |
1117 | bp.try_emplace(K: "internal" , Args: IsInternal()); |
1118 | if (!m_kind_description.empty()) |
1119 | bp.try_emplace(K: "kindDescription" , Args&: m_kind_description); |
1120 | // Put the full structured data for reproducing this breakpoint in a key/value |
1121 | // pair named "details". This allows the breakpoint's details to be visible |
1122 | // in the stats in case we need to reproduce a breakpoint that has long |
1123 | // resolve times |
1124 | StructuredData::ObjectSP bp_data_sp = SerializeToStructuredData(); |
1125 | if (bp_data_sp) { |
1126 | std::string buffer; |
1127 | llvm::raw_string_ostream ss(buffer); |
1128 | json::OStream json_os(ss); |
1129 | bp_data_sp->Serialize(s&: json_os); |
1130 | if (auto expected_value = llvm::json::parse(JSON: buffer)) { |
1131 | bp.try_emplace(K: "details" , Args: std::move(*expected_value)); |
1132 | } else { |
1133 | std::string details_error = toString(E: expected_value.takeError()); |
1134 | json::Object details; |
1135 | details.try_emplace(K: "error" , Args&: details_error); |
1136 | bp.try_emplace(K: "details" , Args: std::move(details)); |
1137 | } |
1138 | } |
1139 | return json::Value(std::move(bp)); |
1140 | } |
1141 | |
1142 | void Breakpoint::ResetStatistics() { m_resolve_time.reset(); } |
1143 | |