diff options
Diffstat (limited to 'lldb/source/Breakpoint')
21 files changed, 3758 insertions, 4805 deletions
diff --git a/lldb/source/Breakpoint/Breakpoint.cpp b/lldb/source/Breakpoint/Breakpoint.cpp index 224f266fe11..78354e28c48 100644 --- a/lldb/source/Breakpoint/Breakpoint.cpp +++ b/lldb/source/Breakpoint/Breakpoint.cpp @@ -13,12 +13,12 @@ #include "llvm/Support/Casting.h" // Project includes -#include "lldb/Core/Address.h" #include "lldb/Breakpoint/Breakpoint.h" #include "lldb/Breakpoint/BreakpointLocation.h" #include "lldb/Breakpoint/BreakpointLocationCollection.h" #include "lldb/Breakpoint/BreakpointResolver.h" #include "lldb/Breakpoint/BreakpointResolverFileLine.h" +#include "lldb/Core/Address.h" #include "lldb/Core/Log.h" #include "lldb/Core/Module.h" #include "lldb/Core/ModuleList.h" @@ -36,47 +36,33 @@ using namespace lldb; using namespace lldb_private; using namespace llvm; -const ConstString & -Breakpoint::GetEventIdentifier () -{ - static ConstString g_identifier("event-identifier.breakpoint.changed"); - return g_identifier; +const ConstString &Breakpoint::GetEventIdentifier() { + static ConstString g_identifier("event-identifier.breakpoint.changed"); + return g_identifier; } //---------------------------------------------------------------------- // Breakpoint constructor //---------------------------------------------------------------------- -Breakpoint::Breakpoint(Target &target, - SearchFilterSP &filter_sp, - BreakpointResolverSP &resolver_sp, - bool hardware, - bool resolve_indirect_symbols) : - m_being_created(true), - m_hardware(hardware), - m_target (target), - m_filter_sp (filter_sp), - m_resolver_sp (resolver_sp), - m_options (), - m_locations (*this), - m_resolve_indirect_symbols(resolve_indirect_symbols), - m_hit_count(0) -{ - m_being_created = false; -} - -Breakpoint::Breakpoint (Target &new_target, Breakpoint &source_bp) : - m_being_created(true), - m_hardware(source_bp.m_hardware), - m_target(new_target), - m_name_list (source_bp.m_name_list), - m_options (source_bp.m_options), - m_locations(*this), - m_resolve_indirect_symbols(source_bp.m_resolve_indirect_symbols), - m_hit_count(0) -{ - // Now go through and copy the filter & resolver: - m_resolver_sp = source_bp.m_resolver_sp->CopyForBreakpoint(*this); - m_filter_sp = source_bp.m_filter_sp->CopyForBreakpoint(*this); +Breakpoint::Breakpoint(Target &target, SearchFilterSP &filter_sp, + BreakpointResolverSP &resolver_sp, bool hardware, + bool resolve_indirect_symbols) + : m_being_created(true), m_hardware(hardware), m_target(target), + m_filter_sp(filter_sp), m_resolver_sp(resolver_sp), m_options(), + m_locations(*this), m_resolve_indirect_symbols(resolve_indirect_symbols), + m_hit_count(0) { + m_being_created = false; +} + +Breakpoint::Breakpoint(Target &new_target, Breakpoint &source_bp) + : m_being_created(true), m_hardware(source_bp.m_hardware), + m_target(new_target), m_name_list(source_bp.m_name_list), + m_options(source_bp.m_options), m_locations(*this), + m_resolve_indirect_symbols(source_bp.m_resolve_indirect_symbols), + m_hit_count(0) { + // Now go through and copy the filter & resolver: + m_resolver_sp = source_bp.m_resolver_sp->CopyForBreakpoint(*this); + m_filter_sp = source_bp.m_filter_sp->CopyForBreakpoint(*this); } //---------------------------------------------------------------------- @@ -84,52 +70,36 @@ Breakpoint::Breakpoint (Target &new_target, Breakpoint &source_bp) : //---------------------------------------------------------------------- Breakpoint::~Breakpoint() = default; -const lldb::TargetSP -Breakpoint::GetTargetSP () -{ - return m_target.shared_from_this(); +const lldb::TargetSP Breakpoint::GetTargetSP() { + return m_target.shared_from_this(); } -bool -Breakpoint::IsInternal () const -{ - return LLDB_BREAK_ID_IS_INTERNAL(m_bid); -} +bool Breakpoint::IsInternal() const { return LLDB_BREAK_ID_IS_INTERNAL(m_bid); } -BreakpointLocationSP -Breakpoint::AddLocation (const Address &addr, bool *new_location) -{ - return m_locations.AddLocation (addr, m_resolve_indirect_symbols, new_location); +BreakpointLocationSP Breakpoint::AddLocation(const Address &addr, + bool *new_location) { + return m_locations.AddLocation(addr, m_resolve_indirect_symbols, + new_location); } -BreakpointLocationSP -Breakpoint::FindLocationByAddress (const Address &addr) -{ - return m_locations.FindByAddress(addr); +BreakpointLocationSP Breakpoint::FindLocationByAddress(const Address &addr) { + return m_locations.FindByAddress(addr); } -break_id_t -Breakpoint::FindLocationIDByAddress (const Address &addr) -{ - return m_locations.FindIDByAddress(addr); +break_id_t Breakpoint::FindLocationIDByAddress(const Address &addr) { + return m_locations.FindIDByAddress(addr); } -BreakpointLocationSP -Breakpoint::FindLocationByID (break_id_t bp_loc_id) -{ - return m_locations.FindByID(bp_loc_id); +BreakpointLocationSP Breakpoint::FindLocationByID(break_id_t bp_loc_id) { + return m_locations.FindByID(bp_loc_id); } -BreakpointLocationSP -Breakpoint::GetLocationAtIndex (size_t index) -{ - return m_locations.GetByIndex(index); +BreakpointLocationSP Breakpoint::GetLocationAtIndex(size_t index) { + return m_locations.GetByIndex(index); } -void -Breakpoint::RemoveInvalidLocations (const ArchSpec &arch) -{ - m_locations.RemoveInvalidLocations(arch); +void Breakpoint::RemoveInvalidLocations(const ArchSpec &arch) { + m_locations.RemoveInvalidLocations(arch); } // For each of the overall options we need to decide how they propagate to @@ -140,962 +110,815 @@ Breakpoint::RemoveInvalidLocations (const ArchSpec &arch) // That way you can conveniently turn off a whole breakpoint without messing // up the individual settings. -void -Breakpoint::SetEnabled (bool enable) -{ - if (enable == m_options.IsEnabled()) - return; +void Breakpoint::SetEnabled(bool enable) { + if (enable == m_options.IsEnabled()) + return; - m_options.SetEnabled(enable); - if (enable) - m_locations.ResolveAllBreakpointSites(); - else - m_locations.ClearAllBreakpointSites(); - - SendBreakpointChangedEvent (enable ? eBreakpointEventTypeEnabled : eBreakpointEventTypeDisabled); + m_options.SetEnabled(enable); + if (enable) + m_locations.ResolveAllBreakpointSites(); + else + m_locations.ClearAllBreakpointSites(); + SendBreakpointChangedEvent(enable ? eBreakpointEventTypeEnabled + : eBreakpointEventTypeDisabled); } -bool -Breakpoint::IsEnabled () -{ - return m_options.IsEnabled(); -} +bool Breakpoint::IsEnabled() { return m_options.IsEnabled(); } -void -Breakpoint::SetIgnoreCount (uint32_t n) -{ - if (m_options.GetIgnoreCount() == n) - return; - - m_options.SetIgnoreCount(n); - SendBreakpointChangedEvent (eBreakpointEventTypeIgnoreChanged); -} +void Breakpoint::SetIgnoreCount(uint32_t n) { + if (m_options.GetIgnoreCount() == n) + return; -void -Breakpoint::DecrementIgnoreCount () -{ - uint32_t ignore = m_options.GetIgnoreCount(); - if (ignore != 0) - m_options.SetIgnoreCount(ignore - 1); + m_options.SetIgnoreCount(n); + SendBreakpointChangedEvent(eBreakpointEventTypeIgnoreChanged); } -uint32_t -Breakpoint::GetIgnoreCount () const -{ - return m_options.GetIgnoreCount(); +void Breakpoint::DecrementIgnoreCount() { + uint32_t ignore = m_options.GetIgnoreCount(); + if (ignore != 0) + m_options.SetIgnoreCount(ignore - 1); } -bool -Breakpoint::IgnoreCountShouldStop () -{ - uint32_t ignore = GetIgnoreCount(); - if (ignore != 0) - { - // When we get here we know the location that caused the stop doesn't have an ignore count, - // since by contract we call it first... So we don't have to find & decrement it, we only have - // to decrement our own ignore count. - DecrementIgnoreCount(); - return false; - } - else - return true; +uint32_t Breakpoint::GetIgnoreCount() const { + return m_options.GetIgnoreCount(); } -uint32_t -Breakpoint::GetHitCount () const -{ - return m_hit_count; +bool Breakpoint::IgnoreCountShouldStop() { + uint32_t ignore = GetIgnoreCount(); + if (ignore != 0) { + // When we get here we know the location that caused the stop doesn't have + // an ignore count, + // since by contract we call it first... So we don't have to find & + // decrement it, we only have + // to decrement our own ignore count. + DecrementIgnoreCount(); + return false; + } else + return true; } -bool -Breakpoint::IsOneShot () const -{ - return m_options.IsOneShot(); -} +uint32_t Breakpoint::GetHitCount() const { return m_hit_count; } -void -Breakpoint::SetOneShot (bool one_shot) -{ - m_options.SetOneShot (one_shot); -} +bool Breakpoint::IsOneShot() const { return m_options.IsOneShot(); } -void -Breakpoint::SetThreadID (lldb::tid_t thread_id) -{ - if (m_options.GetThreadSpec()->GetTID() == thread_id) - return; - - m_options.GetThreadSpec()->SetTID(thread_id); - SendBreakpointChangedEvent (eBreakpointEventTypeThreadChanged); +void Breakpoint::SetOneShot(bool one_shot) { m_options.SetOneShot(one_shot); } + +void Breakpoint::SetThreadID(lldb::tid_t thread_id) { + if (m_options.GetThreadSpec()->GetTID() == thread_id) + return; + + m_options.GetThreadSpec()->SetTID(thread_id); + SendBreakpointChangedEvent(eBreakpointEventTypeThreadChanged); } -lldb::tid_t -Breakpoint::GetThreadID () const -{ - if (m_options.GetThreadSpecNoCreate() == nullptr) - return LLDB_INVALID_THREAD_ID; - else - return m_options.GetThreadSpecNoCreate()->GetTID(); +lldb::tid_t Breakpoint::GetThreadID() const { + if (m_options.GetThreadSpecNoCreate() == nullptr) + return LLDB_INVALID_THREAD_ID; + else + return m_options.GetThreadSpecNoCreate()->GetTID(); } -void -Breakpoint::SetThreadIndex (uint32_t index) -{ - if (m_options.GetThreadSpec()->GetIndex() == index) - return; - - m_options.GetThreadSpec()->SetIndex(index); - SendBreakpointChangedEvent (eBreakpointEventTypeThreadChanged); +void Breakpoint::SetThreadIndex(uint32_t index) { + if (m_options.GetThreadSpec()->GetIndex() == index) + return; + + m_options.GetThreadSpec()->SetIndex(index); + SendBreakpointChangedEvent(eBreakpointEventTypeThreadChanged); } -uint32_t -Breakpoint::GetThreadIndex() const -{ - if (m_options.GetThreadSpecNoCreate() == nullptr) - return 0; - else - return m_options.GetThreadSpecNoCreate()->GetIndex(); +uint32_t Breakpoint::GetThreadIndex() const { + if (m_options.GetThreadSpecNoCreate() == nullptr) + return 0; + else + return m_options.GetThreadSpecNoCreate()->GetIndex(); } -void -Breakpoint::SetThreadName (const char *thread_name) -{ - if (m_options.GetThreadSpec()->GetName() != nullptr - && ::strcmp (m_options.GetThreadSpec()->GetName(), thread_name) == 0) - return; - - m_options.GetThreadSpec()->SetName (thread_name); - SendBreakpointChangedEvent (eBreakpointEventTypeThreadChanged); +void Breakpoint::SetThreadName(const char *thread_name) { + if (m_options.GetThreadSpec()->GetName() != nullptr && + ::strcmp(m_options.GetThreadSpec()->GetName(), thread_name) == 0) + return; + + m_options.GetThreadSpec()->SetName(thread_name); + SendBreakpointChangedEvent(eBreakpointEventTypeThreadChanged); } -const char * -Breakpoint::GetThreadName () const -{ - if (m_options.GetThreadSpecNoCreate() == nullptr) - return nullptr; - else - return m_options.GetThreadSpecNoCreate()->GetName(); +const char *Breakpoint::GetThreadName() const { + if (m_options.GetThreadSpecNoCreate() == nullptr) + return nullptr; + else + return m_options.GetThreadSpecNoCreate()->GetName(); } -void -Breakpoint::SetQueueName (const char *queue_name) -{ - if (m_options.GetThreadSpec()->GetQueueName() != nullptr - && ::strcmp (m_options.GetThreadSpec()->GetQueueName(), queue_name) == 0) - return; - - m_options.GetThreadSpec()->SetQueueName (queue_name); - SendBreakpointChangedEvent (eBreakpointEventTypeThreadChanged); +void Breakpoint::SetQueueName(const char *queue_name) { + if (m_options.GetThreadSpec()->GetQueueName() != nullptr && + ::strcmp(m_options.GetThreadSpec()->GetQueueName(), queue_name) == 0) + return; + + m_options.GetThreadSpec()->SetQueueName(queue_name); + SendBreakpointChangedEvent(eBreakpointEventTypeThreadChanged); } -const char * -Breakpoint::GetQueueName () const -{ - if (m_options.GetThreadSpecNoCreate() == nullptr) - return nullptr; - else - return m_options.GetThreadSpecNoCreate()->GetQueueName(); +const char *Breakpoint::GetQueueName() const { + if (m_options.GetThreadSpecNoCreate() == nullptr) + return nullptr; + else + return m_options.GetThreadSpecNoCreate()->GetQueueName(); } -void -Breakpoint::SetCondition (const char *condition) -{ - m_options.SetCondition (condition); - SendBreakpointChangedEvent (eBreakpointEventTypeConditionChanged); +void Breakpoint::SetCondition(const char *condition) { + m_options.SetCondition(condition); + SendBreakpointChangedEvent(eBreakpointEventTypeConditionChanged); } -const char * -Breakpoint::GetConditionText () const -{ - return m_options.GetConditionText(); +const char *Breakpoint::GetConditionText() const { + return m_options.GetConditionText(); } // This function is used when "baton" doesn't need to be freed -void -Breakpoint::SetCallback (BreakpointHitCallback callback, void *baton, bool is_synchronous) -{ - // The default "Baton" class will keep a copy of "baton" and won't free - // or delete it when it goes goes out of scope. - m_options.SetCallback(callback, BatonSP (new Baton(baton)), is_synchronous); - - SendBreakpointChangedEvent (eBreakpointEventTypeCommandChanged); +void Breakpoint::SetCallback(BreakpointHitCallback callback, void *baton, + bool is_synchronous) { + // The default "Baton" class will keep a copy of "baton" and won't free + // or delete it when it goes goes out of scope. + m_options.SetCallback(callback, BatonSP(new Baton(baton)), is_synchronous); + + SendBreakpointChangedEvent(eBreakpointEventTypeCommandChanged); } -// This function is used when a baton needs to be freed and therefore is +// This function is used when a baton needs to be freed and therefore is // contained in a "Baton" subclass. -void -Breakpoint::SetCallback (BreakpointHitCallback callback, const BatonSP &callback_baton_sp, bool is_synchronous) -{ - m_options.SetCallback(callback, callback_baton_sp, is_synchronous); +void Breakpoint::SetCallback(BreakpointHitCallback callback, + const BatonSP &callback_baton_sp, + bool is_synchronous) { + m_options.SetCallback(callback, callback_baton_sp, is_synchronous); } -void -Breakpoint::ClearCallback () -{ - m_options.ClearCallback (); -} +void Breakpoint::ClearCallback() { m_options.ClearCallback(); } -bool -Breakpoint::InvokeCallback (StoppointCallbackContext *context, break_id_t bp_loc_id) -{ - return m_options.InvokeCallback (context, GetID(), bp_loc_id); +bool Breakpoint::InvokeCallback(StoppointCallbackContext *context, + break_id_t bp_loc_id) { + return m_options.InvokeCallback(context, GetID(), bp_loc_id); } -BreakpointOptions * -Breakpoint::GetOptions () -{ - return &m_options; -} +BreakpointOptions *Breakpoint::GetOptions() { return &m_options; } -void -Breakpoint::ResolveBreakpoint () -{ - if (m_resolver_sp) - m_resolver_sp->ResolveBreakpoint(*m_filter_sp); +void Breakpoint::ResolveBreakpoint() { + if (m_resolver_sp) + m_resolver_sp->ResolveBreakpoint(*m_filter_sp); } -void -Breakpoint::ResolveBreakpointInModules (ModuleList &module_list, BreakpointLocationCollection &new_locations) -{ - m_locations.StartRecordingNewLocations(new_locations); - - m_resolver_sp->ResolveBreakpointInModules(*m_filter_sp, module_list); +void Breakpoint::ResolveBreakpointInModules( + ModuleList &module_list, BreakpointLocationCollection &new_locations) { + m_locations.StartRecordingNewLocations(new_locations); - m_locations.StopRecordingNewLocations(); + m_resolver_sp->ResolveBreakpointInModules(*m_filter_sp, module_list); + + m_locations.StopRecordingNewLocations(); } -void -Breakpoint::ResolveBreakpointInModules (ModuleList &module_list, bool send_event) -{ - if (m_resolver_sp) - { - // If this is not an internal breakpoint, set up to record the new locations, then dispatch - // an event with the new locations. - if (!IsInternal() && send_event) - { - BreakpointEventData *new_locations_event = new BreakpointEventData (eBreakpointEventTypeLocationsAdded, - shared_from_this()); - - ResolveBreakpointInModules (module_list, new_locations_event->GetBreakpointLocationCollection()); - - if (new_locations_event->GetBreakpointLocationCollection().GetSize() != 0) - { - SendBreakpointChangedEvent (new_locations_event); - } - else - delete new_locations_event; - } - else - { - m_resolver_sp->ResolveBreakpointInModules(*m_filter_sp, module_list); - } +void Breakpoint::ResolveBreakpointInModules(ModuleList &module_list, + bool send_event) { + if (m_resolver_sp) { + // If this is not an internal breakpoint, set up to record the new + // locations, then dispatch + // an event with the new locations. + if (!IsInternal() && send_event) { + BreakpointEventData *new_locations_event = new BreakpointEventData( + eBreakpointEventTypeLocationsAdded, shared_from_this()); + + ResolveBreakpointInModules( + module_list, new_locations_event->GetBreakpointLocationCollection()); + + if (new_locations_event->GetBreakpointLocationCollection().GetSize() != + 0) { + SendBreakpointChangedEvent(new_locations_event); + } else + delete new_locations_event; + } else { + m_resolver_sp->ResolveBreakpointInModules(*m_filter_sp, module_list); } + } } -void -Breakpoint::ClearAllBreakpointSites () -{ - m_locations.ClearAllBreakpointSites(); +void Breakpoint::ClearAllBreakpointSites() { + m_locations.ClearAllBreakpointSites(); } //---------------------------------------------------------------------- // ModulesChanged: Pass in a list of new modules, and //---------------------------------------------------------------------- -void -Breakpoint::ModulesChanged (ModuleList &module_list, bool load, bool delete_locations) -{ - Log *log (lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_BREAKPOINTS)); - if (log) - log->Printf ("Breakpoint::ModulesChanged: num_modules: %zu load: %i delete_locations: %i\n", - module_list.GetSize(), load, delete_locations); - - std::lock_guard<std::recursive_mutex> guard(module_list.GetMutex()); - if (load) - { - // The logic for handling new modules is: - // 1) If the filter rejects this module, then skip it. - // 2) Run through the current location list and if there are any locations - // for that module, we mark the module as "seen" and we don't try to re-resolve - // breakpoint locations for that module. - // However, we do add breakpoint sites to these locations if needed. - // 3) If we don't see this module in our breakpoint location list, call ResolveInModules. - - ModuleList new_modules; // We'll stuff the "unseen" modules in this list, and then resolve - // them after the locations pass. Have to do it this way because - // resolving breakpoints will add new locations potentially. - - for (ModuleSP module_sp : module_list.ModulesNoLocking()) - { - bool seen = false; - if (!m_filter_sp->ModulePasses (module_sp)) - continue; - - for (BreakpointLocationSP break_loc_sp : m_locations.BreakpointLocations()) - { - if (!break_loc_sp->IsEnabled()) - continue; - SectionSP section_sp (break_loc_sp->GetAddress().GetSection()); - if (!section_sp || section_sp->GetModule() == module_sp) - { - if (!seen) - seen = true; - - if (!break_loc_sp->ResolveBreakpointSite()) - { - if (log) - log->Printf ("Warning: could not set breakpoint site for breakpoint location %d of breakpoint %d.\n", - break_loc_sp->GetID(), GetID()); - } - } - } - - if (!seen) - new_modules.AppendIfNeeded (module_sp); - } - - if (new_modules.GetSize() > 0) - { - ResolveBreakpointInModules(new_modules); +void Breakpoint::ModulesChanged(ModuleList &module_list, bool load, + bool delete_locations) { + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_BREAKPOINTS)); + if (log) + log->Printf("Breakpoint::ModulesChanged: num_modules: %zu load: %i " + "delete_locations: %i\n", + module_list.GetSize(), load, delete_locations); + + std::lock_guard<std::recursive_mutex> guard(module_list.GetMutex()); + if (load) { + // The logic for handling new modules is: + // 1) If the filter rejects this module, then skip it. + // 2) Run through the current location list and if there are any locations + // for that module, we mark the module as "seen" and we don't try to + // re-resolve + // breakpoint locations for that module. + // However, we do add breakpoint sites to these locations if needed. + // 3) If we don't see this module in our breakpoint location list, call + // ResolveInModules. + + ModuleList new_modules; // We'll stuff the "unseen" modules in this list, + // and then resolve + // them after the locations pass. Have to do it this way because + // resolving breakpoints will add new locations potentially. + + for (ModuleSP module_sp : module_list.ModulesNoLocking()) { + bool seen = false; + if (!m_filter_sp->ModulePasses(module_sp)) + continue; + + for (BreakpointLocationSP break_loc_sp : + m_locations.BreakpointLocations()) { + if (!break_loc_sp->IsEnabled()) + continue; + SectionSP section_sp(break_loc_sp->GetAddress().GetSection()); + if (!section_sp || section_sp->GetModule() == module_sp) { + if (!seen) + seen = true; + + if (!break_loc_sp->ResolveBreakpointSite()) { + if (log) + log->Printf("Warning: could not set breakpoint site for " + "breakpoint location %d of breakpoint %d.\n", + break_loc_sp->GetID(), GetID()); + } } + } + + if (!seen) + new_modules.AppendIfNeeded(module_sp); } + + if (new_modules.GetSize() > 0) { + ResolveBreakpointInModules(new_modules); + } + } else { + // Go through the currently set locations and if any have breakpoints in + // the module list, then remove their breakpoint sites, and their locations + // if asked to. + + BreakpointEventData *removed_locations_event; + if (!IsInternal()) + removed_locations_event = new BreakpointEventData( + eBreakpointEventTypeLocationsRemoved, shared_from_this()); else - { - // Go through the currently set locations and if any have breakpoints in - // the module list, then remove their breakpoint sites, and their locations if asked to. - - BreakpointEventData *removed_locations_event; - if (!IsInternal()) - removed_locations_event = new BreakpointEventData (eBreakpointEventTypeLocationsRemoved, - shared_from_this()); - else - removed_locations_event = nullptr; - - size_t num_modules = module_list.GetSize(); - for (size_t i = 0; i < num_modules; i++) - { - ModuleSP module_sp (module_list.GetModuleAtIndexUnlocked (i)); - if (m_filter_sp->ModulePasses (module_sp)) - { - size_t loc_idx = 0; - size_t num_locations = m_locations.GetSize(); - BreakpointLocationCollection locations_to_remove; - for (loc_idx = 0; loc_idx < num_locations; loc_idx++) - { - BreakpointLocationSP break_loc_sp (m_locations.GetByIndex(loc_idx)); - SectionSP section_sp (break_loc_sp->GetAddress().GetSection()); - if (section_sp && section_sp->GetModule() == module_sp) - { - // Remove this breakpoint since the shared library is - // unloaded, but keep the breakpoint location around - // so we always get complete hit count and breakpoint - // lifetime info - break_loc_sp->ClearBreakpointSite(); - if (removed_locations_event) - { - removed_locations_event->GetBreakpointLocationCollection().Add(break_loc_sp); - } - if (delete_locations) - locations_to_remove.Add (break_loc_sp); - } - } - - if (delete_locations) - { - size_t num_locations_to_remove = locations_to_remove.GetSize(); - for (loc_idx = 0; loc_idx < num_locations_to_remove; loc_idx++) - m_locations.RemoveLocation (locations_to_remove.GetByIndex(loc_idx)); - } + removed_locations_event = nullptr; + + size_t num_modules = module_list.GetSize(); + for (size_t i = 0; i < num_modules; i++) { + ModuleSP module_sp(module_list.GetModuleAtIndexUnlocked(i)); + if (m_filter_sp->ModulePasses(module_sp)) { + size_t loc_idx = 0; + size_t num_locations = m_locations.GetSize(); + BreakpointLocationCollection locations_to_remove; + for (loc_idx = 0; loc_idx < num_locations; loc_idx++) { + BreakpointLocationSP break_loc_sp(m_locations.GetByIndex(loc_idx)); + SectionSP section_sp(break_loc_sp->GetAddress().GetSection()); + if (section_sp && section_sp->GetModule() == module_sp) { + // Remove this breakpoint since the shared library is + // unloaded, but keep the breakpoint location around + // so we always get complete hit count and breakpoint + // lifetime info + break_loc_sp->ClearBreakpointSite(); + if (removed_locations_event) { + removed_locations_event->GetBreakpointLocationCollection().Add( + break_loc_sp); } + if (delete_locations) + locations_to_remove.Add(break_loc_sp); + } } - SendBreakpointChangedEvent (removed_locations_event); - } -} -namespace -{ -static bool -SymbolContextsMightBeEquivalent(SymbolContext &old_sc, SymbolContext &new_sc) -{ - bool equivalent_scs = false; - - if (old_sc.module_sp.get() == new_sc.module_sp.get()) - { - // If these come from the same module, we can directly compare the pointers: - if (old_sc.comp_unit && new_sc.comp_unit - && (old_sc.comp_unit == new_sc.comp_unit)) - { - if (old_sc.function && new_sc.function - && (old_sc.function == new_sc.function)) - { - equivalent_scs = true; - } - } - else if (old_sc.symbol && new_sc.symbol - && (old_sc.symbol == new_sc.symbol)) - { - equivalent_scs = true; + if (delete_locations) { + size_t num_locations_to_remove = locations_to_remove.GetSize(); + for (loc_idx = 0; loc_idx < num_locations_to_remove; loc_idx++) + m_locations.RemoveLocation(locations_to_remove.GetByIndex(loc_idx)); } + } } - else - { - // Otherwise we will compare by name... - if (old_sc.comp_unit && new_sc.comp_unit) - { - if (FileSpec::Equal(*old_sc.comp_unit, *new_sc.comp_unit, true)) - { - // Now check the functions: - if (old_sc.function && new_sc.function - && (old_sc.function->GetName() == new_sc.function->GetName())) - { - equivalent_scs = true; - } - } - } - else if (old_sc.symbol && new_sc.symbol) - { - if (Mangled::Compare(old_sc.symbol->GetMangled(), new_sc.symbol->GetMangled()) == 0) - { - equivalent_scs = true; - } + SendBreakpointChangedEvent(removed_locations_event); + } +} + +namespace { +static bool SymbolContextsMightBeEquivalent(SymbolContext &old_sc, + SymbolContext &new_sc) { + bool equivalent_scs = false; + + if (old_sc.module_sp.get() == new_sc.module_sp.get()) { + // If these come from the same module, we can directly compare the pointers: + if (old_sc.comp_unit && new_sc.comp_unit && + (old_sc.comp_unit == new_sc.comp_unit)) { + if (old_sc.function && new_sc.function && + (old_sc.function == new_sc.function)) { + equivalent_scs = true; + } + } else if (old_sc.symbol && new_sc.symbol && + (old_sc.symbol == new_sc.symbol)) { + equivalent_scs = true; + } + } else { + // Otherwise we will compare by name... + if (old_sc.comp_unit && new_sc.comp_unit) { + if (FileSpec::Equal(*old_sc.comp_unit, *new_sc.comp_unit, true)) { + // Now check the functions: + if (old_sc.function && new_sc.function && + (old_sc.function->GetName() == new_sc.function->GetName())) { + equivalent_scs = true; } + } + } else if (old_sc.symbol && new_sc.symbol) { + if (Mangled::Compare(old_sc.symbol->GetMangled(), + new_sc.symbol->GetMangled()) == 0) { + equivalent_scs = true; + } } - return equivalent_scs; + } + return equivalent_scs; } } // anonymous namespace -void -Breakpoint::ModuleReplaced (ModuleSP old_module_sp, ModuleSP new_module_sp) -{ - Log *log (lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_BREAKPOINTS)); - if (log) - log->Printf ("Breakpoint::ModulesReplaced for %s\n", - old_module_sp->GetSpecificationDescription().c_str()); - // First find all the locations that are in the old module - - BreakpointLocationCollection old_break_locs; - for (BreakpointLocationSP break_loc_sp : m_locations.BreakpointLocations()) - { - SectionSP section_sp = break_loc_sp->GetAddress().GetSection(); - if (section_sp && section_sp->GetModule() == old_module_sp) - { - old_break_locs.Add(break_loc_sp); - } - } - - size_t num_old_locations = old_break_locs.GetSize(); - - if (num_old_locations == 0) - { - // There were no locations in the old module, so we just need to check if there were any in the new module. - ModuleList temp_list; - temp_list.Append (new_module_sp); - ResolveBreakpointInModules(temp_list); +void Breakpoint::ModuleReplaced(ModuleSP old_module_sp, + ModuleSP new_module_sp) { + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_BREAKPOINTS)); + if (log) + log->Printf("Breakpoint::ModulesReplaced for %s\n", + old_module_sp->GetSpecificationDescription().c_str()); + // First find all the locations that are in the old module + + BreakpointLocationCollection old_break_locs; + for (BreakpointLocationSP break_loc_sp : m_locations.BreakpointLocations()) { + SectionSP section_sp = break_loc_sp->GetAddress().GetSection(); + if (section_sp && section_sp->GetModule() == old_module_sp) { + old_break_locs.Add(break_loc_sp); } - else - { - // First search the new module for locations. - // Then compare this with the old list, copy over locations that "look the same" - // Then delete the old locations. - // Finally remember to post the creation event. - // - // Two locations are the same if they have the same comp unit & function (by name) and there are the same number - // of locations in the old function as in the new one. - - ModuleList temp_list; - temp_list.Append (new_module_sp); - BreakpointLocationCollection new_break_locs; - ResolveBreakpointInModules(temp_list, new_break_locs); - BreakpointLocationCollection locations_to_remove; - BreakpointLocationCollection locations_to_announce; - - size_t num_new_locations = new_break_locs.GetSize(); - - if (num_new_locations > 0) - { - // Break out the case of one location -> one location since that's the most common one, and there's no need - // to build up the structures needed for the merge in that case. - if (num_new_locations == 1 && num_old_locations == 1) - { - bool equivalent_locations = false; - SymbolContext old_sc, new_sc; - // The only way the old and new location can be equivalent is if they have the same amount of information: - BreakpointLocationSP old_loc_sp = old_break_locs.GetByIndex(0); - BreakpointLocationSP new_loc_sp = new_break_locs.GetByIndex(0); - - if (old_loc_sp->GetAddress().CalculateSymbolContext(&old_sc) - == new_loc_sp->GetAddress().CalculateSymbolContext(&new_sc)) - { - equivalent_locations = SymbolContextsMightBeEquivalent(old_sc, new_sc); - } - - if (equivalent_locations) - { - m_locations.SwapLocation (old_loc_sp, new_loc_sp); - } - else - { - locations_to_remove.Add(old_loc_sp); - locations_to_announce.Add(new_loc_sp); - } - } - else - { - //We don't want to have to keep computing the SymbolContexts for these addresses over and over, - // so lets get them up front: - - typedef std::map<lldb::break_id_t, SymbolContext> IDToSCMap; - IDToSCMap old_sc_map; - for (size_t idx = 0; idx < num_old_locations; idx++) - { - SymbolContext sc; - BreakpointLocationSP bp_loc_sp = old_break_locs.GetByIndex(idx); - lldb::break_id_t loc_id = bp_loc_sp->GetID(); - bp_loc_sp->GetAddress().CalculateSymbolContext(&old_sc_map[loc_id]); - } - - std::map<lldb::break_id_t, SymbolContext> new_sc_map; - for (size_t idx = 0; idx < num_new_locations; idx++) - { - SymbolContext sc; - BreakpointLocationSP bp_loc_sp = new_break_locs.GetByIndex(idx); - lldb::break_id_t loc_id = bp_loc_sp->GetID(); - bp_loc_sp->GetAddress().CalculateSymbolContext(&new_sc_map[loc_id]); - } - // Take an element from the old Symbol Contexts - while (old_sc_map.size() > 0) - { - lldb::break_id_t old_id = old_sc_map.begin()->first; - SymbolContext &old_sc = old_sc_map.begin()->second; - - // Count the number of entries equivalent to this SC for the old list: - std::vector<lldb::break_id_t> old_id_vec; - old_id_vec.push_back(old_id); - - IDToSCMap::iterator tmp_iter; - for (tmp_iter = ++old_sc_map.begin(); tmp_iter != old_sc_map.end(); tmp_iter++) - { - if (SymbolContextsMightBeEquivalent (old_sc, tmp_iter->second)) - old_id_vec.push_back (tmp_iter->first); - } - - // Now find all the equivalent locations in the new list. - std::vector<lldb::break_id_t> new_id_vec; - for (tmp_iter = new_sc_map.begin(); tmp_iter != new_sc_map.end(); tmp_iter++) - { - if (SymbolContextsMightBeEquivalent (old_sc, tmp_iter->second)) - new_id_vec.push_back(tmp_iter->first); - } - - // Alright, if we have the same number of potentially equivalent locations in the old - // and new modules, we'll just map them one to one in ascending ID order (assuming the - // resolver's order would match the equivalent ones. - // Otherwise, we'll dump all the old ones, and just take the new ones, erasing the elements - // from both maps as we go. - - if (old_id_vec.size() == new_id_vec.size()) - { - sort(old_id_vec.begin(), old_id_vec.end()); - sort(new_id_vec.begin(), new_id_vec.end()); - size_t num_elements = old_id_vec.size(); - for (size_t idx = 0; idx < num_elements; idx++) - { - BreakpointLocationSP old_loc_sp = old_break_locs.FindByIDPair(GetID(), old_id_vec[idx]); - BreakpointLocationSP new_loc_sp = new_break_locs.FindByIDPair(GetID(), new_id_vec[idx]); - m_locations.SwapLocation(old_loc_sp, new_loc_sp); - old_sc_map.erase(old_id_vec[idx]); - new_sc_map.erase(new_id_vec[idx]); - } - } - else - { - for (lldb::break_id_t old_id : old_id_vec) - { - locations_to_remove.Add(old_break_locs.FindByIDPair(GetID(), old_id)); - old_sc_map.erase(old_id); - } - for (lldb::break_id_t new_id : new_id_vec) - { - locations_to_announce.Add(new_break_locs.FindByIDPair(GetID(), new_id)); - new_sc_map.erase(new_id); - } - } - } - } + } + + size_t num_old_locations = old_break_locs.GetSize(); + + if (num_old_locations == 0) { + // There were no locations in the old module, so we just need to check if + // there were any in the new module. + ModuleList temp_list; + temp_list.Append(new_module_sp); + ResolveBreakpointInModules(temp_list); + } else { + // First search the new module for locations. + // Then compare this with the old list, copy over locations that "look the + // same" + // Then delete the old locations. + // Finally remember to post the creation event. + // + // Two locations are the same if they have the same comp unit & function (by + // name) and there are the same number + // of locations in the old function as in the new one. + + ModuleList temp_list; + temp_list.Append(new_module_sp); + BreakpointLocationCollection new_break_locs; + ResolveBreakpointInModules(temp_list, new_break_locs); + BreakpointLocationCollection locations_to_remove; + BreakpointLocationCollection locations_to_announce; + + size_t num_new_locations = new_break_locs.GetSize(); + + if (num_new_locations > 0) { + // Break out the case of one location -> one location since that's the + // most common one, and there's no need + // to build up the structures needed for the merge in that case. + if (num_new_locations == 1 && num_old_locations == 1) { + bool equivalent_locations = false; + SymbolContext old_sc, new_sc; + // The only way the old and new location can be equivalent is if they + // have the same amount of information: + BreakpointLocationSP old_loc_sp = old_break_locs.GetByIndex(0); + BreakpointLocationSP new_loc_sp = new_break_locs.GetByIndex(0); + + if (old_loc_sp->GetAddress().CalculateSymbolContext(&old_sc) == + new_loc_sp->GetAddress().CalculateSymbolContext(&new_sc)) { + equivalent_locations = + SymbolContextsMightBeEquivalent(old_sc, new_sc); } - - // Now remove the remaining old locations, and cons up a removed locations event. - // Note, we don't put the new locations that were swapped with an old location on the locations_to_remove - // list, so we don't need to worry about telling the world about removing a location we didn't tell them - // about adding. - - BreakpointEventData *locations_event; - if (!IsInternal()) - locations_event = new BreakpointEventData (eBreakpointEventTypeLocationsRemoved, - shared_from_this()); - else - locations_event = nullptr; - - for (BreakpointLocationSP loc_sp : locations_to_remove.BreakpointLocations()) - { - m_locations.RemoveLocation(loc_sp); - if (locations_event) - locations_event->GetBreakpointLocationCollection().Add(loc_sp); + + if (equivalent_locations) { + m_locations.SwapLocation(old_loc_sp, new_loc_sp); + } else { + locations_to_remove.Add(old_loc_sp); + locations_to_announce.Add(new_loc_sp); + } + } else { + // We don't want to have to keep computing the SymbolContexts for these + // addresses over and over, + // so lets get them up front: + + typedef std::map<lldb::break_id_t, SymbolContext> IDToSCMap; + IDToSCMap old_sc_map; + for (size_t idx = 0; idx < num_old_locations; idx++) { + SymbolContext sc; + BreakpointLocationSP bp_loc_sp = old_break_locs.GetByIndex(idx); + lldb::break_id_t loc_id = bp_loc_sp->GetID(); + bp_loc_sp->GetAddress().CalculateSymbolContext(&old_sc_map[loc_id]); + } + + std::map<lldb::break_id_t, SymbolContext> new_sc_map; + for (size_t idx = 0; idx < num_new_locations; idx++) { + SymbolContext sc; + BreakpointLocationSP bp_loc_sp = new_break_locs.GetByIndex(idx); + lldb::break_id_t loc_id = bp_loc_sp->GetID(); + bp_loc_sp->GetAddress().CalculateSymbolContext(&new_sc_map[loc_id]); } - SendBreakpointChangedEvent (locations_event); - - // And announce the new ones. - - if (!IsInternal()) - { - locations_event = new BreakpointEventData (eBreakpointEventTypeLocationsAdded, - shared_from_this()); - for (BreakpointLocationSP loc_sp : locations_to_announce.BreakpointLocations()) - locations_event->GetBreakpointLocationCollection().Add(loc_sp); - - SendBreakpointChangedEvent (locations_event); + // Take an element from the old Symbol Contexts + while (old_sc_map.size() > 0) { + lldb::break_id_t old_id = old_sc_map.begin()->first; + SymbolContext &old_sc = old_sc_map.begin()->second; + + // Count the number of entries equivalent to this SC for the old list: + std::vector<lldb::break_id_t> old_id_vec; + old_id_vec.push_back(old_id); + + IDToSCMap::iterator tmp_iter; + for (tmp_iter = ++old_sc_map.begin(); tmp_iter != old_sc_map.end(); + tmp_iter++) { + if (SymbolContextsMightBeEquivalent(old_sc, tmp_iter->second)) + old_id_vec.push_back(tmp_iter->first); + } + + // Now find all the equivalent locations in the new list. + std::vector<lldb::break_id_t> new_id_vec; + for (tmp_iter = new_sc_map.begin(); tmp_iter != new_sc_map.end(); + tmp_iter++) { + if (SymbolContextsMightBeEquivalent(old_sc, tmp_iter->second)) + new_id_vec.push_back(tmp_iter->first); + } + + // Alright, if we have the same number of potentially equivalent + // locations in the old + // and new modules, we'll just map them one to one in ascending ID + // order (assuming the + // resolver's order would match the equivalent ones. + // Otherwise, we'll dump all the old ones, and just take the new ones, + // erasing the elements + // from both maps as we go. + + if (old_id_vec.size() == new_id_vec.size()) { + sort(old_id_vec.begin(), old_id_vec.end()); + sort(new_id_vec.begin(), new_id_vec.end()); + size_t num_elements = old_id_vec.size(); + for (size_t idx = 0; idx < num_elements; idx++) { + BreakpointLocationSP old_loc_sp = + old_break_locs.FindByIDPair(GetID(), old_id_vec[idx]); + BreakpointLocationSP new_loc_sp = + new_break_locs.FindByIDPair(GetID(), new_id_vec[idx]); + m_locations.SwapLocation(old_loc_sp, new_loc_sp); + old_sc_map.erase(old_id_vec[idx]); + new_sc_map.erase(new_id_vec[idx]); + } + } else { + for (lldb::break_id_t old_id : old_id_vec) { + locations_to_remove.Add( + old_break_locs.FindByIDPair(GetID(), old_id)); + old_sc_map.erase(old_id); + } + for (lldb::break_id_t new_id : new_id_vec) { + locations_to_announce.Add( + new_break_locs.FindByIDPair(GetID(), new_id)); + new_sc_map.erase(new_id); + } + } } - m_locations.Compact(); + } } -} -void -Breakpoint::Dump (Stream *) -{ -} + // Now remove the remaining old locations, and cons up a removed locations + // event. + // Note, we don't put the new locations that were swapped with an old + // location on the locations_to_remove + // list, so we don't need to worry about telling the world about removing a + // location we didn't tell them + // about adding. + + BreakpointEventData *locations_event; + if (!IsInternal()) + locations_event = new BreakpointEventData( + eBreakpointEventTypeLocationsRemoved, shared_from_this()); + else + locations_event = nullptr; -size_t -Breakpoint::GetNumResolvedLocations() const -{ - // Return the number of breakpoints that are actually resolved and set - // down in the inferior process. - return m_locations.GetNumResolvedLocations(); -} + for (BreakpointLocationSP loc_sp : + locations_to_remove.BreakpointLocations()) { + m_locations.RemoveLocation(loc_sp); + if (locations_event) + locations_event->GetBreakpointLocationCollection().Add(loc_sp); + } + SendBreakpointChangedEvent(locations_event); -size_t -Breakpoint::GetNumLocations() const -{ - return m_locations.GetSize(); -} + // And announce the new ones. + + if (!IsInternal()) { + locations_event = new BreakpointEventData( + eBreakpointEventTypeLocationsAdded, shared_from_this()); + for (BreakpointLocationSP loc_sp : + locations_to_announce.BreakpointLocations()) + locations_event->GetBreakpointLocationCollection().Add(loc_sp); -bool -Breakpoint::AddName (const char *new_name, Error &error) -{ - if (!new_name) - return false; - if (!BreakpointID::StringIsBreakpointName(new_name, error)) - { - error.SetErrorStringWithFormat("input name \"%s\" not a breakpoint name.", new_name); - return false; + SendBreakpointChangedEvent(locations_event); } - if (!error.Success()) - return false; + m_locations.Compact(); + } +} - m_name_list.insert(new_name); - return true; +void Breakpoint::Dump(Stream *) {} + +size_t Breakpoint::GetNumResolvedLocations() const { + // Return the number of breakpoints that are actually resolved and set + // down in the inferior process. + return m_locations.GetNumResolvedLocations(); } -void -Breakpoint::GetDescription (Stream *s, lldb::DescriptionLevel level, bool show_locations) -{ - assert (s != nullptr); - - if (!m_kind_description.empty()) - { - if (level == eDescriptionLevelBrief) - { - s->PutCString (GetBreakpointKind()); - return; - } - else - s->Printf("Kind: %s\n", GetBreakpointKind ()); - } - - const size_t num_locations = GetNumLocations (); - const size_t num_resolved_locations = GetNumResolvedLocations (); - - // They just made the breakpoint, they don't need to be told HOW they made it... - // Also, we'll print the breakpoint number differently depending on whether there is 1 or more locations. - if (level != eDescriptionLevelInitial) - { - s->Printf("%i: ", GetID()); - GetResolverDescription (s); - GetFilterDescription (s); - } - - switch (level) - { - case lldb::eDescriptionLevelBrief: - case lldb::eDescriptionLevelFull: - if (num_locations > 0) - { - s->Printf(", locations = %" PRIu64, (uint64_t)num_locations); - if (num_resolved_locations > 0) - s->Printf(", resolved = %" PRIu64 ", hit count = %d", (uint64_t)num_resolved_locations, GetHitCount()); - } - else - { - // Don't print the pending notification for exception resolvers since we don't generally - // know how to set them until the target is run. - if (m_resolver_sp->getResolverID() != BreakpointResolver::ExceptionResolver) - s->Printf(", locations = 0 (pending)"); - } +size_t Breakpoint::GetNumLocations() const { return m_locations.GetSize(); } - GetOptions()->GetDescription(s, level); - - if (m_precondition_sp) - m_precondition_sp->GetDescription(*s, level); - - if (level == lldb::eDescriptionLevelFull) - { - if (!m_name_list.empty()) - { - s->EOL(); - s->Indent(); - s->Printf ("Names:"); - s->EOL(); - s->IndentMore(); - for (std::string name : m_name_list) - { - s->Indent(); - s->Printf("%s\n", name.c_str()); - } - s->IndentLess(); - } - s->IndentLess(); - s->EOL(); - } - break; - - case lldb::eDescriptionLevelInitial: - s->Printf ("Breakpoint %i: ", GetID()); - if (num_locations == 0) - { - s->Printf ("no locations (pending)."); - } - else if (num_locations == 1 && !show_locations) - { - // There is only one location, so we'll just print that location information. - GetLocationAtIndex(0)->GetDescription(s, level); - } - else - { - s->Printf ("%" PRIu64 " locations.", static_cast<uint64_t>(num_locations)); - } - s->EOL(); - break; - - case lldb::eDescriptionLevelVerbose: - // Verbose mode does a debug dump of the breakpoint - Dump (s); - s->EOL (); - //s->Indent(); - GetOptions()->GetDescription(s, level); - break; - - default: - break; +bool Breakpoint::AddName(const char *new_name, Error &error) { + if (!new_name) + return false; + if (!BreakpointID::StringIsBreakpointName(new_name, error)) { + error.SetErrorStringWithFormat("input name \"%s\" not a breakpoint name.", + new_name); + return false; + } + if (!error.Success()) + return false; + + m_name_list.insert(new_name); + return true; +} + +void Breakpoint::GetDescription(Stream *s, lldb::DescriptionLevel level, + bool show_locations) { + assert(s != nullptr); + + if (!m_kind_description.empty()) { + if (level == eDescriptionLevelBrief) { + s->PutCString(GetBreakpointKind()); + return; + } else + s->Printf("Kind: %s\n", GetBreakpointKind()); + } + + const size_t num_locations = GetNumLocations(); + const size_t num_resolved_locations = GetNumResolvedLocations(); + + // They just made the breakpoint, they don't need to be told HOW they made + // it... + // Also, we'll print the breakpoint number differently depending on whether + // there is 1 or more locations. + if (level != eDescriptionLevelInitial) { + s->Printf("%i: ", GetID()); + GetResolverDescription(s); + GetFilterDescription(s); + } + + switch (level) { + case lldb::eDescriptionLevelBrief: + case lldb::eDescriptionLevelFull: + if (num_locations > 0) { + s->Printf(", locations = %" PRIu64, (uint64_t)num_locations); + if (num_resolved_locations > 0) + s->Printf(", resolved = %" PRIu64 ", hit count = %d", + (uint64_t)num_resolved_locations, GetHitCount()); + } else { + // Don't print the pending notification for exception resolvers since we + // don't generally + // know how to set them until the target is run. + if (m_resolver_sp->getResolverID() != + BreakpointResolver::ExceptionResolver) + s->Printf(", locations = 0 (pending)"); } - // The brief description is just the location name (1.2 or whatever). That's pointless to - // show in the breakpoint's description, so suppress it. - if (show_locations && level != lldb::eDescriptionLevelBrief) - { + GetOptions()->GetDescription(s, level); + + if (m_precondition_sp) + m_precondition_sp->GetDescription(*s, level); + + if (level == lldb::eDescriptionLevelFull) { + if (!m_name_list.empty()) { + s->EOL(); + s->Indent(); + s->Printf("Names:"); + s->EOL(); s->IndentMore(); - for (size_t i = 0; i < num_locations; ++i) - { - BreakpointLocation *loc = GetLocationAtIndex(i).get(); - loc->GetDescription(s, level); - s->EOL(); + for (std::string name : m_name_list) { + s->Indent(); + s->Printf("%s\n", name.c_str()); } s->IndentLess(); + } + s->IndentLess(); + s->EOL(); + } + break; + + case lldb::eDescriptionLevelInitial: + s->Printf("Breakpoint %i: ", GetID()); + if (num_locations == 0) { + s->Printf("no locations (pending)."); + } else if (num_locations == 1 && !show_locations) { + // There is only one location, so we'll just print that location + // information. + GetLocationAtIndex(0)->GetDescription(s, level); + } else { + s->Printf("%" PRIu64 " locations.", static_cast<uint64_t>(num_locations)); + } + s->EOL(); + break; + + case lldb::eDescriptionLevelVerbose: + // Verbose mode does a debug dump of the breakpoint + Dump(s); + s->EOL(); + // s->Indent(); + GetOptions()->GetDescription(s, level); + break; + + default: + break; + } + + // The brief description is just the location name (1.2 or whatever). That's + // pointless to + // show in the breakpoint's description, so suppress it. + if (show_locations && level != lldb::eDescriptionLevelBrief) { + s->IndentMore(); + for (size_t i = 0; i < num_locations; ++i) { + BreakpointLocation *loc = GetLocationAtIndex(i).get(); + loc->GetDescription(s, level); + s->EOL(); } + s->IndentLess(); + } +} + +void Breakpoint::GetResolverDescription(Stream *s) { + if (m_resolver_sp) + m_resolver_sp->GetDescription(s); +} + +bool Breakpoint::GetMatchingFileLine(const ConstString &filename, + uint32_t line_number, + BreakpointLocationCollection &loc_coll) { + // TODO: To be correct, this method needs to fill the breakpoint location + // collection + // with the location IDs which match the filename and line_number. + // + + if (m_resolver_sp) { + BreakpointResolverFileLine *resolverFileLine = + dyn_cast<BreakpointResolverFileLine>(m_resolver_sp.get()); + if (resolverFileLine && + resolverFileLine->m_file_spec.GetFilename() == filename && + resolverFileLine->m_line_number == line_number) { + return true; + } + } + return false; } -void -Breakpoint::GetResolverDescription (Stream *s) -{ - if (m_resolver_sp) - m_resolver_sp->GetDescription (s); +void Breakpoint::GetFilterDescription(Stream *s) { + m_filter_sp->GetDescription(s); } -bool -Breakpoint::GetMatchingFileLine (const ConstString &filename, uint32_t line_number, BreakpointLocationCollection &loc_coll) -{ - // TODO: To be correct, this method needs to fill the breakpoint location collection - // with the location IDs which match the filename and line_number. - // +bool Breakpoint::EvaluatePrecondition(StoppointCallbackContext &context) { + if (!m_precondition_sp) + return true; - if (m_resolver_sp) - { - BreakpointResolverFileLine *resolverFileLine = dyn_cast<BreakpointResolverFileLine>(m_resolver_sp.get()); - if (resolverFileLine && - resolverFileLine->m_file_spec.GetFilename() == filename && - resolverFileLine->m_line_number == line_number) - { - return true; - } - } - return false; + return m_precondition_sp->EvaluatePrecondition(context); } -void -Breakpoint::GetFilterDescription (Stream *s) -{ - m_filter_sp->GetDescription (s); +bool Breakpoint::BreakpointPrecondition::EvaluatePrecondition( + StoppointCallbackContext &context) { + return true; } -bool -Breakpoint::EvaluatePrecondition (StoppointCallbackContext &context) -{ - if (!m_precondition_sp) - return true; +void Breakpoint::BreakpointPrecondition::GetDescription( + Stream &stream, lldb::DescriptionLevel level) {} - return m_precondition_sp->EvaluatePrecondition(context); +Error Breakpoint::BreakpointPrecondition::ConfigurePrecondition(Args &options) { + Error error; + error.SetErrorString("Base breakpoint precondition has no options."); + return error; } -bool -Breakpoint::BreakpointPrecondition::EvaluatePrecondition(StoppointCallbackContext &context) -{ - return true; -} +void Breakpoint::SendBreakpointChangedEvent( + lldb::BreakpointEventType eventKind) { + if (!m_being_created && !IsInternal() && + GetTarget().EventTypeHasListeners( + Target::eBroadcastBitBreakpointChanged)) { + BreakpointEventData *data = + new Breakpoint::BreakpointEventData(eventKind, shared_from_this()); -void -Breakpoint::BreakpointPrecondition::GetDescription(Stream &stream, lldb::DescriptionLevel level) -{ + GetTarget().BroadcastEvent(Target::eBroadcastBitBreakpointChanged, data); + } } -Error -Breakpoint::BreakpointPrecondition::ConfigurePrecondition(Args &options) -{ - Error error; - error.SetErrorString("Base breakpoint precondition has no options."); - return error; -} +void Breakpoint::SendBreakpointChangedEvent(BreakpointEventData *data) { + if (data == nullptr) + return; -void -Breakpoint::SendBreakpointChangedEvent (lldb::BreakpointEventType eventKind) -{ - if (!m_being_created - && !IsInternal() - && GetTarget().EventTypeHasListeners(Target::eBroadcastBitBreakpointChanged)) - { - BreakpointEventData *data = new Breakpoint::BreakpointEventData (eventKind, shared_from_this()); - - GetTarget().BroadcastEvent (Target::eBroadcastBitBreakpointChanged, data); - } + if (!m_being_created && !IsInternal() && + GetTarget().EventTypeHasListeners(Target::eBroadcastBitBreakpointChanged)) + GetTarget().BroadcastEvent(Target::eBroadcastBitBreakpointChanged, data); + else + delete data; } -void -Breakpoint::SendBreakpointChangedEvent (BreakpointEventData *data) -{ - if (data == nullptr) - return; - - if (!m_being_created - && !IsInternal() - && GetTarget().EventTypeHasListeners(Target::eBroadcastBitBreakpointChanged)) - GetTarget().BroadcastEvent (Target::eBroadcastBitBreakpointChanged, data); - else - delete data; -} - -Breakpoint::BreakpointEventData::BreakpointEventData (BreakpointEventType sub_type, - const BreakpointSP &new_breakpoint_sp) : - EventData (), - m_breakpoint_event (sub_type), - m_new_breakpoint_sp (new_breakpoint_sp) -{ -} +Breakpoint::BreakpointEventData::BreakpointEventData( + BreakpointEventType sub_type, const BreakpointSP &new_breakpoint_sp) + : EventData(), m_breakpoint_event(sub_type), + m_new_breakpoint_sp(new_breakpoint_sp) {} Breakpoint::BreakpointEventData::~BreakpointEventData() = default; -const ConstString & -Breakpoint::BreakpointEventData::GetFlavorString () -{ - static ConstString g_flavor ("Breakpoint::BreakpointEventData"); - return g_flavor; +const ConstString &Breakpoint::BreakpointEventData::GetFlavorString() { + static ConstString g_flavor("Breakpoint::BreakpointEventData"); + return g_flavor; } -const ConstString & -Breakpoint::BreakpointEventData::GetFlavor () const -{ - return BreakpointEventData::GetFlavorString (); +const ConstString &Breakpoint::BreakpointEventData::GetFlavor() const { + return BreakpointEventData::GetFlavorString(); } -BreakpointSP & -Breakpoint::BreakpointEventData::GetBreakpoint () -{ - return m_new_breakpoint_sp; +BreakpointSP &Breakpoint::BreakpointEventData::GetBreakpoint() { + return m_new_breakpoint_sp; } BreakpointEventType -Breakpoint::BreakpointEventData::GetBreakpointEventType () const -{ - return m_breakpoint_event; +Breakpoint::BreakpointEventData::GetBreakpointEventType() const { + return m_breakpoint_event; } -void -Breakpoint::BreakpointEventData::Dump (Stream *s) const -{ -} +void Breakpoint::BreakpointEventData::Dump(Stream *s) const {} const Breakpoint::BreakpointEventData * -Breakpoint::BreakpointEventData::GetEventDataFromEvent (const Event *event) -{ - if (event) - { - const EventData *event_data = event->GetData(); - if (event_data && event_data->GetFlavor() == BreakpointEventData::GetFlavorString()) - return static_cast <const BreakpointEventData *> (event->GetData()); - } - return nullptr; +Breakpoint::BreakpointEventData::GetEventDataFromEvent(const Event *event) { + if (event) { + const EventData *event_data = event->GetData(); + if (event_data && + event_data->GetFlavor() == BreakpointEventData::GetFlavorString()) + return static_cast<const BreakpointEventData *>(event->GetData()); + } + return nullptr; } BreakpointEventType -Breakpoint::BreakpointEventData::GetBreakpointEventTypeFromEvent (const EventSP &event_sp) -{ - const BreakpointEventData *data = GetEventDataFromEvent (event_sp.get()); +Breakpoint::BreakpointEventData::GetBreakpointEventTypeFromEvent( + const EventSP &event_sp) { + const BreakpointEventData *data = GetEventDataFromEvent(event_sp.get()); - if (data == nullptr) - return eBreakpointEventTypeInvalidType; - else - return data->GetBreakpointEventType(); + if (data == nullptr) + return eBreakpointEventTypeInvalidType; + else + return data->GetBreakpointEventType(); } -BreakpointSP -Breakpoint::BreakpointEventData::GetBreakpointFromEvent (const EventSP &event_sp) -{ - BreakpointSP bp_sp; +BreakpointSP Breakpoint::BreakpointEventData::GetBreakpointFromEvent( + const EventSP &event_sp) { + BreakpointSP bp_sp; - const BreakpointEventData *data = GetEventDataFromEvent (event_sp.get()); - if (data) - bp_sp = data->m_new_breakpoint_sp; + const BreakpointEventData *data = GetEventDataFromEvent(event_sp.get()); + if (data) + bp_sp = data->m_new_breakpoint_sp; - return bp_sp; + return bp_sp; } -size_t -Breakpoint::BreakpointEventData::GetNumBreakpointLocationsFromEvent (const EventSP &event_sp) -{ - const BreakpointEventData *data = GetEventDataFromEvent (event_sp.get()); - if (data) - return data->m_locations.GetSize(); +size_t Breakpoint::BreakpointEventData::GetNumBreakpointLocationsFromEvent( + const EventSP &event_sp) { + const BreakpointEventData *data = GetEventDataFromEvent(event_sp.get()); + if (data) + return data->m_locations.GetSize(); - return 0; + return 0; } lldb::BreakpointLocationSP -Breakpoint::BreakpointEventData::GetBreakpointLocationAtIndexFromEvent (const lldb::EventSP &event_sp, uint32_t bp_loc_idx) -{ - lldb::BreakpointLocationSP bp_loc_sp; - - const BreakpointEventData *data = GetEventDataFromEvent (event_sp.get()); - if (data) - { - bp_loc_sp = data->m_locations.GetByIndex(bp_loc_idx); - } +Breakpoint::BreakpointEventData::GetBreakpointLocationAtIndexFromEvent( + const lldb::EventSP &event_sp, uint32_t bp_loc_idx) { + lldb::BreakpointLocationSP bp_loc_sp; + + const BreakpointEventData *data = GetEventDataFromEvent(event_sp.get()); + if (data) { + bp_loc_sp = data->m_locations.GetByIndex(bp_loc_idx); + } - return bp_loc_sp; + return bp_loc_sp; } diff --git a/lldb/source/Breakpoint/BreakpointID.cpp b/lldb/source/Breakpoint/BreakpointID.cpp index 81a3dfe50d9..9ab7adf48c4 100644 --- a/lldb/source/Breakpoint/BreakpointID.cpp +++ b/lldb/source/Breakpoint/BreakpointID.cpp @@ -13,121 +13,108 @@ // C++ Includes // Other libraries and framework includes // Project includes -#include "lldb/Breakpoint/BreakpointID.h" #include "lldb/Breakpoint/Breakpoint.h" -#include "lldb/Core/Stream.h" +#include "lldb/Breakpoint/BreakpointID.h" #include "lldb/Core/Error.h" +#include "lldb/Core/Stream.h" using namespace lldb; using namespace lldb_private; -BreakpointID::BreakpointID (break_id_t bp_id, break_id_t loc_id) : - m_break_id (bp_id), - m_location_id (loc_id) -{ -} +BreakpointID::BreakpointID(break_id_t bp_id, break_id_t loc_id) + : m_break_id(bp_id), m_location_id(loc_id) {} BreakpointID::~BreakpointID() = default; -const char *BreakpointID::g_range_specifiers[] = { "-", "to", "To", "TO", nullptr }; +const char *BreakpointID::g_range_specifiers[] = {"-", "to", "To", "TO", + nullptr}; -// Tells whether or not STR is valid to use between two strings representing breakpoint IDs, to -// indicate a range of breakpoint IDs. This is broken out into a separate function so that we can +// Tells whether or not STR is valid to use between two strings representing +// breakpoint IDs, to +// indicate a range of breakpoint IDs. This is broken out into a separate +// function so that we can // easily change or add to the format for specifying ID ranges at a later date. -bool -BreakpointID::IsRangeIdentifier (const char *str) -{ - int specifier_count = 0; - for (int i = 0; g_range_specifiers[i] != nullptr; ++i) - ++specifier_count; - - for (int i = 0; i < specifier_count; ++i) - { - if (strcmp (g_range_specifiers[i], str) == 0) - return true; - } +bool BreakpointID::IsRangeIdentifier(const char *str) { + int specifier_count = 0; + for (int i = 0; g_range_specifiers[i] != nullptr; ++i) + ++specifier_count; + + for (int i = 0; i < specifier_count; ++i) { + if (strcmp(g_range_specifiers[i], str) == 0) + return true; + } return false; } -bool -BreakpointID::IsValidIDExpression (const char *str) -{ - break_id_t bp_id; - break_id_t loc_id; - BreakpointID::ParseCanonicalReference (str, &bp_id, &loc_id); +bool BreakpointID::IsValidIDExpression(const char *str) { + break_id_t bp_id; + break_id_t loc_id; + BreakpointID::ParseCanonicalReference(str, &bp_id, &loc_id); - return (bp_id != LLDB_INVALID_BREAK_ID); + return (bp_id != LLDB_INVALID_BREAK_ID); } -void -BreakpointID::GetDescription (Stream *s, lldb::DescriptionLevel level) -{ - if (level == eDescriptionLevelVerbose) - s->Printf("%p BreakpointID:", static_cast<void*>(this)); - - if (m_break_id == LLDB_INVALID_BREAK_ID) - s->PutCString ("<invalid>"); - else if (m_location_id == LLDB_INVALID_BREAK_ID) - s->Printf("%i", m_break_id); - else - s->Printf("%i.%i", m_break_id, m_location_id); +void BreakpointID::GetDescription(Stream *s, lldb::DescriptionLevel level) { + if (level == eDescriptionLevelVerbose) + s->Printf("%p BreakpointID:", static_cast<void *>(this)); + + if (m_break_id == LLDB_INVALID_BREAK_ID) + s->PutCString("<invalid>"); + else if (m_location_id == LLDB_INVALID_BREAK_ID) + s->Printf("%i", m_break_id); + else + s->Printf("%i.%i", m_break_id, m_location_id); } -void -BreakpointID::GetCanonicalReference (Stream *s, break_id_t bp_id, break_id_t loc_id) -{ - if (bp_id == LLDB_INVALID_BREAK_ID) - s->PutCString ("<invalid>"); - else if (loc_id == LLDB_INVALID_BREAK_ID) - s->Printf("%i", bp_id); - else - s->Printf("%i.%i", bp_id, loc_id); +void BreakpointID::GetCanonicalReference(Stream *s, break_id_t bp_id, + break_id_t loc_id) { + if (bp_id == LLDB_INVALID_BREAK_ID) + s->PutCString("<invalid>"); + else if (loc_id == LLDB_INVALID_BREAK_ID) + s->Printf("%i", bp_id); + else + s->Printf("%i.%i", bp_id, loc_id); } -bool -BreakpointID::ParseCanonicalReference (const char *input, break_id_t *break_id_ptr, break_id_t *break_loc_id_ptr) -{ - *break_id_ptr = LLDB_INVALID_BREAK_ID; - *break_loc_id_ptr = LLDB_INVALID_BREAK_ID; - - if (input == nullptr || *input == '\0') - return false; - - const char *format = "%i%n.%i%n"; - int chars_consumed_1 = 0; - int chars_consumed_2 = 0; - int n_items_parsed = ::sscanf (input, - format, - break_id_ptr, // %i parse the breakpoint ID - &chars_consumed_1, // %n gets the number of characters parsed so far - break_loc_id_ptr, // %i parse the breakpoint location ID - &chars_consumed_2); // %n gets the number of characters parsed so far - - if ((n_items_parsed == 1 && input[chars_consumed_1] == '\0') || - (n_items_parsed == 2 && input[chars_consumed_2] == '\0')) - return true; - - // Badly formatted canonical reference. - *break_id_ptr = LLDB_INVALID_BREAK_ID; - *break_loc_id_ptr = LLDB_INVALID_BREAK_ID; +bool BreakpointID::ParseCanonicalReference(const char *input, + break_id_t *break_id_ptr, + break_id_t *break_loc_id_ptr) { + *break_id_ptr = LLDB_INVALID_BREAK_ID; + *break_loc_id_ptr = LLDB_INVALID_BREAK_ID; + + if (input == nullptr || *input == '\0') return false; + + const char *format = "%i%n.%i%n"; + int chars_consumed_1 = 0; + int chars_consumed_2 = 0; + int n_items_parsed = ::sscanf( + input, format, + break_id_ptr, // %i parse the breakpoint ID + &chars_consumed_1, // %n gets the number of characters parsed so far + break_loc_id_ptr, // %i parse the breakpoint location ID + &chars_consumed_2); // %n gets the number of characters parsed so far + + if ((n_items_parsed == 1 && input[chars_consumed_1] == '\0') || + (n_items_parsed == 2 && input[chars_consumed_2] == '\0')) + return true; + + // Badly formatted canonical reference. + *break_id_ptr = LLDB_INVALID_BREAK_ID; + *break_loc_id_ptr = LLDB_INVALID_BREAK_ID; + return false; } -bool -BreakpointID::StringIsBreakpointName(const char *name, Error &error) -{ - error.Clear(); - - if (name && (name[0] >= 'A' && name[0] <= 'z')) - { - if (strcspn(name, ".- ") != strlen(name)) - { - error.SetErrorStringWithFormat("invalid breakpoint name: \"%s\"", name); - } - return true; +bool BreakpointID::StringIsBreakpointName(const char *name, Error &error) { + error.Clear(); + + if (name && (name[0] >= 'A' && name[0] <= 'z')) { + if (strcspn(name, ".- ") != strlen(name)) { + error.SetErrorStringWithFormat("invalid breakpoint name: \"%s\"", name); } - else - return false; + return true; + } else + return false; } diff --git a/lldb/source/Breakpoint/BreakpointIDList.cpp b/lldb/source/Breakpoint/BreakpointIDList.cpp index ebf0697c271..4871105def7 100644 --- a/lldb/source/Breakpoint/BreakpointIDList.cpp +++ b/lldb/source/Breakpoint/BreakpointIDList.cpp @@ -15,8 +15,8 @@ #include "lldb/Breakpoint/Breakpoint.h" #include "lldb/Breakpoint/BreakpointLocation.h" -#include "lldb/Interpreter/CommandReturnObject.h" #include "lldb/Interpreter/Args.h" +#include "lldb/Interpreter/CommandReturnObject.h" #include "lldb/Target/Target.h" using namespace lldb; @@ -26,412 +26,370 @@ using namespace lldb_private; // class BreakpointIDList //---------------------------------------------------------------------- -BreakpointIDList::BreakpointIDList () : -m_invalid_id (LLDB_INVALID_BREAK_ID, LLDB_INVALID_BREAK_ID) -{ -} +BreakpointIDList::BreakpointIDList() + : m_invalid_id(LLDB_INVALID_BREAK_ID, LLDB_INVALID_BREAK_ID) {} BreakpointIDList::~BreakpointIDList() = default; -size_t -BreakpointIDList::GetSize() -{ - return m_breakpoint_ids.size(); -} +size_t BreakpointIDList::GetSize() { return m_breakpoint_ids.size(); } -BreakpointID & -BreakpointIDList::GetBreakpointIDAtIndex(size_t index) -{ - return ((index < m_breakpoint_ids.size()) ? m_breakpoint_ids[index] : m_invalid_id); +BreakpointID &BreakpointIDList::GetBreakpointIDAtIndex(size_t index) { + return ((index < m_breakpoint_ids.size()) ? m_breakpoint_ids[index] + : m_invalid_id); } -bool -BreakpointIDList::RemoveBreakpointIDAtIndex (size_t index) -{ - if (index >= m_breakpoint_ids.size()) - return false; +bool BreakpointIDList::RemoveBreakpointIDAtIndex(size_t index) { + if (index >= m_breakpoint_ids.size()) + return false; - m_breakpoint_ids.erase (m_breakpoint_ids.begin() + index); - return true; + m_breakpoint_ids.erase(m_breakpoint_ids.begin() + index); + return true; } -void -BreakpointIDList::Clear() -{ - m_breakpoint_ids.clear (); -} +void BreakpointIDList::Clear() { m_breakpoint_ids.clear(); } -bool -BreakpointIDList::AddBreakpointID (BreakpointID bp_id) -{ - m_breakpoint_ids.push_back (bp_id); +bool BreakpointIDList::AddBreakpointID(BreakpointID bp_id) { + m_breakpoint_ids.push_back(bp_id); - return true; // We don't do any verification in this function, so always return true. + return true; // We don't do any verification in this function, so always + // return true. } -bool -BreakpointIDList::AddBreakpointID (const char *bp_id_str) -{ - BreakpointID temp_bp_id; - break_id_t bp_id; - break_id_t loc_id; +bool BreakpointIDList::AddBreakpointID(const char *bp_id_str) { + BreakpointID temp_bp_id; + break_id_t bp_id; + break_id_t loc_id; - bool success = BreakpointID::ParseCanonicalReference (bp_id_str, &bp_id, &loc_id); + bool success = + BreakpointID::ParseCanonicalReference(bp_id_str, &bp_id, &loc_id); - if (success) - { - temp_bp_id.SetID (bp_id, loc_id); - m_breakpoint_ids.push_back (temp_bp_id); - } + if (success) { + temp_bp_id.SetID(bp_id, loc_id); + m_breakpoint_ids.push_back(temp_bp_id); + } - return success; + return success; } -bool -BreakpointIDList::FindBreakpointID (BreakpointID &bp_id, size_t *position) -{ - for (size_t i = 0; i < m_breakpoint_ids.size(); ++i) - { - BreakpointID tmp_id = m_breakpoint_ids[i]; - if (tmp_id.GetBreakpointID() == bp_id.GetBreakpointID() - && tmp_id.GetLocationID() == bp_id.GetLocationID()) - { - *position = i; - return true; - } +bool BreakpointIDList::FindBreakpointID(BreakpointID &bp_id, size_t *position) { + for (size_t i = 0; i < m_breakpoint_ids.size(); ++i) { + BreakpointID tmp_id = m_breakpoint_ids[i]; + if (tmp_id.GetBreakpointID() == bp_id.GetBreakpointID() && + tmp_id.GetLocationID() == bp_id.GetLocationID()) { + *position = i; + return true; } + } + return false; +} + +bool BreakpointIDList::FindBreakpointID(const char *bp_id_str, + size_t *position) { + BreakpointID temp_bp_id; + break_id_t bp_id; + break_id_t loc_id; + + if (BreakpointID::ParseCanonicalReference(bp_id_str, &bp_id, &loc_id)) { + temp_bp_id.SetID(bp_id, loc_id); + return FindBreakpointID(temp_bp_id, position); + } else return false; } -bool -BreakpointIDList::FindBreakpointID (const char *bp_id_str, size_t *position) -{ - BreakpointID temp_bp_id; +void BreakpointIDList::InsertStringArray(const char **string_array, + size_t array_size, + CommandReturnObject &result) { + if (string_array == nullptr) + return; + + for (uint32_t i = 0; i < array_size; ++i) { break_id_t bp_id; break_id_t loc_id; - if (BreakpointID::ParseCanonicalReference (bp_id_str, &bp_id, &loc_id)) - { - temp_bp_id.SetID (bp_id, loc_id); - return FindBreakpointID (temp_bp_id, position); - } - else - return false; -} - -void -BreakpointIDList::InsertStringArray (const char **string_array, size_t array_size, CommandReturnObject &result) -{ - if (string_array == nullptr) + if (BreakpointID::ParseCanonicalReference(string_array[i], &bp_id, + &loc_id)) { + if (bp_id != LLDB_INVALID_BREAK_ID) { + BreakpointID temp_bp_id(bp_id, loc_id); + m_breakpoint_ids.push_back(temp_bp_id); + } else { + result.AppendErrorWithFormat("'%s' is not a valid breakpoint ID.\n", + string_array[i]); + result.SetStatus(eReturnStatusFailed); return; - - for (uint32_t i = 0; i < array_size; ++i) - { - break_id_t bp_id; - break_id_t loc_id; - - if (BreakpointID::ParseCanonicalReference (string_array[i], &bp_id, &loc_id)) - { - if (bp_id != LLDB_INVALID_BREAK_ID) - { - BreakpointID temp_bp_id(bp_id, loc_id); - m_breakpoint_ids.push_back (temp_bp_id); - } - else - { - result.AppendErrorWithFormat ("'%s' is not a valid breakpoint ID.\n", string_array[i]); - result.SetStatus (eReturnStatusFailed); - return; - } - } + } } - result.SetStatus (eReturnStatusSuccessFinishNoResult); + } + result.SetStatus(eReturnStatusSuccessFinishNoResult); } +// This function takes OLD_ARGS, which is usually the result of breaking the +// command string arguments into +// an array of space-separated strings, and searches through the arguments for +// any breakpoint ID range specifiers. +// Any string in the array that is not part of an ID range specifier is copied +// directly into NEW_ARGS. If any +// ID range specifiers are found, the range is interpreted and a list of +// canonical breakpoint IDs corresponding to +// all the current breakpoints and locations in the range are added to +// NEW_ARGS. When this function is done, +// NEW_ARGS should be a copy of OLD_ARGS, with and ID range specifiers replaced +// by the members of the range. + +void BreakpointIDList::FindAndReplaceIDRanges(Args &old_args, Target *target, + bool allow_locations, + CommandReturnObject &result, + Args &new_args) { + std::string range_start; + const char *range_end; + const char *current_arg; + const size_t num_old_args = old_args.GetArgumentCount(); + std::set<std::string> names_found; + + for (size_t i = 0; i < num_old_args; ++i) { + bool is_range = false; + + current_arg = old_args.GetArgumentAtIndex(i); + if (!allow_locations && strchr(current_arg, '.') != nullptr) { + result.AppendErrorWithFormat( + "Breakpoint locations not allowed, saw location: %s.", current_arg); + new_args.Clear(); + return; + } -// This function takes OLD_ARGS, which is usually the result of breaking the command string arguments into -// an array of space-separated strings, and searches through the arguments for any breakpoint ID range specifiers. -// Any string in the array that is not part of an ID range specifier is copied directly into NEW_ARGS. If any -// ID range specifiers are found, the range is interpreted and a list of canonical breakpoint IDs corresponding to -// all the current breakpoints and locations in the range are added to NEW_ARGS. When this function is done, -// NEW_ARGS should be a copy of OLD_ARGS, with and ID range specifiers replaced by the members of the range. - -void -BreakpointIDList::FindAndReplaceIDRanges (Args &old_args, - Target *target, - bool allow_locations, - CommandReturnObject &result, - Args &new_args) -{ - std::string range_start; - const char *range_end; - const char *current_arg; - const size_t num_old_args = old_args.GetArgumentCount(); - std::set<std::string> names_found; - - for (size_t i = 0; i < num_old_args; ++i) - { - bool is_range = false; - - current_arg = old_args.GetArgumentAtIndex (i); - if (!allow_locations && strchr(current_arg, '.') != nullptr) - { - result.AppendErrorWithFormat ("Breakpoint locations not allowed, saw location: %s.", current_arg); + size_t range_start_len = 0; + size_t range_end_pos = 0; + Error error; + + if (BreakpointIDList::StringContainsIDRangeExpression( + current_arg, &range_start_len, &range_end_pos)) { + is_range = true; + range_start.assign(current_arg, range_start_len); + range_end = current_arg + range_end_pos; + } else if (BreakpointID::StringIsBreakpointName(current_arg, error)) { + if (!error.Success()) { + new_args.Clear(); + result.AppendError(error.AsCString()); + result.SetStatus(eReturnStatusFailed); + return; + } else + names_found.insert(current_arg); + } else if ((i + 2 < num_old_args) && + BreakpointID::IsRangeIdentifier( + old_args.GetArgumentAtIndex(i + 1)) && + BreakpointID::IsValidIDExpression(current_arg) && + BreakpointID::IsValidIDExpression( + old_args.GetArgumentAtIndex(i + 2))) { + range_start.assign(current_arg); + range_end = old_args.GetArgumentAtIndex(i + 2); + is_range = true; + i = i + 2; + } else { + // See if user has specified id.* + std::string tmp_str = old_args.GetArgumentAtIndex(i); + size_t pos = tmp_str.find('.'); + if (pos != std::string::npos) { + std::string bp_id_str = tmp_str.substr(0, pos); + if (BreakpointID::IsValidIDExpression(bp_id_str.c_str()) && + tmp_str[pos + 1] == '*' && tmp_str.length() == (pos + 2)) { + break_id_t bp_id; + break_id_t bp_loc_id; + + BreakpointID::ParseCanonicalReference(bp_id_str.c_str(), &bp_id, + &bp_loc_id); + BreakpointSP breakpoint_sp = target->GetBreakpointByID(bp_id); + if (!breakpoint_sp) { new_args.Clear(); + result.AppendErrorWithFormat("'%d' is not a valid breakpoint ID.\n", + bp_id); + result.SetStatus(eReturnStatusFailed); return; + } + const size_t num_locations = breakpoint_sp->GetNumLocations(); + for (size_t j = 0; j < num_locations; ++j) { + BreakpointLocation *bp_loc = + breakpoint_sp->GetLocationAtIndex(j).get(); + StreamString canonical_id_str; + BreakpointID::GetCanonicalReference(&canonical_id_str, bp_id, + bp_loc->GetID()); + new_args.AppendArgument(canonical_id_str.GetData()); + } } + } + } - size_t range_start_len = 0; - size_t range_end_pos = 0; - Error error; - - if (BreakpointIDList::StringContainsIDRangeExpression (current_arg, &range_start_len, &range_end_pos)) - { - is_range = true; - range_start.assign (current_arg, range_start_len); - range_end = current_arg + range_end_pos; - } - else if (BreakpointID::StringIsBreakpointName(current_arg, error)) - { - if (!error.Success()) - { - new_args.Clear(); - result.AppendError (error.AsCString()); - result.SetStatus (eReturnStatusFailed); - return; - } - else - names_found.insert(current_arg); - } - else if ((i + 2 < num_old_args) - && BreakpointID::IsRangeIdentifier (old_args.GetArgumentAtIndex (i+1)) - && BreakpointID::IsValidIDExpression (current_arg) - && BreakpointID::IsValidIDExpression (old_args.GetArgumentAtIndex (i+2))) - { - range_start.assign (current_arg); - range_end = old_args.GetArgumentAtIndex (i+2); - is_range = true; - i = i+2; - } - else - { - // See if user has specified id.* - std::string tmp_str = old_args.GetArgumentAtIndex (i); - size_t pos = tmp_str.find ('.'); - if (pos != std::string::npos) - { - std::string bp_id_str = tmp_str.substr (0, pos); - if (BreakpointID::IsValidIDExpression (bp_id_str.c_str()) - && tmp_str[pos+1] == '*' - && tmp_str.length() == (pos + 2)) - { - break_id_t bp_id; - break_id_t bp_loc_id; - - BreakpointID::ParseCanonicalReference (bp_id_str.c_str(), &bp_id, &bp_loc_id); - BreakpointSP breakpoint_sp = target->GetBreakpointByID (bp_id); - if (! breakpoint_sp) - { - new_args.Clear(); - result.AppendErrorWithFormat ("'%d' is not a valid breakpoint ID.\n", bp_id); - result.SetStatus (eReturnStatusFailed); - return; - } - const size_t num_locations = breakpoint_sp->GetNumLocations(); - for (size_t j = 0; j < num_locations; ++j) - { - BreakpointLocation *bp_loc = breakpoint_sp->GetLocationAtIndex(j).get(); - StreamString canonical_id_str; - BreakpointID::GetCanonicalReference (&canonical_id_str, bp_id, bp_loc->GetID()); - new_args.AppendArgument (canonical_id_str.GetData()); - } - } - - } + if (is_range) { + break_id_t start_bp_id; + break_id_t end_bp_id; + break_id_t start_loc_id; + break_id_t end_loc_id; + + BreakpointID::ParseCanonicalReference(range_start.c_str(), &start_bp_id, + &start_loc_id); + BreakpointID::ParseCanonicalReference(range_end, &end_bp_id, &end_loc_id); + + if ((start_bp_id == LLDB_INVALID_BREAK_ID) || + (!target->GetBreakpointByID(start_bp_id))) { + new_args.Clear(); + result.AppendErrorWithFormat("'%s' is not a valid breakpoint ID.\n", + range_start.c_str()); + result.SetStatus(eReturnStatusFailed); + return; + } + + if ((end_bp_id == LLDB_INVALID_BREAK_ID) || + (!target->GetBreakpointByID(end_bp_id))) { + new_args.Clear(); + result.AppendErrorWithFormat("'%s' is not a valid breakpoint ID.\n", + range_end); + result.SetStatus(eReturnStatusFailed); + return; + } + + if (((start_loc_id == LLDB_INVALID_BREAK_ID) && + (end_loc_id != LLDB_INVALID_BREAK_ID)) || + ((start_loc_id != LLDB_INVALID_BREAK_ID) && + (end_loc_id == LLDB_INVALID_BREAK_ID))) { + new_args.Clear(); + result.AppendErrorWithFormat("Invalid breakpoint id range: Either " + "both ends of range must specify" + " a breakpoint location, or neither can " + "specify a breakpoint location.\n"); + result.SetStatus(eReturnStatusFailed); + return; + } + + // We have valid range starting & ending breakpoint IDs. Go through all + // the breakpoints in the + // target and find all the breakpoints that fit into this range, and add + // them to new_args. + + // Next check to see if we have location id's. If so, make sure the + // start_bp_id and end_bp_id are + // for the same breakpoint; otherwise we have an illegal range: breakpoint + // id ranges that specify + // bp locations are NOT allowed to cross major bp id numbers. + + if ((start_loc_id != LLDB_INVALID_BREAK_ID) || + (end_loc_id != LLDB_INVALID_BREAK_ID)) { + if (start_bp_id != end_bp_id) { + new_args.Clear(); + result.AppendErrorWithFormat( + "Invalid range: Ranges that specify particular breakpoint " + "locations" + " must be within the same major breakpoint; you specified two" + " different major breakpoints, %d and %d.\n", + start_bp_id, end_bp_id); + result.SetStatus(eReturnStatusFailed); + return; } - - if (is_range) - { - break_id_t start_bp_id; - break_id_t end_bp_id; - break_id_t start_loc_id; - break_id_t end_loc_id; - - BreakpointID::ParseCanonicalReference (range_start.c_str(), &start_bp_id, &start_loc_id); - BreakpointID::ParseCanonicalReference (range_end, &end_bp_id, &end_loc_id); - - if ((start_bp_id == LLDB_INVALID_BREAK_ID) - || (! target->GetBreakpointByID (start_bp_id))) - { - new_args.Clear(); - result.AppendErrorWithFormat ("'%s' is not a valid breakpoint ID.\n", range_start.c_str()); - result.SetStatus (eReturnStatusFailed); - return; - } - - if ((end_bp_id == LLDB_INVALID_BREAK_ID) - || (! target->GetBreakpointByID (end_bp_id))) - { - new_args.Clear(); - result.AppendErrorWithFormat ("'%s' is not a valid breakpoint ID.\n", range_end); - result.SetStatus (eReturnStatusFailed); - return; - } - - - if (((start_loc_id == LLDB_INVALID_BREAK_ID) - && (end_loc_id != LLDB_INVALID_BREAK_ID)) - || ((start_loc_id != LLDB_INVALID_BREAK_ID) - && (end_loc_id == LLDB_INVALID_BREAK_ID))) - { - new_args.Clear (); - result.AppendErrorWithFormat ("Invalid breakpoint id range: Either both ends of range must specify" - " a breakpoint location, or neither can specify a breakpoint location.\n"); - result.SetStatus (eReturnStatusFailed); - return; + } + + const BreakpointList &breakpoints = target->GetBreakpointList(); + const size_t num_breakpoints = breakpoints.GetSize(); + for (size_t j = 0; j < num_breakpoints; ++j) { + Breakpoint *breakpoint = breakpoints.GetBreakpointAtIndex(j).get(); + break_id_t cur_bp_id = breakpoint->GetID(); + + if ((cur_bp_id < start_bp_id) || (cur_bp_id > end_bp_id)) + continue; + + const size_t num_locations = breakpoint->GetNumLocations(); + + if ((cur_bp_id == start_bp_id) && + (start_loc_id != LLDB_INVALID_BREAK_ID)) { + for (size_t k = 0; k < num_locations; ++k) { + BreakpointLocation *bp_loc = + breakpoint->GetLocationAtIndex(k).get(); + if ((bp_loc->GetID() >= start_loc_id) && + (bp_loc->GetID() <= end_loc_id)) { + StreamString canonical_id_str; + BreakpointID::GetCanonicalReference(&canonical_id_str, cur_bp_id, + bp_loc->GetID()); + new_args.AppendArgument(canonical_id_str.GetData()); } - - // We have valid range starting & ending breakpoint IDs. Go through all the breakpoints in the - // target and find all the breakpoints that fit into this range, and add them to new_args. - - // Next check to see if we have location id's. If so, make sure the start_bp_id and end_bp_id are - // for the same breakpoint; otherwise we have an illegal range: breakpoint id ranges that specify - // bp locations are NOT allowed to cross major bp id numbers. - - if ((start_loc_id != LLDB_INVALID_BREAK_ID) - || (end_loc_id != LLDB_INVALID_BREAK_ID)) - { - if (start_bp_id != end_bp_id) - { - new_args.Clear(); - result.AppendErrorWithFormat ("Invalid range: Ranges that specify particular breakpoint locations" - " must be within the same major breakpoint; you specified two" - " different major breakpoints, %d and %d.\n", - start_bp_id, end_bp_id); - result.SetStatus (eReturnStatusFailed); - return; - } - } - - const BreakpointList& breakpoints = target->GetBreakpointList(); - const size_t num_breakpoints = breakpoints.GetSize(); - for (size_t j = 0; j < num_breakpoints; ++j) - { - Breakpoint *breakpoint = breakpoints.GetBreakpointAtIndex (j).get(); - break_id_t cur_bp_id = breakpoint->GetID(); - - if ((cur_bp_id < start_bp_id) || (cur_bp_id > end_bp_id)) - continue; - - const size_t num_locations = breakpoint->GetNumLocations(); - - if ((cur_bp_id == start_bp_id) && (start_loc_id != LLDB_INVALID_BREAK_ID)) - { - for (size_t k = 0; k < num_locations; ++k) - { - BreakpointLocation * bp_loc = breakpoint->GetLocationAtIndex(k).get(); - if ((bp_loc->GetID() >= start_loc_id) && (bp_loc->GetID() <= end_loc_id)) - { - StreamString canonical_id_str; - BreakpointID::GetCanonicalReference (&canonical_id_str, cur_bp_id, bp_loc->GetID()); - new_args.AppendArgument (canonical_id_str.GetData()); - } - } - } - else if ((cur_bp_id == end_bp_id) && (end_loc_id != LLDB_INVALID_BREAK_ID)) - { - for (size_t k = 0; k < num_locations; ++k) - { - BreakpointLocation * bp_loc = breakpoint->GetLocationAtIndex(k).get(); - if (bp_loc->GetID() <= end_loc_id) - { - StreamString canonical_id_str; - BreakpointID::GetCanonicalReference (&canonical_id_str, cur_bp_id, bp_loc->GetID()); - new_args.AppendArgument (canonical_id_str.GetData()); - } - } - } - else - { - StreamString canonical_id_str; - BreakpointID::GetCanonicalReference (&canonical_id_str, cur_bp_id, LLDB_INVALID_BREAK_ID); - new_args.AppendArgument (canonical_id_str.GetData()); - } + } + } else if ((cur_bp_id == end_bp_id) && + (end_loc_id != LLDB_INVALID_BREAK_ID)) { + for (size_t k = 0; k < num_locations; ++k) { + BreakpointLocation *bp_loc = + breakpoint->GetLocationAtIndex(k).get(); + if (bp_loc->GetID() <= end_loc_id) { + StreamString canonical_id_str; + BreakpointID::GetCanonicalReference(&canonical_id_str, cur_bp_id, + bp_loc->GetID()); + new_args.AppendArgument(canonical_id_str.GetData()); } + } + } else { + StreamString canonical_id_str; + BreakpointID::GetCanonicalReference(&canonical_id_str, cur_bp_id, + LLDB_INVALID_BREAK_ID); + new_args.AppendArgument(canonical_id_str.GetData()); } - else // else is_range was false - { - new_args.AppendArgument (current_arg); - } - } - - // Okay, now see if we found any names, and if we did, add them: - if (target && names_found.size()) + } + } else // else is_range was false { - for (BreakpointSP bkpt_sp : target->GetBreakpointList().Breakpoints()) - { - for (std::string name : names_found) - { - if (bkpt_sp->MatchesName(name.c_str())) - { - StreamString canonical_id_str; - BreakpointID::GetCanonicalReference (&canonical_id_str, bkpt_sp->GetID(), LLDB_INVALID_BREAK_ID); - new_args.AppendArgument (canonical_id_str.GetData()); - } - } + new_args.AppendArgument(current_arg); + } + } + + // Okay, now see if we found any names, and if we did, add them: + if (target && names_found.size()) { + for (BreakpointSP bkpt_sp : target->GetBreakpointList().Breakpoints()) { + for (std::string name : names_found) { + if (bkpt_sp->MatchesName(name.c_str())) { + StreamString canonical_id_str; + BreakpointID::GetCanonicalReference( + &canonical_id_str, bkpt_sp->GetID(), LLDB_INVALID_BREAK_ID); + new_args.AppendArgument(canonical_id_str.GetData()); } + } } + } - result.SetStatus (eReturnStatusSuccessFinishNoResult); + result.SetStatus(eReturnStatusSuccessFinishNoResult); } -bool -BreakpointIDList::StringContainsIDRangeExpression (const char *in_string, - size_t *range_start_len, - size_t *range_end_pos) -{ - bool is_range_expression = false; - std::string arg_str = in_string; - std::string::size_type idx; - std::string::size_type start_pos = 0; - - *range_start_len = 0; - *range_end_pos = 0; - - int specifiers_size = 0; - for (int i = 0; BreakpointID::g_range_specifiers[i] != nullptr; ++i) - ++specifiers_size; - - for (int i = 0; i < specifiers_size && !is_range_expression; ++i) - { - const char *specifier_str = BreakpointID::g_range_specifiers[i]; - size_t len = strlen (specifier_str); - idx = arg_str.find (BreakpointID::g_range_specifiers[i]); - if (idx != std::string::npos) - { - *range_start_len = idx - start_pos; - std::string start_str = arg_str.substr (start_pos, *range_start_len); - if (idx + len < arg_str.length()) - { - *range_end_pos = idx + len; - std::string end_str = arg_str.substr (*range_end_pos); - if (BreakpointID::IsValidIDExpression (start_str.c_str()) - && BreakpointID::IsValidIDExpression (end_str.c_str())) - { - is_range_expression = true; - //*range_start = start_str; - //*range_end = end_str; - } - } +bool BreakpointIDList::StringContainsIDRangeExpression(const char *in_string, + size_t *range_start_len, + size_t *range_end_pos) { + bool is_range_expression = false; + std::string arg_str = in_string; + std::string::size_type idx; + std::string::size_type start_pos = 0; + + *range_start_len = 0; + *range_end_pos = 0; + + int specifiers_size = 0; + for (int i = 0; BreakpointID::g_range_specifiers[i] != nullptr; ++i) + ++specifiers_size; + + for (int i = 0; i < specifiers_size && !is_range_expression; ++i) { + const char *specifier_str = BreakpointID::g_range_specifiers[i]; + size_t len = strlen(specifier_str); + idx = arg_str.find(BreakpointID::g_range_specifiers[i]); + if (idx != std::string::npos) { + *range_start_len = idx - start_pos; + std::string start_str = arg_str.substr(start_pos, *range_start_len); + if (idx + len < arg_str.length()) { + *range_end_pos = idx + len; + std::string end_str = arg_str.substr(*range_end_pos); + if (BreakpointID::IsValidIDExpression(start_str.c_str()) && + BreakpointID::IsValidIDExpression(end_str.c_str())) { + is_range_expression = true; + //*range_start = start_str; + //*range_end = end_str; } + } } + } - if (!is_range_expression) - { - *range_start_len = 0; - *range_end_pos = 0; - } + if (!is_range_expression) { + *range_start_len = 0; + *range_end_pos = 0; + } - return is_range_expression; + return is_range_expression; } diff --git a/lldb/source/Breakpoint/BreakpointList.cpp b/lldb/source/Breakpoint/BreakpointList.cpp index 9877c2d1246..a47a07d92e5 100644 --- a/lldb/source/Breakpoint/BreakpointList.cpp +++ b/lldb/source/Breakpoint/BreakpointList.cpp @@ -19,222 +19,183 @@ using namespace lldb; using namespace lldb_private; BreakpointList::BreakpointList(bool is_internal) - : m_mutex(), m_breakpoints(), m_next_break_id(0), m_is_internal(is_internal) -{ -} - -BreakpointList::~BreakpointList() -{ -} - - -break_id_t -BreakpointList::Add (BreakpointSP &bp_sp, bool notify) -{ - std::lock_guard<std::recursive_mutex> guard(m_mutex); - // Internal breakpoint IDs are negative, normal ones are positive - bp_sp->SetID (m_is_internal ? --m_next_break_id : ++m_next_break_id); - - m_breakpoints.push_back(bp_sp); - if (notify) - { - if (bp_sp->GetTarget().EventTypeHasListeners(Target::eBroadcastBitBreakpointChanged)) - bp_sp->GetTarget().BroadcastEvent (Target::eBroadcastBitBreakpointChanged, - new Breakpoint::BreakpointEventData (eBreakpointEventTypeAdded, bp_sp)); - } - return bp_sp->GetID(); -} - -bool -BreakpointList::Remove (break_id_t break_id, bool notify) -{ - std::lock_guard<std::recursive_mutex> guard(m_mutex); - bp_collection::iterator pos = GetBreakpointIDIterator(break_id); // Predicate - if (pos != m_breakpoints.end()) - { - BreakpointSP bp_sp (*pos); - m_breakpoints.erase(pos); - if (notify) - { - if (bp_sp->GetTarget().EventTypeHasListeners(Target::eBroadcastBitBreakpointChanged)) - bp_sp->GetTarget().BroadcastEvent (Target::eBroadcastBitBreakpointChanged, - new Breakpoint::BreakpointEventData (eBreakpointEventTypeRemoved, bp_sp)); - } - return true; + : m_mutex(), m_breakpoints(), m_next_break_id(0), + m_is_internal(is_internal) {} + +BreakpointList::~BreakpointList() {} + +break_id_t BreakpointList::Add(BreakpointSP &bp_sp, bool notify) { + std::lock_guard<std::recursive_mutex> guard(m_mutex); + // Internal breakpoint IDs are negative, normal ones are positive + bp_sp->SetID(m_is_internal ? --m_next_break_id : ++m_next_break_id); + + m_breakpoints.push_back(bp_sp); + if (notify) { + if (bp_sp->GetTarget().EventTypeHasListeners( + Target::eBroadcastBitBreakpointChanged)) + bp_sp->GetTarget().BroadcastEvent(Target::eBroadcastBitBreakpointChanged, + new Breakpoint::BreakpointEventData( + eBreakpointEventTypeAdded, bp_sp)); + } + return bp_sp->GetID(); +} + +bool BreakpointList::Remove(break_id_t break_id, bool notify) { + std::lock_guard<std::recursive_mutex> guard(m_mutex); + bp_collection::iterator pos = GetBreakpointIDIterator(break_id); // Predicate + if (pos != m_breakpoints.end()) { + BreakpointSP bp_sp(*pos); + m_breakpoints.erase(pos); + if (notify) { + if (bp_sp->GetTarget().EventTypeHasListeners( + Target::eBroadcastBitBreakpointChanged)) + bp_sp->GetTarget().BroadcastEvent( + Target::eBroadcastBitBreakpointChanged, + new Breakpoint::BreakpointEventData(eBreakpointEventTypeRemoved, + bp_sp)); } - return false; + return true; + } + return false; } -void -BreakpointList::RemoveInvalidLocations (const ArchSpec &arch) -{ - std::lock_guard<std::recursive_mutex> guard(m_mutex); - for (const auto &bp_sp : m_breakpoints) - bp_sp->RemoveInvalidLocations(arch); +void BreakpointList::RemoveInvalidLocations(const ArchSpec &arch) { + std::lock_guard<std::recursive_mutex> guard(m_mutex); + for (const auto &bp_sp : m_breakpoints) + bp_sp->RemoveInvalidLocations(arch); } - -void -BreakpointList::SetEnabledAll (bool enabled) -{ - std::lock_guard<std::recursive_mutex> guard(m_mutex); - for (const auto &bp_sp : m_breakpoints) - bp_sp->SetEnabled (enabled); +void BreakpointList::SetEnabledAll(bool enabled) { + std::lock_guard<std::recursive_mutex> guard(m_mutex); + for (const auto &bp_sp : m_breakpoints) + bp_sp->SetEnabled(enabled); } +void BreakpointList::RemoveAll(bool notify) { + std::lock_guard<std::recursive_mutex> guard(m_mutex); + ClearAllBreakpointSites(); -void -BreakpointList::RemoveAll (bool notify) -{ - std::lock_guard<std::recursive_mutex> guard(m_mutex); - ClearAllBreakpointSites (); - - if (notify) - { - bp_collection::iterator pos, end = m_breakpoints.end(); - for (pos = m_breakpoints.begin(); pos != end; ++pos) - { - if ((*pos)->GetTarget().EventTypeHasListeners(Target::eBroadcastBitBreakpointChanged)) - { - (*pos)->GetTarget().BroadcastEvent (Target::eBroadcastBitBreakpointChanged, - new Breakpoint::BreakpointEventData (eBreakpointEventTypeRemoved, - *pos)); - } - } + if (notify) { + bp_collection::iterator pos, end = m_breakpoints.end(); + for (pos = m_breakpoints.begin(); pos != end; ++pos) { + if ((*pos)->GetTarget().EventTypeHasListeners( + Target::eBroadcastBitBreakpointChanged)) { + (*pos)->GetTarget().BroadcastEvent( + Target::eBroadcastBitBreakpointChanged, + new Breakpoint::BreakpointEventData(eBreakpointEventTypeRemoved, + *pos)); + } } - m_breakpoints.erase (m_breakpoints.begin(), m_breakpoints.end()); + } + m_breakpoints.erase(m_breakpoints.begin(), m_breakpoints.end()); } -class BreakpointIDMatches -{ +class BreakpointIDMatches { public: - BreakpointIDMatches (break_id_t break_id) : - m_break_id(break_id) - { - } + BreakpointIDMatches(break_id_t break_id) : m_break_id(break_id) {} - bool operator() (const BreakpointSP &bp) const - { - return m_break_id == bp->GetID(); - } + bool operator()(const BreakpointSP &bp) const { + return m_break_id == bp->GetID(); + } private: - const break_id_t m_break_id; + const break_id_t m_break_id; }; BreakpointList::bp_collection::iterator -BreakpointList::GetBreakpointIDIterator (break_id_t break_id) -{ - return std::find_if(m_breakpoints.begin(), m_breakpoints.end(), // Search full range - BreakpointIDMatches(break_id)); // Predicate +BreakpointList::GetBreakpointIDIterator(break_id_t break_id) { + return std::find_if(m_breakpoints.begin(), + m_breakpoints.end(), // Search full range + BreakpointIDMatches(break_id)); // Predicate } BreakpointList::bp_collection::const_iterator -BreakpointList::GetBreakpointIDConstIterator (break_id_t break_id) const -{ - return std::find_if(m_breakpoints.begin(), m_breakpoints.end(), // Search full range - BreakpointIDMatches(break_id)); // Predicate +BreakpointList::GetBreakpointIDConstIterator(break_id_t break_id) const { + return std::find_if(m_breakpoints.begin(), + m_breakpoints.end(), // Search full range + BreakpointIDMatches(break_id)); // Predicate } -BreakpointSP -BreakpointList::FindBreakpointByID (break_id_t break_id) -{ - std::lock_guard<std::recursive_mutex> guard(m_mutex); - BreakpointSP stop_sp; - bp_collection::iterator pos = GetBreakpointIDIterator(break_id); - if (pos != m_breakpoints.end()) - stop_sp = *pos; +BreakpointSP BreakpointList::FindBreakpointByID(break_id_t break_id) { + std::lock_guard<std::recursive_mutex> guard(m_mutex); + BreakpointSP stop_sp; + bp_collection::iterator pos = GetBreakpointIDIterator(break_id); + if (pos != m_breakpoints.end()) + stop_sp = *pos; - return stop_sp; -} - -const BreakpointSP -BreakpointList::FindBreakpointByID (break_id_t break_id) const -{ - std::lock_guard<std::recursive_mutex> guard(m_mutex); - BreakpointSP stop_sp; - bp_collection::const_iterator pos = GetBreakpointIDConstIterator(break_id); - if (pos != m_breakpoints.end()) - stop_sp = *pos; - - return stop_sp; -} - -void -BreakpointList::Dump (Stream *s) const -{ - std::lock_guard<std::recursive_mutex> guard(m_mutex); - s->Printf("%p: ", static_cast<const void*>(this)); - s->Indent(); - s->Printf("BreakpointList with %u Breakpoints:\n", (uint32_t)m_breakpoints.size()); - s->IndentMore(); - for (const auto &bp_sp : m_breakpoints) - bp_sp->Dump(s); - s->IndentLess(); -} - - -BreakpointSP -BreakpointList::GetBreakpointAtIndex (size_t i) -{ - std::lock_guard<std::recursive_mutex> guard(m_mutex); - BreakpointSP stop_sp; - bp_collection::iterator end = m_breakpoints.end(); - bp_collection::iterator pos; - size_t curr_i = 0; - for (pos = m_breakpoints.begin(), curr_i = 0; pos != end; ++pos, ++curr_i) - { - if (curr_i == i) - stop_sp = *pos; - } - return stop_sp; + return stop_sp; } const BreakpointSP -BreakpointList::GetBreakpointAtIndex (size_t i) const -{ - std::lock_guard<std::recursive_mutex> guard(m_mutex); - BreakpointSP stop_sp; - bp_collection::const_iterator end = m_breakpoints.end(); - bp_collection::const_iterator pos; - size_t curr_i = 0; - for (pos = m_breakpoints.begin(), curr_i = 0; pos != end; ++pos, ++curr_i) - { - if (curr_i == i) - stop_sp = *pos; - } - return stop_sp; -} - -void -BreakpointList::UpdateBreakpoints (ModuleList& module_list, bool added, bool delete_locations) -{ - std::lock_guard<std::recursive_mutex> guard(m_mutex); - for (const auto &bp_sp : m_breakpoints) - bp_sp->ModulesChanged (module_list, added, delete_locations); - -} - -void -BreakpointList::UpdateBreakpointsWhenModuleIsReplaced (ModuleSP old_module_sp, ModuleSP new_module_sp) -{ - std::lock_guard<std::recursive_mutex> guard(m_mutex); - for (const auto &bp_sp : m_breakpoints) - bp_sp->ModuleReplaced (old_module_sp, new_module_sp); - -} - -void -BreakpointList::ClearAllBreakpointSites () -{ - std::lock_guard<std::recursive_mutex> guard(m_mutex); - for (const auto &bp_sp : m_breakpoints) - bp_sp->ClearAllBreakpointSites (); - -} - -void -BreakpointList::GetListMutex(std::unique_lock<std::recursive_mutex> &lock) -{ - lock = std::unique_lock<std::recursive_mutex>(m_mutex); +BreakpointList::FindBreakpointByID(break_id_t break_id) const { + std::lock_guard<std::recursive_mutex> guard(m_mutex); + BreakpointSP stop_sp; + bp_collection::const_iterator pos = GetBreakpointIDConstIterator(break_id); + if (pos != m_breakpoints.end()) + stop_sp = *pos; + + return stop_sp; +} + +void BreakpointList::Dump(Stream *s) const { + std::lock_guard<std::recursive_mutex> guard(m_mutex); + s->Printf("%p: ", static_cast<const void *>(this)); + s->Indent(); + s->Printf("BreakpointList with %u Breakpoints:\n", + (uint32_t)m_breakpoints.size()); + s->IndentMore(); + for (const auto &bp_sp : m_breakpoints) + bp_sp->Dump(s); + s->IndentLess(); +} + +BreakpointSP BreakpointList::GetBreakpointAtIndex(size_t i) { + std::lock_guard<std::recursive_mutex> guard(m_mutex); + BreakpointSP stop_sp; + bp_collection::iterator end = m_breakpoints.end(); + bp_collection::iterator pos; + size_t curr_i = 0; + for (pos = m_breakpoints.begin(), curr_i = 0; pos != end; ++pos, ++curr_i) { + if (curr_i == i) + stop_sp = *pos; + } + return stop_sp; +} + +const BreakpointSP BreakpointList::GetBreakpointAtIndex(size_t i) const { + std::lock_guard<std::recursive_mutex> guard(m_mutex); + BreakpointSP stop_sp; + bp_collection::const_iterator end = m_breakpoints.end(); + bp_collection::const_iterator pos; + size_t curr_i = 0; + for (pos = m_breakpoints.begin(), curr_i = 0; pos != end; ++pos, ++curr_i) { + if (curr_i == i) + stop_sp = *pos; + } + return stop_sp; +} + +void BreakpointList::UpdateBreakpoints(ModuleList &module_list, bool added, + bool delete_locations) { + std::lock_guard<std::recursive_mutex> guard(m_mutex); + for (const auto &bp_sp : m_breakpoints) + bp_sp->ModulesChanged(module_list, added, delete_locations); +} + +void BreakpointList::UpdateBreakpointsWhenModuleIsReplaced( + ModuleSP old_module_sp, ModuleSP new_module_sp) { + std::lock_guard<std::recursive_mutex> guard(m_mutex); + for (const auto &bp_sp : m_breakpoints) + bp_sp->ModuleReplaced(old_module_sp, new_module_sp); +} + +void BreakpointList::ClearAllBreakpointSites() { + std::lock_guard<std::recursive_mutex> guard(m_mutex); + for (const auto &bp_sp : m_breakpoints) + bp_sp->ClearAllBreakpointSites(); +} + +void BreakpointList::GetListMutex( + std::unique_lock<std::recursive_mutex> &lock) { + lock = std::unique_lock<std::recursive_mutex>(m_mutex); } diff --git a/lldb/source/Breakpoint/BreakpointLocation.cpp b/lldb/source/Breakpoint/BreakpointLocation.cpp index e1b1af0fe78..c68bf6a05df 100644 --- a/lldb/source/Breakpoint/BreakpointLocation.cpp +++ b/lldb/source/Breakpoint/BreakpointLocation.cpp @@ -25,421 +25,336 @@ #include "lldb/Symbol/CompileUnit.h" #include "lldb/Symbol/Symbol.h" #include "lldb/Symbol/TypeSystem.h" -#include "lldb/Target/Target.h" #include "lldb/Target/Process.h" +#include "lldb/Target/Target.h" #include "lldb/Target/Thread.h" #include "lldb/Target/ThreadSpec.h" using namespace lldb; using namespace lldb_private; -BreakpointLocation::BreakpointLocation(break_id_t loc_id, Breakpoint &owner, const Address &addr, lldb::tid_t tid, +BreakpointLocation::BreakpointLocation(break_id_t loc_id, Breakpoint &owner, + const Address &addr, lldb::tid_t tid, bool hardware, bool check_for_resolver) - : StoppointLocation(loc_id, addr.GetOpcodeLoadAddress(&owner.GetTarget()), hardware), - m_being_created(true), - m_should_resolve_indirect_functions(false), - m_is_reexported(false), - m_is_indirect(false), - m_address(addr), - m_owner(owner), - m_options_ap(), - m_bp_site_sp(), - m_condition_mutex() -{ - if (check_for_resolver) - { - Symbol *symbol = m_address.CalculateSymbolContextSymbol(); - if (symbol && symbol->IsIndirect()) - { - SetShouldResolveIndirectFunctions(true); - } + : StoppointLocation(loc_id, addr.GetOpcodeLoadAddress(&owner.GetTarget()), + hardware), + m_being_created(true), m_should_resolve_indirect_functions(false), + m_is_reexported(false), m_is_indirect(false), m_address(addr), + m_owner(owner), m_options_ap(), m_bp_site_sp(), m_condition_mutex() { + if (check_for_resolver) { + Symbol *symbol = m_address.CalculateSymbolContextSymbol(); + if (symbol && symbol->IsIndirect()) { + SetShouldResolveIndirectFunctions(true); } + } - SetThreadID(tid); - m_being_created = false; + SetThreadID(tid); + m_being_created = false; } -BreakpointLocation::~BreakpointLocation() -{ - ClearBreakpointSite(); -} +BreakpointLocation::~BreakpointLocation() { ClearBreakpointSite(); } -lldb::addr_t -BreakpointLocation::GetLoadAddress () const -{ - return m_address.GetOpcodeLoadAddress (&m_owner.GetTarget()); +lldb::addr_t BreakpointLocation::GetLoadAddress() const { + return m_address.GetOpcodeLoadAddress(&m_owner.GetTarget()); } -Address & -BreakpointLocation::GetAddress () -{ - return m_address; -} +Address &BreakpointLocation::GetAddress() { return m_address; } -Breakpoint & -BreakpointLocation::GetBreakpoint () -{ - return m_owner; -} +Breakpoint &BreakpointLocation::GetBreakpoint() { return m_owner; } -Target & -BreakpointLocation::GetTarget() -{ - return m_owner.GetTarget(); -} +Target &BreakpointLocation::GetTarget() { return m_owner.GetTarget(); } -bool -BreakpointLocation::IsEnabled () const -{ - if (!m_owner.IsEnabled()) - return false; - else if (m_options_ap.get() != nullptr) - return m_options_ap->IsEnabled(); - else - return true; +bool BreakpointLocation::IsEnabled() const { + if (!m_owner.IsEnabled()) + return false; + else if (m_options_ap.get() != nullptr) + return m_options_ap->IsEnabled(); + else + return true; } -void -BreakpointLocation::SetEnabled (bool enabled) -{ - GetLocationOptions()->SetEnabled(enabled); - if (enabled) - { - ResolveBreakpointSite(); - } - else - { - ClearBreakpointSite(); - } - SendBreakpointLocationChangedEvent (enabled ? eBreakpointEventTypeEnabled : eBreakpointEventTypeDisabled); +void BreakpointLocation::SetEnabled(bool enabled) { + GetLocationOptions()->SetEnabled(enabled); + if (enabled) { + ResolveBreakpointSite(); + } else { + ClearBreakpointSite(); + } + SendBreakpointLocationChangedEvent(enabled ? eBreakpointEventTypeEnabled + : eBreakpointEventTypeDisabled); } -void -BreakpointLocation::SetThreadID (lldb::tid_t thread_id) -{ - if (thread_id != LLDB_INVALID_THREAD_ID) - GetLocationOptions()->SetThreadID(thread_id); - else - { - // If we're resetting this to an invalid thread id, then - // don't make an options pointer just to do that. - if (m_options_ap.get() != nullptr) - m_options_ap->SetThreadID (thread_id); - } - SendBreakpointLocationChangedEvent (eBreakpointEventTypeThreadChanged); +void BreakpointLocation::SetThreadID(lldb::tid_t thread_id) { + if (thread_id != LLDB_INVALID_THREAD_ID) + GetLocationOptions()->SetThreadID(thread_id); + else { + // If we're resetting this to an invalid thread id, then + // don't make an options pointer just to do that. + if (m_options_ap.get() != nullptr) + m_options_ap->SetThreadID(thread_id); + } + SendBreakpointLocationChangedEvent(eBreakpointEventTypeThreadChanged); } -lldb::tid_t -BreakpointLocation::GetThreadID () -{ - if (GetOptionsNoCreate()->GetThreadSpecNoCreate()) - return GetOptionsNoCreate()->GetThreadSpecNoCreate()->GetTID(); - else - return LLDB_INVALID_THREAD_ID; +lldb::tid_t BreakpointLocation::GetThreadID() { + if (GetOptionsNoCreate()->GetThreadSpecNoCreate()) + return GetOptionsNoCreate()->GetThreadSpecNoCreate()->GetTID(); + else + return LLDB_INVALID_THREAD_ID; } -void -BreakpointLocation::SetThreadIndex (uint32_t index) -{ - if (index != 0) - GetLocationOptions()->GetThreadSpec()->SetIndex(index); - else - { - // If we're resetting this to an invalid thread id, then - // don't make an options pointer just to do that. - if (m_options_ap.get() != nullptr) - m_options_ap->GetThreadSpec()->SetIndex(index); - } - SendBreakpointLocationChangedEvent (eBreakpointEventTypeThreadChanged); +void BreakpointLocation::SetThreadIndex(uint32_t index) { + if (index != 0) + GetLocationOptions()->GetThreadSpec()->SetIndex(index); + else { + // If we're resetting this to an invalid thread id, then + // don't make an options pointer just to do that. + if (m_options_ap.get() != nullptr) + m_options_ap->GetThreadSpec()->SetIndex(index); + } + SendBreakpointLocationChangedEvent(eBreakpointEventTypeThreadChanged); } -uint32_t -BreakpointLocation::GetThreadIndex() const -{ - if (GetOptionsNoCreate()->GetThreadSpecNoCreate()) - return GetOptionsNoCreate()->GetThreadSpecNoCreate()->GetIndex(); - else - return 0; +uint32_t BreakpointLocation::GetThreadIndex() const { + if (GetOptionsNoCreate()->GetThreadSpecNoCreate()) + return GetOptionsNoCreate()->GetThreadSpecNoCreate()->GetIndex(); + else + return 0; } -void -BreakpointLocation::SetThreadName (const char *thread_name) -{ - if (thread_name != nullptr) - GetLocationOptions()->GetThreadSpec()->SetName(thread_name); - else - { - // If we're resetting this to an invalid thread id, then - // don't make an options pointer just to do that. - if (m_options_ap.get() != nullptr) - m_options_ap->GetThreadSpec()->SetName(thread_name); - } - SendBreakpointLocationChangedEvent (eBreakpointEventTypeThreadChanged); +void BreakpointLocation::SetThreadName(const char *thread_name) { + if (thread_name != nullptr) + GetLocationOptions()->GetThreadSpec()->SetName(thread_name); + else { + // If we're resetting this to an invalid thread id, then + // don't make an options pointer just to do that. + if (m_options_ap.get() != nullptr) + m_options_ap->GetThreadSpec()->SetName(thread_name); + } + SendBreakpointLocationChangedEvent(eBreakpointEventTypeThreadChanged); } -const char * -BreakpointLocation::GetThreadName () const -{ - if (GetOptionsNoCreate()->GetThreadSpecNoCreate()) - return GetOptionsNoCreate()->GetThreadSpecNoCreate()->GetName(); - else - return nullptr; +const char *BreakpointLocation::GetThreadName() const { + if (GetOptionsNoCreate()->GetThreadSpecNoCreate()) + return GetOptionsNoCreate()->GetThreadSpecNoCreate()->GetName(); + else + return nullptr; } -void -BreakpointLocation::SetQueueName (const char *queue_name) -{ - if (queue_name != nullptr) - GetLocationOptions()->GetThreadSpec()->SetQueueName(queue_name); - else - { - // If we're resetting this to an invalid thread id, then - // don't make an options pointer just to do that. - if (m_options_ap.get() != nullptr) - m_options_ap->GetThreadSpec()->SetQueueName(queue_name); - } - SendBreakpointLocationChangedEvent (eBreakpointEventTypeThreadChanged); +void BreakpointLocation::SetQueueName(const char *queue_name) { + if (queue_name != nullptr) + GetLocationOptions()->GetThreadSpec()->SetQueueName(queue_name); + else { + // If we're resetting this to an invalid thread id, then + // don't make an options pointer just to do that. + if (m_options_ap.get() != nullptr) + m_options_ap->GetThreadSpec()->SetQueueName(queue_name); + } + SendBreakpointLocationChangedEvent(eBreakpointEventTypeThreadChanged); } -const char * -BreakpointLocation::GetQueueName () const -{ - if (GetOptionsNoCreate()->GetThreadSpecNoCreate()) - return GetOptionsNoCreate()->GetThreadSpecNoCreate()->GetQueueName(); - else - return nullptr; +const char *BreakpointLocation::GetQueueName() const { + if (GetOptionsNoCreate()->GetThreadSpecNoCreate()) + return GetOptionsNoCreate()->GetThreadSpecNoCreate()->GetQueueName(); + else + return nullptr; } -bool -BreakpointLocation::InvokeCallback (StoppointCallbackContext *context) -{ - if (m_options_ap.get() != nullptr && m_options_ap->HasCallback()) - return m_options_ap->InvokeCallback (context, m_owner.GetID(), GetID()); - else - return m_owner.InvokeCallback (context, GetID()); +bool BreakpointLocation::InvokeCallback(StoppointCallbackContext *context) { + if (m_options_ap.get() != nullptr && m_options_ap->HasCallback()) + return m_options_ap->InvokeCallback(context, m_owner.GetID(), GetID()); + else + return m_owner.InvokeCallback(context, GetID()); } -void -BreakpointLocation::SetCallback (BreakpointHitCallback callback, void *baton, - bool is_synchronous) -{ - // The default "Baton" class will keep a copy of "baton" and won't free - // or delete it when it goes goes out of scope. - GetLocationOptions()->SetCallback(callback, BatonSP (new Baton(baton)), is_synchronous); - SendBreakpointLocationChangedEvent (eBreakpointEventTypeCommandChanged); +void BreakpointLocation::SetCallback(BreakpointHitCallback callback, + void *baton, bool is_synchronous) { + // The default "Baton" class will keep a copy of "baton" and won't free + // or delete it when it goes goes out of scope. + GetLocationOptions()->SetCallback(callback, BatonSP(new Baton(baton)), + is_synchronous); + SendBreakpointLocationChangedEvent(eBreakpointEventTypeCommandChanged); } -void -BreakpointLocation::SetCallback (BreakpointHitCallback callback, const BatonSP &baton_sp, - bool is_synchronous) -{ - GetLocationOptions()->SetCallback (callback, baton_sp, is_synchronous); - SendBreakpointLocationChangedEvent (eBreakpointEventTypeCommandChanged); +void BreakpointLocation::SetCallback(BreakpointHitCallback callback, + const BatonSP &baton_sp, + bool is_synchronous) { + GetLocationOptions()->SetCallback(callback, baton_sp, is_synchronous); + SendBreakpointLocationChangedEvent(eBreakpointEventTypeCommandChanged); } -void -BreakpointLocation::ClearCallback () -{ - GetLocationOptions()->ClearCallback(); +void BreakpointLocation::ClearCallback() { + GetLocationOptions()->ClearCallback(); } -void -BreakpointLocation::SetCondition (const char *condition) -{ - GetLocationOptions()->SetCondition (condition); - SendBreakpointLocationChangedEvent (eBreakpointEventTypeConditionChanged); +void BreakpointLocation::SetCondition(const char *condition) { + GetLocationOptions()->SetCondition(condition); + SendBreakpointLocationChangedEvent(eBreakpointEventTypeConditionChanged); } -const char * -BreakpointLocation::GetConditionText (size_t *hash) const -{ - return GetOptionsNoCreate()->GetConditionText(hash); +const char *BreakpointLocation::GetConditionText(size_t *hash) const { + return GetOptionsNoCreate()->GetConditionText(hash); } -bool -BreakpointLocation::ConditionSaysStop (ExecutionContext &exe_ctx, Error &error) -{ - Log *log = lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_BREAKPOINTS); +bool BreakpointLocation::ConditionSaysStop(ExecutionContext &exe_ctx, + Error &error) { + Log *log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_BREAKPOINTS); + + std::lock_guard<std::mutex> guard(m_condition_mutex); - std::lock_guard<std::mutex> guard(m_condition_mutex); + size_t condition_hash; + const char *condition_text = GetConditionText(&condition_hash); - size_t condition_hash; - const char *condition_text = GetConditionText(&condition_hash); - - if (!condition_text) - { - m_user_expression_sp.reset(); - return false; + if (!condition_text) { + m_user_expression_sp.reset(); + return false; + } + + error.Clear(); + + DiagnosticManager diagnostics; + + if (condition_hash != m_condition_hash || !m_user_expression_sp || + !m_user_expression_sp->MatchesContext(exe_ctx)) { + LanguageType language = eLanguageTypeUnknown; + // See if we can figure out the language from the frame, otherwise use the + // default language: + CompileUnit *comp_unit = m_address.CalculateSymbolContextCompileUnit(); + if (comp_unit) + language = comp_unit->GetLanguage(); + + m_user_expression_sp.reset(GetTarget().GetUserExpressionForLanguage( + condition_text, nullptr, language, Expression::eResultTypeAny, + EvaluateExpressionOptions(), error)); + if (error.Fail()) { + if (log) + log->Printf("Error getting condition expression: %s.", + error.AsCString()); + m_user_expression_sp.reset(); + return true; } - error.Clear(); - - DiagnosticManager diagnostics; - - if (condition_hash != m_condition_hash || !m_user_expression_sp || !m_user_expression_sp->MatchesContext(exe_ctx)) - { - LanguageType language = eLanguageTypeUnknown; - // See if we can figure out the language from the frame, otherwise use the default language: - CompileUnit *comp_unit = m_address.CalculateSymbolContextCompileUnit(); - if (comp_unit) - language = comp_unit->GetLanguage(); - - m_user_expression_sp.reset(GetTarget().GetUserExpressionForLanguage(condition_text, - nullptr, - language, - Expression::eResultTypeAny, - EvaluateExpressionOptions(), - error)); - if (error.Fail()) - { - if (log) - log->Printf("Error getting condition expression: %s.", error.AsCString()); - m_user_expression_sp.reset(); - return true; - } + if (!m_user_expression_sp->Parse(diagnostics, exe_ctx, + eExecutionPolicyOnlyWhenNeeded, true, + false)) { + error.SetErrorStringWithFormat( + "Couldn't parse conditional expression:\n%s", + diagnostics.GetString().c_str()); + m_user_expression_sp.reset(); + return true; + } - if (!m_user_expression_sp->Parse(diagnostics, exe_ctx, eExecutionPolicyOnlyWhenNeeded, true, false)) - { - error.SetErrorStringWithFormat("Couldn't parse conditional expression:\n%s", - diagnostics.GetString().c_str()); - m_user_expression_sp.reset(); - return true; - } + m_condition_hash = condition_hash; + } + + // We need to make sure the user sees any parse errors in their condition, so + // we'll hook the + // constructor errors up to the debugger's Async I/O. + + ValueObjectSP result_value_sp; + + EvaluateExpressionOptions options; + options.SetUnwindOnError(true); + options.SetIgnoreBreakpoints(true); + options.SetTryAllThreads(true); + options.SetResultIsInternal( + true); // Don't generate a user variable for condition expressions. + + Error expr_error; + + diagnostics.Clear(); - m_condition_hash = condition_hash; + ExpressionVariableSP result_variable_sp; + + ExpressionResults result_code = m_user_expression_sp->Execute( + diagnostics, exe_ctx, options, m_user_expression_sp, result_variable_sp); + + bool ret; + + if (result_code == eExpressionCompleted) { + if (!result_variable_sp) { + error.SetErrorString("Expression did not return a result"); + return false; } - // We need to make sure the user sees any parse errors in their condition, so we'll hook the - // constructor errors up to the debugger's Async I/O. - - ValueObjectSP result_value_sp; - - EvaluateExpressionOptions options; - options.SetUnwindOnError(true); - options.SetIgnoreBreakpoints(true); - options.SetTryAllThreads(true); - options.SetResultIsInternal(true); // Don't generate a user variable for condition expressions. - - Error expr_error; - - diagnostics.Clear(); - - ExpressionVariableSP result_variable_sp; - - ExpressionResults result_code = - m_user_expression_sp->Execute(diagnostics, exe_ctx, options, m_user_expression_sp, result_variable_sp); - - bool ret; - - if (result_code == eExpressionCompleted) - { - if (!result_variable_sp) - { - error.SetErrorString("Expression did not return a result"); - return false; - } - - result_value_sp = result_variable_sp->GetValueObject(); - - if (result_value_sp) - { - ret = result_value_sp->IsLogicalTrue(error); - if (log) - { - if (error.Success()) - { - log->Printf("Condition successfully evaluated, result is %s.\n", - ret ? "true" : "false"); - } - else - { - error.SetErrorString("Failed to get an integer result from the expression"); - ret = false; - } - - } + result_value_sp = result_variable_sp->GetValueObject(); + + if (result_value_sp) { + ret = result_value_sp->IsLogicalTrue(error); + if (log) { + if (error.Success()) { + log->Printf("Condition successfully evaluated, result is %s.\n", + ret ? "true" : "false"); + } else { + error.SetErrorString( + "Failed to get an integer result from the expression"); + ret = false; } - else - { - ret = false; - error.SetErrorString("Failed to get any result from the expression"); - } - } - else - { - ret = false; - error.SetErrorStringWithFormat("Couldn't execute expression:\n%s", diagnostics.GetString().c_str()); + } + } else { + ret = false; + error.SetErrorString("Failed to get any result from the expression"); } + } else { + ret = false; + error.SetErrorStringWithFormat("Couldn't execute expression:\n%s", + diagnostics.GetString().c_str()); + } - return ret; + return ret; } -uint32_t -BreakpointLocation::GetIgnoreCount () -{ - return GetOptionsNoCreate()->GetIgnoreCount(); +uint32_t BreakpointLocation::GetIgnoreCount() { + return GetOptionsNoCreate()->GetIgnoreCount(); } -void -BreakpointLocation::SetIgnoreCount (uint32_t n) -{ - GetLocationOptions()->SetIgnoreCount(n); - SendBreakpointLocationChangedEvent (eBreakpointEventTypeIgnoreChanged); +void BreakpointLocation::SetIgnoreCount(uint32_t n) { + GetLocationOptions()->SetIgnoreCount(n); + SendBreakpointLocationChangedEvent(eBreakpointEventTypeIgnoreChanged); } -void -BreakpointLocation::DecrementIgnoreCount() -{ - if (m_options_ap.get() != nullptr) - { - uint32_t loc_ignore = m_options_ap->GetIgnoreCount(); - if (loc_ignore != 0) - m_options_ap->SetIgnoreCount(loc_ignore - 1); - } +void BreakpointLocation::DecrementIgnoreCount() { + if (m_options_ap.get() != nullptr) { + uint32_t loc_ignore = m_options_ap->GetIgnoreCount(); + if (loc_ignore != 0) + m_options_ap->SetIgnoreCount(loc_ignore - 1); + } } -bool -BreakpointLocation::IgnoreCountShouldStop() -{ - if (m_options_ap.get() != nullptr) - { - uint32_t loc_ignore = m_options_ap->GetIgnoreCount(); - if (loc_ignore != 0) - { - m_owner.DecrementIgnoreCount(); - DecrementIgnoreCount(); // Have to decrement our owners' ignore count, since it won't get a - // chance to. - return false; - } +bool BreakpointLocation::IgnoreCountShouldStop() { + if (m_options_ap.get() != nullptr) { + uint32_t loc_ignore = m_options_ap->GetIgnoreCount(); + if (loc_ignore != 0) { + m_owner.DecrementIgnoreCount(); + DecrementIgnoreCount(); // Have to decrement our owners' ignore count, + // since it won't get a + // chance to. + return false; } - return true; + } + return true; } -const BreakpointOptions * -BreakpointLocation::GetOptionsNoCreate () const -{ - if (m_options_ap.get() != nullptr) - return m_options_ap.get(); - else - return m_owner.GetOptions (); -} - -BreakpointOptions * -BreakpointLocation::GetLocationOptions () -{ - // If we make the copy we don't copy the callbacks because that is potentially - // expensive and we don't want to do that for the simple case where someone is - // just disabling the location. - if (m_options_ap.get() == nullptr) - m_options_ap.reset(BreakpointOptions::CopyOptionsNoCallback(*m_owner.GetOptions ())); - +const BreakpointOptions *BreakpointLocation::GetOptionsNoCreate() const { + if (m_options_ap.get() != nullptr) return m_options_ap.get(); + else + return m_owner.GetOptions(); +} + +BreakpointOptions *BreakpointLocation::GetLocationOptions() { + // If we make the copy we don't copy the callbacks because that is potentially + // expensive and we don't want to do that for the simple case where someone is + // just disabling the location. + if (m_options_ap.get() == nullptr) + m_options_ap.reset( + BreakpointOptions::CopyOptionsNoCallback(*m_owner.GetOptions())); + + return m_options_ap.get(); } -bool -BreakpointLocation::ValidForThisThread (Thread *thread) -{ - return thread->MatchesSpec(GetOptionsNoCreate()->GetThreadSpecNoCreate()); +bool BreakpointLocation::ValidForThisThread(Thread *thread) { + return thread->MatchesSpec(GetOptionsNoCreate()->GetThreadSpecNoCreate()); } // RETURNS - true if we should stop at this breakpoint, false if we @@ -447,309 +362,275 @@ BreakpointLocation::ValidForThisThread (Thread *thread) // here, since if the breakpoint is not for this thread, then the event won't // even get reported, so the check is redundant. -bool -BreakpointLocation::ShouldStop (StoppointCallbackContext *context) -{ - bool should_stop = true; - Log *log = lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_BREAKPOINTS); - - // Do this first, if a location is disabled, it shouldn't increment its hit count. - if (!IsEnabled()) - return false; - - if (!IgnoreCountShouldStop()) - return false; - - if (!m_owner.IgnoreCountShouldStop()) - return false; - - // We only run synchronous callbacks in ShouldStop: - context->is_synchronous = true; - should_stop = InvokeCallback (context); - - if (log) - { - StreamString s; - GetDescription (&s, lldb::eDescriptionLevelVerbose); - log->Printf ("Hit breakpoint location: %s, %s.\n", s.GetData(), should_stop ? "stopping" : "continuing"); - } - - return should_stop; -} - -void -BreakpointLocation::BumpHitCount() -{ - if (IsEnabled()) - { - // Step our hit count, and also step the hit count of the owner. - IncrementHitCount(); - m_owner.IncrementHitCount(); - } +bool BreakpointLocation::ShouldStop(StoppointCallbackContext *context) { + bool should_stop = true; + Log *log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_BREAKPOINTS); + + // Do this first, if a location is disabled, it shouldn't increment its hit + // count. + if (!IsEnabled()) + return false; + + if (!IgnoreCountShouldStop()) + return false; + + if (!m_owner.IgnoreCountShouldStop()) + return false; + + // We only run synchronous callbacks in ShouldStop: + context->is_synchronous = true; + should_stop = InvokeCallback(context); + + if (log) { + StreamString s; + GetDescription(&s, lldb::eDescriptionLevelVerbose); + log->Printf("Hit breakpoint location: %s, %s.\n", s.GetData(), + should_stop ? "stopping" : "continuing"); + } + + return should_stop; } -void -BreakpointLocation::UndoBumpHitCount() -{ - if (IsEnabled()) - { - // Step our hit count, and also step the hit count of the owner. - DecrementHitCount(); - m_owner.DecrementHitCount(); - } +void BreakpointLocation::BumpHitCount() { + if (IsEnabled()) { + // Step our hit count, and also step the hit count of the owner. + IncrementHitCount(); + m_owner.IncrementHitCount(); + } } -bool -BreakpointLocation::IsResolved () const -{ - return m_bp_site_sp.get() != nullptr; +void BreakpointLocation::UndoBumpHitCount() { + if (IsEnabled()) { + // Step our hit count, and also step the hit count of the owner. + DecrementHitCount(); + m_owner.DecrementHitCount(); + } } -lldb::BreakpointSiteSP -BreakpointLocation::GetBreakpointSite() const -{ - return m_bp_site_sp; +bool BreakpointLocation::IsResolved() const { + return m_bp_site_sp.get() != nullptr; } -bool -BreakpointLocation::ResolveBreakpointSite () -{ - if (m_bp_site_sp) - return true; +lldb::BreakpointSiteSP BreakpointLocation::GetBreakpointSite() const { + return m_bp_site_sp; +} - Process *process = m_owner.GetTarget().GetProcessSP().get(); - if (process == nullptr) - return false; +bool BreakpointLocation::ResolveBreakpointSite() { + if (m_bp_site_sp) + return true; - lldb::break_id_t new_id = process->CreateBreakpointSite (shared_from_this(), m_owner.IsHardware()); + Process *process = m_owner.GetTarget().GetProcessSP().get(); + if (process == nullptr) + return false; - if (new_id == LLDB_INVALID_BREAK_ID) - { - Log *log = lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_BREAKPOINTS); - if (log) - log->Warning ("Tried to add breakpoint site at 0x%" PRIx64 " but it was already present.\n", - m_address.GetOpcodeLoadAddress (&m_owner.GetTarget())); - return false; - } + lldb::break_id_t new_id = + process->CreateBreakpointSite(shared_from_this(), m_owner.IsHardware()); - return true; -} + if (new_id == LLDB_INVALID_BREAK_ID) { + Log *log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_BREAKPOINTS); + if (log) + log->Warning("Tried to add breakpoint site at 0x%" PRIx64 + " but it was already present.\n", + m_address.GetOpcodeLoadAddress(&m_owner.GetTarget())); + return false; + } -bool -BreakpointLocation::SetBreakpointSite (BreakpointSiteSP& bp_site_sp) -{ - m_bp_site_sp = bp_site_sp; - SendBreakpointLocationChangedEvent (eBreakpointEventTypeLocationsResolved); - return true; + return true; } -bool -BreakpointLocation::ClearBreakpointSite () -{ - if (m_bp_site_sp.get()) - { - ProcessSP process_sp(m_owner.GetTarget().GetProcessSP()); - // If the process exists, get it to remove the owner, it will remove the physical implementation - // of the breakpoint as well if there are no more owners. Otherwise just remove this owner. - if (process_sp) - process_sp->RemoveOwnerFromBreakpointSite (GetBreakpoint().GetID(), - GetID(), m_bp_site_sp); - else - m_bp_site_sp->RemoveOwner(GetBreakpoint().GetID(), GetID()); - - m_bp_site_sp.reset(); - return true; - } - return false; +bool BreakpointLocation::SetBreakpointSite(BreakpointSiteSP &bp_site_sp) { + m_bp_site_sp = bp_site_sp; + SendBreakpointLocationChangedEvent(eBreakpointEventTypeLocationsResolved); + return true; } -void -BreakpointLocation::GetDescription (Stream *s, lldb::DescriptionLevel level) -{ - SymbolContext sc; - - // If the description level is "initial" then the breakpoint is printing out our initial state, - // and we should let it decide how it wants to print our label. - if (level != eDescriptionLevelInitial) - { - s->Indent(); - BreakpointID::GetCanonicalReference(s, m_owner.GetID(), GetID()); - } - - if (level == lldb::eDescriptionLevelBrief) - return; - - if (level != eDescriptionLevelInitial) - s->PutCString(": "); - - if (level == lldb::eDescriptionLevelVerbose) - s->IndentMore(); - - if (m_address.IsSectionOffset()) - { - m_address.CalculateSymbolContext(&sc); - - if (level == lldb::eDescriptionLevelFull || level == eDescriptionLevelInitial) - { - if (IsReExported()) - s->PutCString ("re-exported target = "); - else - s->PutCString("where = "); - sc.DumpStopContext (s, m_owner.GetTarget().GetProcessSP().get(), m_address, false, true, false, true, true); - } - else - { - if (sc.module_sp) - { - s->EOL(); - s->Indent("module = "); - sc.module_sp->GetFileSpec().Dump (s); - } - - if (sc.comp_unit != nullptr) - { - s->EOL(); - s->Indent("compile unit = "); - static_cast<FileSpec*>(sc.comp_unit)->GetFilename().Dump (s); - - if (sc.function != nullptr) - { - s->EOL(); - s->Indent("function = "); - s->PutCString (sc.function->GetName().AsCString("<unknown>")); - } - - if (sc.line_entry.line > 0) - { - s->EOL(); - s->Indent("location = "); - sc.line_entry.DumpStopContext (s, true); - } - - } - else - { - // If we don't have a comp unit, see if we have a symbol we can print. - if (sc.symbol) - { - s->EOL(); - if (IsReExported()) - s->Indent ("re-exported target = "); - else - s->Indent("symbol = "); - s->PutCString(sc.symbol->GetName().AsCString("<unknown>")); - } - } - } - } +bool BreakpointLocation::ClearBreakpointSite() { + if (m_bp_site_sp.get()) { + ProcessSP process_sp(m_owner.GetTarget().GetProcessSP()); + // If the process exists, get it to remove the owner, it will remove the + // physical implementation + // of the breakpoint as well if there are no more owners. Otherwise just + // remove this owner. + if (process_sp) + process_sp->RemoveOwnerFromBreakpointSite(GetBreakpoint().GetID(), + GetID(), m_bp_site_sp); + else + m_bp_site_sp->RemoveOwner(GetBreakpoint().GetID(), GetID()); - if (level == lldb::eDescriptionLevelVerbose) - { + m_bp_site_sp.reset(); + return true; + } + return false; +} + +void BreakpointLocation::GetDescription(Stream *s, + lldb::DescriptionLevel level) { + SymbolContext sc; + + // If the description level is "initial" then the breakpoint is printing out + // our initial state, + // and we should let it decide how it wants to print our label. + if (level != eDescriptionLevelInitial) { + s->Indent(); + BreakpointID::GetCanonicalReference(s, m_owner.GetID(), GetID()); + } + + if (level == lldb::eDescriptionLevelBrief) + return; + + if (level != eDescriptionLevelInitial) + s->PutCString(": "); + + if (level == lldb::eDescriptionLevelVerbose) + s->IndentMore(); + + if (m_address.IsSectionOffset()) { + m_address.CalculateSymbolContext(&sc); + + if (level == lldb::eDescriptionLevelFull || + level == eDescriptionLevelInitial) { + if (IsReExported()) + s->PutCString("re-exported target = "); + else + s->PutCString("where = "); + sc.DumpStopContext(s, m_owner.GetTarget().GetProcessSP().get(), m_address, + false, true, false, true, true); + } else { + if (sc.module_sp) { s->EOL(); - s->Indent(); - } - - if (m_address.IsSectionOffset() && (level == eDescriptionLevelFull || level == eDescriptionLevelInitial)) - s->Printf (", "); - s->Printf ("address = "); - - ExecutionContextScope *exe_scope = nullptr; - Target *target = &m_owner.GetTarget(); - if (target) - exe_scope = target->GetProcessSP().get(); - if (exe_scope == nullptr) - exe_scope = target; - - if (level == eDescriptionLevelInitial) - m_address.Dump(s, exe_scope, Address::DumpStyleLoadAddress, Address::DumpStyleFileAddress); - else - m_address.Dump(s, exe_scope, Address::DumpStyleLoadAddress, Address::DumpStyleModuleWithFileAddress); - - if (IsIndirect() && m_bp_site_sp) - { - Address resolved_address; - resolved_address.SetLoadAddress(m_bp_site_sp->GetLoadAddress(), target); - Symbol *resolved_symbol = resolved_address.CalculateSymbolContextSymbol(); - if (resolved_symbol) - { - if (level == eDescriptionLevelFull || level == eDescriptionLevelInitial) - s->Printf (", "); - else if (level == lldb::eDescriptionLevelVerbose) - { - s->EOL(); - s->Indent(); - } - s->Printf ("indirect target = %s", resolved_symbol->GetName().GetCString()); - } - } + s->Indent("module = "); + sc.module_sp->GetFileSpec().Dump(s); + } - if (level == lldb::eDescriptionLevelVerbose) - { + if (sc.comp_unit != nullptr) { s->EOL(); - s->Indent(); - s->Printf("resolved = %s\n", IsResolved() ? "true" : "false"); + s->Indent("compile unit = "); + static_cast<FileSpec *>(sc.comp_unit)->GetFilename().Dump(s); - s->Indent(); - s->Printf ("hit count = %-4u\n", GetHitCount()); + if (sc.function != nullptr) { + s->EOL(); + s->Indent("function = "); + s->PutCString(sc.function->GetName().AsCString("<unknown>")); + } - if (m_options_ap.get()) - { - s->Indent(); - m_options_ap->GetDescription (s, level); - s->EOL(); + if (sc.line_entry.line > 0) { + s->EOL(); + s->Indent("location = "); + sc.line_entry.DumpStopContext(s, true); } - s->IndentLess(); - } - else if (level != eDescriptionLevelInitial) - { - s->Printf(", %sresolved, hit count = %u ", - (IsResolved() ? "" : "un"), - GetHitCount()); - if (m_options_ap.get()) - { - m_options_ap->GetDescription (s, level); + + } else { + // If we don't have a comp unit, see if we have a symbol we can print. + if (sc.symbol) { + s->EOL(); + if (IsReExported()) + s->Indent("re-exported target = "); + else + s->Indent("symbol = "); + s->PutCString(sc.symbol->GetName().AsCString("<unknown>")); } + } } -} - -void -BreakpointLocation::Dump(Stream *s) const -{ - if (s == nullptr) - return; - - s->Printf("BreakpointLocation %u: tid = %4.4" PRIx64 " load addr = 0x%8.8" PRIx64 " state = %s type = %s breakpoint " - "hw_index = %i hit_count = %-4u ignore_count = %-4u", - GetID(), - GetOptionsNoCreate()->GetThreadSpecNoCreate()->GetTID(), - (uint64_t) m_address.GetOpcodeLoadAddress (&m_owner.GetTarget()), - (m_options_ap.get() ? m_options_ap->IsEnabled() : m_owner.IsEnabled()) ? "enabled " : "disabled", - IsHardware() ? "hardware" : "software", - GetHardwareIndex(), - GetHitCount(), - GetOptionsNoCreate()->GetIgnoreCount()); -} - -void -BreakpointLocation::SendBreakpointLocationChangedEvent (lldb::BreakpointEventType eventKind) -{ - if (!m_being_created - && !m_owner.IsInternal() - && m_owner.GetTarget().EventTypeHasListeners(Target::eBroadcastBitBreakpointChanged)) - { - Breakpoint::BreakpointEventData *data = new Breakpoint::BreakpointEventData (eventKind, - m_owner.shared_from_this()); - data->GetBreakpointLocationCollection().Add (shared_from_this()); - m_owner.GetTarget().BroadcastEvent (Target::eBroadcastBitBreakpointChanged, data); + } + + if (level == lldb::eDescriptionLevelVerbose) { + s->EOL(); + s->Indent(); + } + + if (m_address.IsSectionOffset() && + (level == eDescriptionLevelFull || level == eDescriptionLevelInitial)) + s->Printf(", "); + s->Printf("address = "); + + ExecutionContextScope *exe_scope = nullptr; + Target *target = &m_owner.GetTarget(); + if (target) + exe_scope = target->GetProcessSP().get(); + if (exe_scope == nullptr) + exe_scope = target; + + if (level == eDescriptionLevelInitial) + m_address.Dump(s, exe_scope, Address::DumpStyleLoadAddress, + Address::DumpStyleFileAddress); + else + m_address.Dump(s, exe_scope, Address::DumpStyleLoadAddress, + Address::DumpStyleModuleWithFileAddress); + + if (IsIndirect() && m_bp_site_sp) { + Address resolved_address; + resolved_address.SetLoadAddress(m_bp_site_sp->GetLoadAddress(), target); + Symbol *resolved_symbol = resolved_address.CalculateSymbolContextSymbol(); + if (resolved_symbol) { + if (level == eDescriptionLevelFull || level == eDescriptionLevelInitial) + s->Printf(", "); + else if (level == lldb::eDescriptionLevelVerbose) { + s->EOL(); + s->Indent(); + } + s->Printf("indirect target = %s", + resolved_symbol->GetName().GetCString()); } -} + } -void -BreakpointLocation::SwapLocation (BreakpointLocationSP swap_from) -{ - m_address = swap_from->m_address; - m_should_resolve_indirect_functions = swap_from->m_should_resolve_indirect_functions; - m_is_reexported = swap_from->m_is_reexported; - m_is_indirect = swap_from->m_is_indirect; - m_user_expression_sp.reset(); + if (level == lldb::eDescriptionLevelVerbose) { + s->EOL(); + s->Indent(); + s->Printf("resolved = %s\n", IsResolved() ? "true" : "false"); + + s->Indent(); + s->Printf("hit count = %-4u\n", GetHitCount()); + + if (m_options_ap.get()) { + s->Indent(); + m_options_ap->GetDescription(s, level); + s->EOL(); + } + s->IndentLess(); + } else if (level != eDescriptionLevelInitial) { + s->Printf(", %sresolved, hit count = %u ", (IsResolved() ? "" : "un"), + GetHitCount()); + if (m_options_ap.get()) { + m_options_ap->GetDescription(s, level); + } + } +} + +void BreakpointLocation::Dump(Stream *s) const { + if (s == nullptr) + return; + + s->Printf( + "BreakpointLocation %u: tid = %4.4" PRIx64 " load addr = 0x%8.8" PRIx64 + " state = %s type = %s breakpoint " + "hw_index = %i hit_count = %-4u ignore_count = %-4u", + GetID(), GetOptionsNoCreate()->GetThreadSpecNoCreate()->GetTID(), + (uint64_t)m_address.GetOpcodeLoadAddress(&m_owner.GetTarget()), + (m_options_ap.get() ? m_options_ap->IsEnabled() : m_owner.IsEnabled()) + ? "enabled " + : "disabled", + IsHardware() ? "hardware" : "software", GetHardwareIndex(), GetHitCount(), + GetOptionsNoCreate()->GetIgnoreCount()); +} + +void BreakpointLocation::SendBreakpointLocationChangedEvent( + lldb::BreakpointEventType eventKind) { + if (!m_being_created && !m_owner.IsInternal() && + m_owner.GetTarget().EventTypeHasListeners( + Target::eBroadcastBitBreakpointChanged)) { + Breakpoint::BreakpointEventData *data = new Breakpoint::BreakpointEventData( + eventKind, m_owner.shared_from_this()); + data->GetBreakpointLocationCollection().Add(shared_from_this()); + m_owner.GetTarget().BroadcastEvent(Target::eBroadcastBitBreakpointChanged, + data); + } +} + +void BreakpointLocation::SwapLocation(BreakpointLocationSP swap_from) { + m_address = swap_from->m_address; + m_should_resolve_indirect_functions = + swap_from->m_should_resolve_indirect_functions; + m_is_reexported = swap_from->m_is_reexported; + m_is_indirect = swap_from->m_is_indirect; + m_user_expression_sp.reset(); } diff --git a/lldb/source/Breakpoint/BreakpointLocationCollection.cpp b/lldb/source/Breakpoint/BreakpointLocationCollection.cpp index 52698b2f15b..6536002bda6 100644 --- a/lldb/source/Breakpoint/BreakpointLocationCollection.cpp +++ b/lldb/source/Breakpoint/BreakpointLocationCollection.cpp @@ -7,15 +7,14 @@ // //===----------------------------------------------------------------------===// - // C Includes // C++ Includes // Other libraries and framework includes // Project includes #include "lldb/Breakpoint/BreakpointLocationCollection.h" -#include "lldb/Core/ModuleList.h" #include "lldb/Breakpoint/Breakpoint.h" #include "lldb/Breakpoint/BreakpointLocation.h" +#include "lldb/Core/ModuleList.h" #include "lldb/Target/Thread.h" #include "lldb/Target/ThreadSpec.h" @@ -25,189 +24,162 @@ using namespace lldb_private; //---------------------------------------------------------------------- // BreakpointLocationCollection constructor //---------------------------------------------------------------------- -BreakpointLocationCollection::BreakpointLocationCollection() : - m_break_loc_collection(), - m_collection_mutex() -{ -} +BreakpointLocationCollection::BreakpointLocationCollection() + : m_break_loc_collection(), m_collection_mutex() {} //---------------------------------------------------------------------- // Destructor //---------------------------------------------------------------------- -BreakpointLocationCollection::~BreakpointLocationCollection() -{ +BreakpointLocationCollection::~BreakpointLocationCollection() {} + +void BreakpointLocationCollection::Add(const BreakpointLocationSP &bp_loc) { + std::lock_guard<std::mutex> guard(m_collection_mutex); + BreakpointLocationSP old_bp_loc = + FindByIDPair(bp_loc->GetBreakpoint().GetID(), bp_loc->GetID()); + if (!old_bp_loc.get()) + m_break_loc_collection.push_back(bp_loc); } -void -BreakpointLocationCollection::Add(const BreakpointLocationSP &bp_loc) -{ - std::lock_guard<std::mutex> guard(m_collection_mutex); - BreakpointLocationSP old_bp_loc = FindByIDPair (bp_loc->GetBreakpoint().GetID(), bp_loc->GetID()); - if (!old_bp_loc.get()) - m_break_loc_collection.push_back(bp_loc); +bool BreakpointLocationCollection::Remove(lldb::break_id_t bp_id, + lldb::break_id_t bp_loc_id) { + std::lock_guard<std::mutex> guard(m_collection_mutex); + collection::iterator pos = GetIDPairIterator(bp_id, bp_loc_id); // Predicate + if (pos != m_break_loc_collection.end()) { + m_break_loc_collection.erase(pos); + return true; + } + return false; } -bool -BreakpointLocationCollection::Remove (lldb::break_id_t bp_id, lldb::break_id_t bp_loc_id) -{ - std::lock_guard<std::mutex> guard(m_collection_mutex); - collection::iterator pos = GetIDPairIterator(bp_id, bp_loc_id); // Predicate - if (pos != m_break_loc_collection.end()) - { - m_break_loc_collection.erase(pos); - return true; - } - return false; - -} - -class BreakpointIDPairMatches -{ +class BreakpointIDPairMatches { public: - BreakpointIDPairMatches (lldb::break_id_t break_id, lldb::break_id_t break_loc_id) : - m_break_id(break_id), - m_break_loc_id (break_loc_id) - { - } + BreakpointIDPairMatches(lldb::break_id_t break_id, + lldb::break_id_t break_loc_id) + : m_break_id(break_id), m_break_loc_id(break_loc_id) {} - bool operator() (const BreakpointLocationSP &bp_loc) const - { - return m_break_id == bp_loc->GetBreakpoint().GetID() - && m_break_loc_id == bp_loc->GetID(); - } + bool operator()(const BreakpointLocationSP &bp_loc) const { + return m_break_id == bp_loc->GetBreakpoint().GetID() && + m_break_loc_id == bp_loc->GetID(); + } private: - const lldb::break_id_t m_break_id; - const lldb::break_id_t m_break_loc_id; + const lldb::break_id_t m_break_id; + const lldb::break_id_t m_break_loc_id; }; BreakpointLocationCollection::collection::iterator -BreakpointLocationCollection::GetIDPairIterator (lldb::break_id_t break_id, lldb::break_id_t break_loc_id) -{ - return std::find_if(m_break_loc_collection.begin(), m_break_loc_collection.end(), // Search full range - BreakpointIDPairMatches(break_id, break_loc_id)); // Predicate +BreakpointLocationCollection::GetIDPairIterator(lldb::break_id_t break_id, + lldb::break_id_t break_loc_id) { + return std::find_if( + m_break_loc_collection.begin(), + m_break_loc_collection.end(), // Search full range + BreakpointIDPairMatches(break_id, break_loc_id)); // Predicate } BreakpointLocationCollection::collection::const_iterator -BreakpointLocationCollection::GetIDPairConstIterator (lldb::break_id_t break_id, lldb::break_id_t break_loc_id) const -{ - return std::find_if(m_break_loc_collection.begin(), m_break_loc_collection.end(), // Search full range - BreakpointIDPairMatches(break_id, break_loc_id)); // Predicate +BreakpointLocationCollection::GetIDPairConstIterator( + lldb::break_id_t break_id, lldb::break_id_t break_loc_id) const { + return std::find_if( + m_break_loc_collection.begin(), + m_break_loc_collection.end(), // Search full range + BreakpointIDPairMatches(break_id, break_loc_id)); // Predicate } BreakpointLocationSP -BreakpointLocationCollection::FindByIDPair (lldb::break_id_t break_id, lldb::break_id_t break_loc_id) -{ - BreakpointLocationSP stop_sp; - collection::iterator pos = GetIDPairIterator(break_id, break_loc_id); - if (pos != m_break_loc_collection.end()) - stop_sp = *pos; - - return stop_sp; +BreakpointLocationCollection::FindByIDPair(lldb::break_id_t break_id, + lldb::break_id_t break_loc_id) { + BreakpointLocationSP stop_sp; + collection::iterator pos = GetIDPairIterator(break_id, break_loc_id); + if (pos != m_break_loc_collection.end()) + stop_sp = *pos; + + return stop_sp; } -const BreakpointLocationSP -BreakpointLocationCollection::FindByIDPair (lldb::break_id_t break_id, lldb::break_id_t break_loc_id) const -{ - BreakpointLocationSP stop_sp; - collection::const_iterator pos = GetIDPairConstIterator(break_id, break_loc_id); - if (pos != m_break_loc_collection.end()) - stop_sp = *pos; - - return stop_sp; +const BreakpointLocationSP BreakpointLocationCollection::FindByIDPair( + lldb::break_id_t break_id, lldb::break_id_t break_loc_id) const { + BreakpointLocationSP stop_sp; + collection::const_iterator pos = + GetIDPairConstIterator(break_id, break_loc_id); + if (pos != m_break_loc_collection.end()) + stop_sp = *pos; + + return stop_sp; } -BreakpointLocationSP -BreakpointLocationCollection::GetByIndex (size_t i) -{ - std::lock_guard<std::mutex> guard(m_collection_mutex); - BreakpointLocationSP stop_sp; - if (i < m_break_loc_collection.size()) - stop_sp = m_break_loc_collection[i]; - - return stop_sp; +BreakpointLocationSP BreakpointLocationCollection::GetByIndex(size_t i) { + std::lock_guard<std::mutex> guard(m_collection_mutex); + BreakpointLocationSP stop_sp; + if (i < m_break_loc_collection.size()) + stop_sp = m_break_loc_collection[i]; + + return stop_sp; } const BreakpointLocationSP -BreakpointLocationCollection::GetByIndex (size_t i) const -{ - std::lock_guard<std::mutex> guard(m_collection_mutex); - BreakpointLocationSP stop_sp; - if (i < m_break_loc_collection.size()) - stop_sp = m_break_loc_collection[i]; - - return stop_sp; -} +BreakpointLocationCollection::GetByIndex(size_t i) const { + std::lock_guard<std::mutex> guard(m_collection_mutex); + BreakpointLocationSP stop_sp; + if (i < m_break_loc_collection.size()) + stop_sp = m_break_loc_collection[i]; -bool -BreakpointLocationCollection::ShouldStop (StoppointCallbackContext *context) -{ - bool shouldStop = false; - size_t i = 0; - size_t prev_size = GetSize(); - while (i < prev_size) - { - // ShouldStop can remove the breakpoint from the list - if (GetByIndex(i)->ShouldStop(context)) - shouldStop = true; - - if (prev_size == GetSize()) - i++; - prev_size = GetSize(); - } - return shouldStop; + return stop_sp; } -bool -BreakpointLocationCollection::ValidForThisThread (Thread *thread) -{ - std::lock_guard<std::mutex> guard(m_collection_mutex); - collection::iterator pos, - begin = m_break_loc_collection.begin(), - end = m_break_loc_collection.end(); - - for (pos = begin; pos != end; ++pos) - { - if ((*pos)->ValidForThisThread (thread)) - return true; - } - return false; +bool BreakpointLocationCollection::ShouldStop( + StoppointCallbackContext *context) { + bool shouldStop = false; + size_t i = 0; + size_t prev_size = GetSize(); + while (i < prev_size) { + // ShouldStop can remove the breakpoint from the list + if (GetByIndex(i)->ShouldStop(context)) + shouldStop = true; + + if (prev_size == GetSize()) + i++; + prev_size = GetSize(); + } + return shouldStop; } -bool -BreakpointLocationCollection::IsInternal () const -{ - std::lock_guard<std::mutex> guard(m_collection_mutex); - collection::const_iterator pos, - begin = m_break_loc_collection.begin(), - end = m_break_loc_collection.end(); - - bool is_internal = true; - - for (pos = begin; pos != end; ++pos) - { - if (!(*pos)->GetBreakpoint().IsInternal ()) - { - is_internal = false; - break; - } - } - return is_internal; +bool BreakpointLocationCollection::ValidForThisThread(Thread *thread) { + std::lock_guard<std::mutex> guard(m_collection_mutex); + collection::iterator pos, begin = m_break_loc_collection.begin(), + end = m_break_loc_collection.end(); + + for (pos = begin; pos != end; ++pos) { + if ((*pos)->ValidForThisThread(thread)) + return true; + } + return false; } -void -BreakpointLocationCollection::GetDescription (Stream *s, lldb::DescriptionLevel level) -{ - std::lock_guard<std::mutex> guard(m_collection_mutex); - collection::iterator pos, - begin = m_break_loc_collection.begin(), - end = m_break_loc_collection.end(); - - for (pos = begin; pos != end; ++pos) - { - if (pos != begin) - s->PutChar(' '); - (*pos)->GetDescription(s, level); +bool BreakpointLocationCollection::IsInternal() const { + std::lock_guard<std::mutex> guard(m_collection_mutex); + collection::const_iterator pos, begin = m_break_loc_collection.begin(), + end = m_break_loc_collection.end(); + + bool is_internal = true; + + for (pos = begin; pos != end; ++pos) { + if (!(*pos)->GetBreakpoint().IsInternal()) { + is_internal = false; + break; } + } + return is_internal; } +void BreakpointLocationCollection::GetDescription( + Stream *s, lldb::DescriptionLevel level) { + std::lock_guard<std::mutex> guard(m_collection_mutex); + collection::iterator pos, begin = m_break_loc_collection.begin(), + end = m_break_loc_collection.end(); + + for (pos = begin; pos != end; ++pos) { + if (pos != begin) + s->PutChar(' '); + (*pos)->GetDescription(s, level); + } +} diff --git a/lldb/source/Breakpoint/BreakpointLocationList.cpp b/lldb/source/Breakpoint/BreakpointLocationList.cpp index 5e56299bfe7..b4cf0c38e9c 100644 --- a/lldb/source/Breakpoint/BreakpointLocationList.cpp +++ b/lldb/source/Breakpoint/BreakpointLocationList.cpp @@ -13,8 +13,8 @@ // Project includes #include "lldb/Breakpoint/BreakpointLocationList.h" -#include "lldb/Breakpoint/BreakpointLocation.h" #include "lldb/Breakpoint/Breakpoint.h" +#include "lldb/Breakpoint/BreakpointLocation.h" #include "lldb/Core/ArchSpec.h" #include "lldb/Core/Module.h" #include "lldb/Core/Section.h" @@ -25,339 +25,286 @@ using namespace lldb; using namespace lldb_private; BreakpointLocationList::BreakpointLocationList(Breakpoint &owner) - : m_owner(owner), m_locations(), m_address_to_location(), m_mutex(), m_next_id(0), m_new_location_recorder(nullptr) -{ -} + : m_owner(owner), m_locations(), m_address_to_location(), m_mutex(), + m_next_id(0), m_new_location_recorder(nullptr) {} BreakpointLocationList::~BreakpointLocationList() = default; BreakpointLocationSP -BreakpointLocationList::Create (const Address &addr, bool resolve_indirect_symbols) -{ - std::lock_guard<std::recursive_mutex> guard(m_mutex); - // The location ID is just the size of the location list + 1 - lldb::break_id_t bp_loc_id = ++m_next_id; - BreakpointLocationSP bp_loc_sp (new BreakpointLocation (bp_loc_id, m_owner, addr, LLDB_INVALID_THREAD_ID, m_owner.IsHardware(), resolve_indirect_symbols)); - m_locations.push_back (bp_loc_sp); - m_address_to_location[addr] = bp_loc_sp; - return bp_loc_sp; +BreakpointLocationList::Create(const Address &addr, + bool resolve_indirect_symbols) { + std::lock_guard<std::recursive_mutex> guard(m_mutex); + // The location ID is just the size of the location list + 1 + lldb::break_id_t bp_loc_id = ++m_next_id; + BreakpointLocationSP bp_loc_sp( + new BreakpointLocation(bp_loc_id, m_owner, addr, LLDB_INVALID_THREAD_ID, + m_owner.IsHardware(), resolve_indirect_symbols)); + m_locations.push_back(bp_loc_sp); + m_address_to_location[addr] = bp_loc_sp; + return bp_loc_sp; } -bool -BreakpointLocationList::ShouldStop (StoppointCallbackContext *context, lldb::break_id_t break_id) -{ - BreakpointLocationSP bp = FindByID (break_id); - if (bp) - { - // Let the BreakpointLocation decide if it should stop here (could not have - // reached it's target hit count yet, or it could have a callback - // that decided it shouldn't stop (shared library loads/unloads). - return bp->ShouldStop (context); - } - // We should stop here since this BreakpointLocation isn't valid anymore or it - // doesn't exist. - return true; +bool BreakpointLocationList::ShouldStop(StoppointCallbackContext *context, + lldb::break_id_t break_id) { + BreakpointLocationSP bp = FindByID(break_id); + if (bp) { + // Let the BreakpointLocation decide if it should stop here (could not have + // reached it's target hit count yet, or it could have a callback + // that decided it shouldn't stop (shared library loads/unloads). + return bp->ShouldStop(context); + } + // We should stop here since this BreakpointLocation isn't valid anymore or it + // doesn't exist. + return true; } -lldb::break_id_t -BreakpointLocationList::FindIDByAddress (const Address &addr) -{ - BreakpointLocationSP bp_loc_sp = FindByAddress (addr); - if (bp_loc_sp) - { - return bp_loc_sp->GetID(); - } - return LLDB_INVALID_BREAK_ID; +lldb::break_id_t BreakpointLocationList::FindIDByAddress(const Address &addr) { + BreakpointLocationSP bp_loc_sp = FindByAddress(addr); + if (bp_loc_sp) { + return bp_loc_sp->GetID(); + } + return LLDB_INVALID_BREAK_ID; } -static bool -Compare (BreakpointLocationSP lhs, lldb::break_id_t val) -{ - return lhs->GetID() < val; +static bool Compare(BreakpointLocationSP lhs, lldb::break_id_t val) { + return lhs->GetID() < val; } BreakpointLocationSP -BreakpointLocationList::FindByID (lldb::break_id_t break_id) const -{ - std::lock_guard<std::recursive_mutex> guard(m_mutex); - collection::const_iterator end = m_locations.end(); - collection::const_iterator pos = std::lower_bound(m_locations.begin(), end, break_id, Compare); - if (pos != end && (*pos)->GetID() == break_id) - return *(pos); - else - return BreakpointLocationSP(); +BreakpointLocationList::FindByID(lldb::break_id_t break_id) const { + std::lock_guard<std::recursive_mutex> guard(m_mutex); + collection::const_iterator end = m_locations.end(); + collection::const_iterator pos = + std::lower_bound(m_locations.begin(), end, break_id, Compare); + if (pos != end && (*pos)->GetID() == break_id) + return *(pos); + else + return BreakpointLocationSP(); } -size_t -BreakpointLocationList::FindInModule (Module *module, - BreakpointLocationCollection& bp_loc_list) -{ - std::lock_guard<std::recursive_mutex> guard(m_mutex); - const size_t orig_size = bp_loc_list.GetSize(); - collection::iterator pos, end = m_locations.end(); - - for (pos = m_locations.begin(); pos != end; ++pos) - { - BreakpointLocationSP break_loc = (*pos); - SectionSP section_sp (break_loc->GetAddress().GetSection()); - if (section_sp && section_sp->GetModule().get() == module) - { - bp_loc_list.Add (break_loc); - } +size_t BreakpointLocationList::FindInModule( + Module *module, BreakpointLocationCollection &bp_loc_list) { + std::lock_guard<std::recursive_mutex> guard(m_mutex); + const size_t orig_size = bp_loc_list.GetSize(); + collection::iterator pos, end = m_locations.end(); + + for (pos = m_locations.begin(); pos != end; ++pos) { + BreakpointLocationSP break_loc = (*pos); + SectionSP section_sp(break_loc->GetAddress().GetSection()); + if (section_sp && section_sp->GetModule().get() == module) { + bp_loc_list.Add(break_loc); } - return bp_loc_list.GetSize() - orig_size; + } + return bp_loc_list.GetSize() - orig_size; } const BreakpointLocationSP -BreakpointLocationList::FindByAddress (const Address &addr) const -{ - std::lock_guard<std::recursive_mutex> guard(m_mutex); - BreakpointLocationSP bp_loc_sp; - if (!m_locations.empty()) - { - Address so_addr; - - if (addr.IsSectionOffset()) - { - so_addr = addr; - } - else - { - // Try and resolve as a load address if possible. - m_owner.GetTarget().GetSectionLoadList().ResolveLoadAddress (addr.GetOffset(), so_addr); - if (!so_addr.IsValid()) - { - // The address didn't resolve, so just set to passed in addr. - so_addr = addr; - } - } - - addr_map::const_iterator pos = m_address_to_location.find (so_addr); - if (pos != m_address_to_location.end()) - bp_loc_sp = pos->second; +BreakpointLocationList::FindByAddress(const Address &addr) const { + std::lock_guard<std::recursive_mutex> guard(m_mutex); + BreakpointLocationSP bp_loc_sp; + if (!m_locations.empty()) { + Address so_addr; + + if (addr.IsSectionOffset()) { + so_addr = addr; + } else { + // Try and resolve as a load address if possible. + m_owner.GetTarget().GetSectionLoadList().ResolveLoadAddress( + addr.GetOffset(), so_addr); + if (!so_addr.IsValid()) { + // The address didn't resolve, so just set to passed in addr. + so_addr = addr; + } } - return bp_loc_sp; + addr_map::const_iterator pos = m_address_to_location.find(so_addr); + if (pos != m_address_to_location.end()) + bp_loc_sp = pos->second; + } + + return bp_loc_sp; } -void -BreakpointLocationList::Dump (Stream *s) const -{ - s->Printf("%p: ", static_cast<const void*>(this)); - //s->Indent(); - std::lock_guard<std::recursive_mutex> guard(m_mutex); - s->Printf("BreakpointLocationList with %" PRIu64 " BreakpointLocations:\n", (uint64_t)m_locations.size()); - s->IndentMore(); - collection::const_iterator pos, end = m_locations.end(); - for (pos = m_locations.begin(); pos != end; ++pos) - (*pos).get()->Dump(s); - s->IndentLess(); +void BreakpointLocationList::Dump(Stream *s) const { + s->Printf("%p: ", static_cast<const void *>(this)); + // s->Indent(); + std::lock_guard<std::recursive_mutex> guard(m_mutex); + s->Printf("BreakpointLocationList with %" PRIu64 " BreakpointLocations:\n", + (uint64_t)m_locations.size()); + s->IndentMore(); + collection::const_iterator pos, end = m_locations.end(); + for (pos = m_locations.begin(); pos != end; ++pos) + (*pos).get()->Dump(s); + s->IndentLess(); } -BreakpointLocationSP -BreakpointLocationList::GetByIndex (size_t i) -{ - std::lock_guard<std::recursive_mutex> guard(m_mutex); - BreakpointLocationSP bp_loc_sp; - if (i < m_locations.size()) - bp_loc_sp = m_locations[i]; +BreakpointLocationSP BreakpointLocationList::GetByIndex(size_t i) { + std::lock_guard<std::recursive_mutex> guard(m_mutex); + BreakpointLocationSP bp_loc_sp; + if (i < m_locations.size()) + bp_loc_sp = m_locations[i]; - return bp_loc_sp; + return bp_loc_sp; } -const BreakpointLocationSP -BreakpointLocationList::GetByIndex (size_t i) const -{ - std::lock_guard<std::recursive_mutex> guard(m_mutex); - BreakpointLocationSP bp_loc_sp; - if (i < m_locations.size()) - bp_loc_sp = m_locations[i]; +const BreakpointLocationSP BreakpointLocationList::GetByIndex(size_t i) const { + std::lock_guard<std::recursive_mutex> guard(m_mutex); + BreakpointLocationSP bp_loc_sp; + if (i < m_locations.size()) + bp_loc_sp = m_locations[i]; - return bp_loc_sp; + return bp_loc_sp; } -void -BreakpointLocationList::ClearAllBreakpointSites () -{ - std::lock_guard<std::recursive_mutex> guard(m_mutex); - collection::iterator pos, end = m_locations.end(); - for (pos = m_locations.begin(); pos != end; ++pos) - (*pos)->ClearBreakpointSite(); +void BreakpointLocationList::ClearAllBreakpointSites() { + std::lock_guard<std::recursive_mutex> guard(m_mutex); + collection::iterator pos, end = m_locations.end(); + for (pos = m_locations.begin(); pos != end; ++pos) + (*pos)->ClearBreakpointSite(); } -void -BreakpointLocationList::ResolveAllBreakpointSites () -{ - std::lock_guard<std::recursive_mutex> guard(m_mutex); - collection::iterator pos, end = m_locations.end(); +void BreakpointLocationList::ResolveAllBreakpointSites() { + std::lock_guard<std::recursive_mutex> guard(m_mutex); + collection::iterator pos, end = m_locations.end(); - for (pos = m_locations.begin(); pos != end; ++pos) - { - if ((*pos)->IsEnabled()) - (*pos)->ResolveBreakpointSite(); - } + for (pos = m_locations.begin(); pos != end; ++pos) { + if ((*pos)->IsEnabled()) + (*pos)->ResolveBreakpointSite(); + } } -uint32_t -BreakpointLocationList::GetHitCount () const -{ - uint32_t hit_count = 0; - std::lock_guard<std::recursive_mutex> guard(m_mutex); - collection::const_iterator pos, end = m_locations.end(); - for (pos = m_locations.begin(); pos != end; ++pos) - hit_count += (*pos)->GetHitCount(); - return hit_count; +uint32_t BreakpointLocationList::GetHitCount() const { + uint32_t hit_count = 0; + std::lock_guard<std::recursive_mutex> guard(m_mutex); + collection::const_iterator pos, end = m_locations.end(); + for (pos = m_locations.begin(); pos != end; ++pos) + hit_count += (*pos)->GetHitCount(); + return hit_count; } -size_t -BreakpointLocationList::GetNumResolvedLocations() const -{ - std::lock_guard<std::recursive_mutex> guard(m_mutex); - size_t resolve_count = 0; - collection::const_iterator pos, end = m_locations.end(); - for (pos = m_locations.begin(); pos != end; ++pos) - { - if ((*pos)->IsResolved()) - ++resolve_count; - } - return resolve_count; +size_t BreakpointLocationList::GetNumResolvedLocations() const { + std::lock_guard<std::recursive_mutex> guard(m_mutex); + size_t resolve_count = 0; + collection::const_iterator pos, end = m_locations.end(); + for (pos = m_locations.begin(); pos != end; ++pos) { + if ((*pos)->IsResolved()) + ++resolve_count; + } + return resolve_count; } -void -BreakpointLocationList::GetDescription (Stream *s, lldb::DescriptionLevel level) -{ - std::lock_guard<std::recursive_mutex> guard(m_mutex); - collection::iterator pos, end = m_locations.end(); +void BreakpointLocationList::GetDescription(Stream *s, + lldb::DescriptionLevel level) { + std::lock_guard<std::recursive_mutex> guard(m_mutex); + collection::iterator pos, end = m_locations.end(); - for (pos = m_locations.begin(); pos != end; ++pos) - { - s->Printf(" "); - (*pos)->GetDescription(s, level); - } + for (pos = m_locations.begin(); pos != end; ++pos) { + s->Printf(" "); + (*pos)->GetDescription(s, level); + } } -BreakpointLocationSP -BreakpointLocationList::AddLocation (const Address &addr, bool resolve_indirect_symbols, bool *new_location) -{ - std::lock_guard<std::recursive_mutex> guard(m_mutex); - - if (new_location) - *new_location = false; - BreakpointLocationSP bp_loc_sp (FindByAddress(addr)); - if (!bp_loc_sp) - { - bp_loc_sp = Create (addr, resolve_indirect_symbols); - if (bp_loc_sp) - { - bp_loc_sp->ResolveBreakpointSite(); - - if (new_location) - *new_location = true; - if(m_new_location_recorder) - { - m_new_location_recorder->Add(bp_loc_sp); - } - } - } - return bp_loc_sp; +BreakpointLocationSP BreakpointLocationList::AddLocation( + const Address &addr, bool resolve_indirect_symbols, bool *new_location) { + std::lock_guard<std::recursive_mutex> guard(m_mutex); + + if (new_location) + *new_location = false; + BreakpointLocationSP bp_loc_sp(FindByAddress(addr)); + if (!bp_loc_sp) { + bp_loc_sp = Create(addr, resolve_indirect_symbols); + if (bp_loc_sp) { + bp_loc_sp->ResolveBreakpointSite(); + + if (new_location) + *new_location = true; + if (m_new_location_recorder) { + m_new_location_recorder->Add(bp_loc_sp); + } + } + } + return bp_loc_sp; } -void -BreakpointLocationList::SwapLocation (BreakpointLocationSP to_location_sp, BreakpointLocationSP from_location_sp) -{ - if (!from_location_sp || !to_location_sp) - return; - - m_address_to_location.erase(to_location_sp->GetAddress()); - to_location_sp->SwapLocation(from_location_sp); - RemoveLocation(from_location_sp); - m_address_to_location[to_location_sp->GetAddress()] = to_location_sp; - to_location_sp->ResolveBreakpointSite(); +void BreakpointLocationList::SwapLocation( + BreakpointLocationSP to_location_sp, + BreakpointLocationSP from_location_sp) { + if (!from_location_sp || !to_location_sp) + return; + + m_address_to_location.erase(to_location_sp->GetAddress()); + to_location_sp->SwapLocation(from_location_sp); + RemoveLocation(from_location_sp); + m_address_to_location[to_location_sp->GetAddress()] = to_location_sp; + to_location_sp->ResolveBreakpointSite(); } -bool -BreakpointLocationList::RemoveLocation (const lldb::BreakpointLocationSP &bp_loc_sp) -{ - if (bp_loc_sp) - { - std::lock_guard<std::recursive_mutex> guard(m_mutex); - - m_address_to_location.erase (bp_loc_sp->GetAddress()); - - collection::iterator pos, end = m_locations.end(); - for (pos = m_locations.begin(); pos != end; ++pos) - { - if ((*pos).get() == bp_loc_sp.get()) - { - m_locations.erase (pos); - return true; - } - } +bool BreakpointLocationList::RemoveLocation( + const lldb::BreakpointLocationSP &bp_loc_sp) { + if (bp_loc_sp) { + std::lock_guard<std::recursive_mutex> guard(m_mutex); + + m_address_to_location.erase(bp_loc_sp->GetAddress()); + + collection::iterator pos, end = m_locations.end(); + for (pos = m_locations.begin(); pos != end; ++pos) { + if ((*pos).get() == bp_loc_sp.get()) { + m_locations.erase(pos); + return true; + } } - return false; + } + return false; } -void -BreakpointLocationList::RemoveInvalidLocations (const ArchSpec &arch) -{ - std::lock_guard<std::recursive_mutex> guard(m_mutex); - size_t idx = 0; - // Don't cache m_location.size() as it will change since we might - // remove locations from our vector... - while (idx < m_locations.size()) - { - BreakpointLocation *bp_loc = m_locations[idx].get(); - if (bp_loc->GetAddress().SectionWasDeleted()) - { - // Section was deleted which means this breakpoint comes from a module - // that is no longer valid, so we should remove it. - m_locations.erase(m_locations.begin() + idx); - continue; - } - if (arch.IsValid()) - { - ModuleSP module_sp (bp_loc->GetAddress().GetModule()); - if (module_sp) - { - if (!arch.IsCompatibleMatch(module_sp->GetArchitecture())) - { - // The breakpoint was in a module whose architecture is no longer - // compatible with "arch", so we need to remove it - m_locations.erase(m_locations.begin() + idx); - continue; - } - } +void BreakpointLocationList::RemoveInvalidLocations(const ArchSpec &arch) { + std::lock_guard<std::recursive_mutex> guard(m_mutex); + size_t idx = 0; + // Don't cache m_location.size() as it will change since we might + // remove locations from our vector... + while (idx < m_locations.size()) { + BreakpointLocation *bp_loc = m_locations[idx].get(); + if (bp_loc->GetAddress().SectionWasDeleted()) { + // Section was deleted which means this breakpoint comes from a module + // that is no longer valid, so we should remove it. + m_locations.erase(m_locations.begin() + idx); + continue; + } + if (arch.IsValid()) { + ModuleSP module_sp(bp_loc->GetAddress().GetModule()); + if (module_sp) { + if (!arch.IsCompatibleMatch(module_sp->GetArchitecture())) { + // The breakpoint was in a module whose architecture is no longer + // compatible with "arch", so we need to remove it + m_locations.erase(m_locations.begin() + idx); + continue; } - // Only increment the index if we didn't remove the locations at index "idx" - ++idx; + } } + // Only increment the index if we didn't remove the locations at index "idx" + ++idx; + } } -void -BreakpointLocationList::StartRecordingNewLocations (BreakpointLocationCollection &new_locations) -{ - std::lock_guard<std::recursive_mutex> guard(m_mutex); - assert(m_new_location_recorder == nullptr); - m_new_location_recorder = &new_locations; +void BreakpointLocationList::StartRecordingNewLocations( + BreakpointLocationCollection &new_locations) { + std::lock_guard<std::recursive_mutex> guard(m_mutex); + assert(m_new_location_recorder == nullptr); + m_new_location_recorder = &new_locations; } -void -BreakpointLocationList::StopRecordingNewLocations () -{ - std::lock_guard<std::recursive_mutex> guard(m_mutex); - m_new_location_recorder = nullptr; +void BreakpointLocationList::StopRecordingNewLocations() { + std::lock_guard<std::recursive_mutex> guard(m_mutex); + m_new_location_recorder = nullptr; } -void -BreakpointLocationList::Compact() -{ - lldb::break_id_t highest_id = 0; - - for (BreakpointLocationSP loc_sp : m_locations) - { - lldb::break_id_t cur_id = loc_sp->GetID(); - if (cur_id > highest_id) - highest_id = cur_id; - } - m_next_id = highest_id; +void BreakpointLocationList::Compact() { + lldb::break_id_t highest_id = 0; + + for (BreakpointLocationSP loc_sp : m_locations) { + lldb::break_id_t cur_id = loc_sp->GetID(); + if (cur_id > highest_id) + highest_id = cur_id; + } + m_next_id = highest_id; } diff --git a/lldb/source/Breakpoint/BreakpointOptions.cpp b/lldb/source/Breakpoint/BreakpointOptions.cpp index d2a91975685..bb43e3a9b86 100644 --- a/lldb/source/Breakpoint/BreakpointOptions.cpp +++ b/lldb/source/Breakpoint/BreakpointOptions.cpp @@ -13,10 +13,10 @@ // Project includes #include "lldb/Breakpoint/BreakpointOptions.h" +#include "lldb/Breakpoint/StoppointCallbackContext.h" #include "lldb/Core/Stream.h" #include "lldb/Core/StringList.h" #include "lldb/Core/Value.h" -#include "lldb/Breakpoint/StoppointCallbackContext.h" #include "lldb/Target/Process.h" #include "lldb/Target/Target.h" #include "lldb/Target/ThreadSpec.h" @@ -24,78 +24,66 @@ using namespace lldb; using namespace lldb_private; -bool -BreakpointOptions::NullCallback (void *baton, StoppointCallbackContext *context, lldb::user_id_t break_id, lldb::user_id_t break_loc_id) -{ - return true; +bool BreakpointOptions::NullCallback(void *baton, + StoppointCallbackContext *context, + lldb::user_id_t break_id, + lldb::user_id_t break_loc_id) { + return true; } //---------------------------------------------------------------------- // BreakpointOptions constructor //---------------------------------------------------------------------- -BreakpointOptions::BreakpointOptions() : - m_callback (BreakpointOptions::NullCallback), - m_callback_baton_sp (), - m_callback_is_synchronous (false), - m_enabled (true), - m_one_shot (false), - m_ignore_count (0), - m_thread_spec_ap (), - m_condition_text (), - m_condition_text_hash (0) -{ -} +BreakpointOptions::BreakpointOptions() + : m_callback(BreakpointOptions::NullCallback), m_callback_baton_sp(), + m_callback_is_synchronous(false), m_enabled(true), m_one_shot(false), + m_ignore_count(0), m_thread_spec_ap(), m_condition_text(), + m_condition_text_hash(0) {} //---------------------------------------------------------------------- // BreakpointOptions copy constructor //---------------------------------------------------------------------- -BreakpointOptions::BreakpointOptions(const BreakpointOptions& rhs) : - m_callback (rhs.m_callback), - m_callback_baton_sp (rhs.m_callback_baton_sp), - m_callback_is_synchronous (rhs.m_callback_is_synchronous), - m_enabled (rhs.m_enabled), - m_one_shot (rhs.m_one_shot), - m_ignore_count (rhs.m_ignore_count), - m_thread_spec_ap () -{ - if (rhs.m_thread_spec_ap.get() != nullptr) - m_thread_spec_ap.reset (new ThreadSpec(*rhs.m_thread_spec_ap.get())); - m_condition_text = rhs.m_condition_text; - m_condition_text_hash = rhs.m_condition_text_hash; +BreakpointOptions::BreakpointOptions(const BreakpointOptions &rhs) + : m_callback(rhs.m_callback), m_callback_baton_sp(rhs.m_callback_baton_sp), + m_callback_is_synchronous(rhs.m_callback_is_synchronous), + m_enabled(rhs.m_enabled), m_one_shot(rhs.m_one_shot), + m_ignore_count(rhs.m_ignore_count), m_thread_spec_ap() { + if (rhs.m_thread_spec_ap.get() != nullptr) + m_thread_spec_ap.reset(new ThreadSpec(*rhs.m_thread_spec_ap.get())); + m_condition_text = rhs.m_condition_text; + m_condition_text_hash = rhs.m_condition_text_hash; } //---------------------------------------------------------------------- // BreakpointOptions assignment operator //---------------------------------------------------------------------- -const BreakpointOptions& -BreakpointOptions::operator=(const BreakpointOptions& rhs) -{ - m_callback = rhs.m_callback; - m_callback_baton_sp = rhs.m_callback_baton_sp; - m_callback_is_synchronous = rhs.m_callback_is_synchronous; - m_enabled = rhs.m_enabled; - m_one_shot = rhs.m_one_shot; - m_ignore_count = rhs.m_ignore_count; - if (rhs.m_thread_spec_ap.get() != nullptr) - m_thread_spec_ap.reset(new ThreadSpec(*rhs.m_thread_spec_ap.get())); - m_condition_text = rhs.m_condition_text; - m_condition_text_hash = rhs.m_condition_text_hash; - return *this; +const BreakpointOptions &BreakpointOptions:: +operator=(const BreakpointOptions &rhs) { + m_callback = rhs.m_callback; + m_callback_baton_sp = rhs.m_callback_baton_sp; + m_callback_is_synchronous = rhs.m_callback_is_synchronous; + m_enabled = rhs.m_enabled; + m_one_shot = rhs.m_one_shot; + m_ignore_count = rhs.m_ignore_count; + if (rhs.m_thread_spec_ap.get() != nullptr) + m_thread_spec_ap.reset(new ThreadSpec(*rhs.m_thread_spec_ap.get())); + m_condition_text = rhs.m_condition_text; + m_condition_text_hash = rhs.m_condition_text_hash; + return *this; } BreakpointOptions * -BreakpointOptions::CopyOptionsNoCallback (BreakpointOptions &orig) -{ - BreakpointHitCallback orig_callback = orig.m_callback; - lldb::BatonSP orig_callback_baton_sp = orig.m_callback_baton_sp; - bool orig_is_sync = orig.m_callback_is_synchronous; - - orig.ClearCallback(); - BreakpointOptions *ret_val = new BreakpointOptions(orig); - - orig.SetCallback (orig_callback, orig_callback_baton_sp, orig_is_sync); - - return ret_val; +BreakpointOptions::CopyOptionsNoCallback(BreakpointOptions &orig) { + BreakpointHitCallback orig_callback = orig.m_callback; + lldb::BatonSP orig_callback_baton_sp = orig.m_callback_baton_sp; + bool orig_is_sync = orig.m_callback_is_synchronous; + + orig.ClearCallback(); + BreakpointOptions *ret_val = new BreakpointOptions(orig); + + orig.SetCallback(orig_callback, orig_callback_baton_sp, orig_is_sync); + + return ret_val; } //---------------------------------------------------------------------- @@ -106,187 +94,148 @@ BreakpointOptions::~BreakpointOptions() = default; //------------------------------------------------------------------ // Callbacks //------------------------------------------------------------------ -void -BreakpointOptions::SetCallback (BreakpointHitCallback callback, const BatonSP &callback_baton_sp, bool callback_is_synchronous) -{ - m_callback_is_synchronous = callback_is_synchronous; - m_callback = callback; - m_callback_baton_sp = callback_baton_sp; +void BreakpointOptions::SetCallback(BreakpointHitCallback callback, + const BatonSP &callback_baton_sp, + bool callback_is_synchronous) { + m_callback_is_synchronous = callback_is_synchronous; + m_callback = callback; + m_callback_baton_sp = callback_baton_sp; } -void -BreakpointOptions::ClearCallback () -{ - m_callback = BreakpointOptions::NullCallback; - m_callback_is_synchronous = false; - m_callback_baton_sp.reset(); +void BreakpointOptions::ClearCallback() { + m_callback = BreakpointOptions::NullCallback; + m_callback_is_synchronous = false; + m_callback_baton_sp.reset(); } -Baton * -BreakpointOptions::GetBaton () -{ - return m_callback_baton_sp.get(); -} +Baton *BreakpointOptions::GetBaton() { return m_callback_baton_sp.get(); } -const Baton * -BreakpointOptions::GetBaton () const -{ - return m_callback_baton_sp.get(); +const Baton *BreakpointOptions::GetBaton() const { + return m_callback_baton_sp.get(); } -bool -BreakpointOptions::InvokeCallback (StoppointCallbackContext *context, - lldb::user_id_t break_id, - lldb::user_id_t break_loc_id) -{ - if (m_callback && context->is_synchronous == IsCallbackSynchronous()) - { - return m_callback(m_callback_baton_sp ? m_callback_baton_sp->m_data : nullptr, - context, - break_id, - break_loc_id); - } - else - return true; +bool BreakpointOptions::InvokeCallback(StoppointCallbackContext *context, + lldb::user_id_t break_id, + lldb::user_id_t break_loc_id) { + if (m_callback && context->is_synchronous == IsCallbackSynchronous()) { + return m_callback(m_callback_baton_sp ? m_callback_baton_sp->m_data + : nullptr, + context, break_id, break_loc_id); + } else + return true; } -bool -BreakpointOptions::HasCallback () const -{ - return m_callback != BreakpointOptions::NullCallback; +bool BreakpointOptions::HasCallback() const { + return m_callback != BreakpointOptions::NullCallback; } -void -BreakpointOptions::SetCondition (const char *condition) -{ - if (!condition) - condition = ""; - - m_condition_text.assign(condition); - std::hash<std::string> hasher; - m_condition_text_hash = hasher(m_condition_text); +void BreakpointOptions::SetCondition(const char *condition) { + if (!condition) + condition = ""; + + m_condition_text.assign(condition); + std::hash<std::string> hasher; + m_condition_text_hash = hasher(m_condition_text); } -const char * -BreakpointOptions::GetConditionText (size_t *hash) const -{ - if (!m_condition_text.empty()) - { - if (hash) - *hash = m_condition_text_hash; - - return m_condition_text.c_str(); - } - else - { - return nullptr; - } +const char *BreakpointOptions::GetConditionText(size_t *hash) const { + if (!m_condition_text.empty()) { + if (hash) + *hash = m_condition_text_hash; + + return m_condition_text.c_str(); + } else { + return nullptr; + } } -const ThreadSpec * -BreakpointOptions::GetThreadSpecNoCreate () const -{ - return m_thread_spec_ap.get(); +const ThreadSpec *BreakpointOptions::GetThreadSpecNoCreate() const { + return m_thread_spec_ap.get(); } -ThreadSpec * -BreakpointOptions::GetThreadSpec () -{ - if (m_thread_spec_ap.get() == nullptr) - m_thread_spec_ap.reset (new ThreadSpec()); - - return m_thread_spec_ap.get(); +ThreadSpec *BreakpointOptions::GetThreadSpec() { + if (m_thread_spec_ap.get() == nullptr) + m_thread_spec_ap.reset(new ThreadSpec()); + + return m_thread_spec_ap.get(); } -void -BreakpointOptions::SetThreadID (lldb::tid_t thread_id) -{ - GetThreadSpec()->SetTID(thread_id); +void BreakpointOptions::SetThreadID(lldb::tid_t thread_id) { + GetThreadSpec()->SetTID(thread_id); } -void -BreakpointOptions::GetDescription (Stream *s, lldb::DescriptionLevel level) const -{ - // Figure out if there are any options not at their default value, and only print - // anything if there are: - - if (m_ignore_count != 0 || !m_enabled || m_one_shot || (GetThreadSpecNoCreate() != nullptr && GetThreadSpecNoCreate()->HasSpecification ())) - { - if (level == lldb::eDescriptionLevelVerbose) - { - s->EOL (); - s->IndentMore(); - s->Indent(); - s->PutCString("Breakpoint Options:\n"); - s->IndentMore(); - s->Indent(); - } - else - s->PutCString(" Options: "); - - if (m_ignore_count > 0) - s->Printf("ignore: %d ", m_ignore_count); - s->Printf("%sabled ", m_enabled ? "en" : "dis"); - - if (m_one_shot) - s->Printf ("one-shot "); - - if (m_thread_spec_ap.get()) - m_thread_spec_ap->GetDescription (s, level); - - if (level == lldb::eDescriptionLevelFull) - { - s->IndentLess(); - s->IndentMore(); - } +void BreakpointOptions::GetDescription(Stream *s, + lldb::DescriptionLevel level) const { + // Figure out if there are any options not at their default value, and only + // print + // anything if there are: + + if (m_ignore_count != 0 || !m_enabled || m_one_shot || + (GetThreadSpecNoCreate() != nullptr && + GetThreadSpecNoCreate()->HasSpecification())) { + if (level == lldb::eDescriptionLevelVerbose) { + s->EOL(); + s->IndentMore(); + s->Indent(); + s->PutCString("Breakpoint Options:\n"); + s->IndentMore(); + s->Indent(); + } else + s->PutCString(" Options: "); + + if (m_ignore_count > 0) + s->Printf("ignore: %d ", m_ignore_count); + s->Printf("%sabled ", m_enabled ? "en" : "dis"); + + if (m_one_shot) + s->Printf("one-shot "); + + if (m_thread_spec_ap.get()) + m_thread_spec_ap->GetDescription(s, level); + + if (level == lldb::eDescriptionLevelFull) { + s->IndentLess(); + s->IndentMore(); } - - if (m_callback_baton_sp.get()) - { - if (level != eDescriptionLevelBrief) - { - s->EOL(); - m_callback_baton_sp->GetDescription (s, level); - } + } + + if (m_callback_baton_sp.get()) { + if (level != eDescriptionLevelBrief) { + s->EOL(); + m_callback_baton_sp->GetDescription(s, level); + } + } + if (!m_condition_text.empty()) { + if (level != eDescriptionLevelBrief) { + s->EOL(); + s->Printf("Condition: %s\n", m_condition_text.c_str()); } - if (!m_condition_text.empty()) - { - if (level != eDescriptionLevelBrief) - { - s->EOL(); - s->Printf("Condition: %s\n", m_condition_text.c_str()); - } - } + } } -void -BreakpointOptions::CommandBaton::GetDescription (Stream *s, lldb::DescriptionLevel level) const -{ - CommandData *data = (CommandData *)m_data; +void BreakpointOptions::CommandBaton::GetDescription( + Stream *s, lldb::DescriptionLevel level) const { + CommandData *data = (CommandData *)m_data; - if (level == eDescriptionLevelBrief) - { - s->Printf (", commands = %s", (data && data->user_source.GetSize() > 0) ? "yes" : "no"); - return; - } - - s->IndentMore (); - s->Indent("Breakpoint commands:\n"); - - s->IndentMore (); - if (data && data->user_source.GetSize() > 0) - { - const size_t num_strings = data->user_source.GetSize(); - for (size_t i = 0; i < num_strings; ++i) - { - s->Indent(data->user_source.GetStringAtIndex(i)); - s->EOL(); - } - } - else - { - s->PutCString ("No commands.\n"); + if (level == eDescriptionLevelBrief) { + s->Printf(", commands = %s", + (data && data->user_source.GetSize() > 0) ? "yes" : "no"); + return; + } + + s->IndentMore(); + s->Indent("Breakpoint commands:\n"); + + s->IndentMore(); + if (data && data->user_source.GetSize() > 0) { + const size_t num_strings = data->user_source.GetSize(); + for (size_t i = 0; i < num_strings; ++i) { + s->Indent(data->user_source.GetStringAtIndex(i)); + s->EOL(); } - s->IndentLess (); - s->IndentLess (); + } else { + s->PutCString("No commands.\n"); + } + s->IndentLess(); + s->IndentLess(); } diff --git a/lldb/source/Breakpoint/BreakpointResolver.cpp b/lldb/source/Breakpoint/BreakpointResolver.cpp index e757b388550..ee6e4c8fbbe 100644 --- a/lldb/source/Breakpoint/BreakpointResolver.cpp +++ b/lldb/source/Breakpoint/BreakpointResolver.cpp @@ -13,18 +13,18 @@ // C++ Includes // Other libraries and framework includes // Project includes -#include "lldb/Core/Address.h" #include "lldb/Breakpoint/Breakpoint.h" #include "lldb/Breakpoint/BreakpointLocation.h" +#include "lldb/Core/Address.h" #include "lldb/Core/Log.h" #include "lldb/Core/ModuleList.h" #include "lldb/Core/SearchFilter.h" #include "lldb/Core/Stream.h" #include "lldb/Core/StreamString.h" -#include "lldb/Symbol/SymbolContext.h" -#include "lldb/Target/Target.h" #include "lldb/Symbol/CompileUnit.h" #include "lldb/Symbol/Function.h" +#include "lldb/Symbol/SymbolContext.h" +#include "lldb/Target/Target.h" using namespace lldb_private; using namespace lldb; @@ -32,196 +32,169 @@ using namespace lldb; //---------------------------------------------------------------------- // BreakpointResolver: //---------------------------------------------------------------------- -BreakpointResolver::BreakpointResolver (Breakpoint *bkpt, const unsigned char resolverTy, lldb::addr_t offset) : - m_breakpoint (bkpt), - m_offset(offset), - SubclassID (resolverTy) -{ -} +BreakpointResolver::BreakpointResolver(Breakpoint *bkpt, + const unsigned char resolverTy, + lldb::addr_t offset) + : m_breakpoint(bkpt), m_offset(offset), SubclassID(resolverTy) {} -BreakpointResolver::~BreakpointResolver () -{ +BreakpointResolver::~BreakpointResolver() {} +void BreakpointResolver::SetBreakpoint(Breakpoint *bkpt) { + m_breakpoint = bkpt; } -void -BreakpointResolver::SetBreakpoint (Breakpoint *bkpt) -{ - m_breakpoint = bkpt; +void BreakpointResolver::ResolveBreakpointInModules(SearchFilter &filter, + ModuleList &modules) { + filter.SearchInModuleList(*this, modules); } -void -BreakpointResolver::ResolveBreakpointInModules (SearchFilter &filter, ModuleList &modules) -{ - filter.SearchInModuleList(*this, modules); +void BreakpointResolver::ResolveBreakpoint(SearchFilter &filter) { + filter.Search(*this); } -void -BreakpointResolver::ResolveBreakpoint (SearchFilter &filter) -{ - filter.Search (*this); -} +void BreakpointResolver::SetSCMatchesByLine(SearchFilter &filter, + SymbolContextList &sc_list, + bool skip_prologue, + const char *log_ident) { + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_BREAKPOINTS)); + + while (sc_list.GetSize() > 0) { + SymbolContextList tmp_sc_list; + unsigned current_idx = 0; + SymbolContext sc; + bool first_entry = true; + + FileSpec match_file_spec; + FileSpec match_original_file_spec; + uint32_t closest_line_number = UINT32_MAX; + + // Pull out the first entry, and all the others that match its file spec, + // and stuff them in the tmp list. + while (current_idx < sc_list.GetSize()) { + bool matches; + + sc_list.GetContextAtIndex(current_idx, sc); + if (first_entry) { + match_file_spec = sc.line_entry.file; + match_original_file_spec = sc.line_entry.original_file; + matches = true; + first_entry = false; + } else + matches = ((sc.line_entry.file == match_file_spec) || + (sc.line_entry.original_file == match_original_file_spec)); + + if (matches) { + tmp_sc_list.Append(sc); + sc_list.RemoveContextAtIndex(current_idx); + + // ResolveSymbolContext will always return a number that is >= the line + // number you pass in. + // So the smaller line number is always better. + if (sc.line_entry.line < closest_line_number) + closest_line_number = sc.line_entry.line; + } else + current_idx++; + } -void -BreakpointResolver::SetSCMatchesByLine (SearchFilter &filter, SymbolContextList &sc_list, bool skip_prologue, const char *log_ident) -{ - Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_BREAKPOINTS)); - - while (sc_list.GetSize() > 0) - { - SymbolContextList tmp_sc_list; - unsigned current_idx = 0; - SymbolContext sc; - bool first_entry = true; - - FileSpec match_file_spec; - FileSpec match_original_file_spec; - uint32_t closest_line_number = UINT32_MAX; - - // Pull out the first entry, and all the others that match its file spec, and stuff them in the tmp list. - while (current_idx < sc_list.GetSize()) - { - bool matches; - - sc_list.GetContextAtIndex (current_idx, sc); - if (first_entry) - { - match_file_spec = sc.line_entry.file; - match_original_file_spec = sc.line_entry.original_file; - matches = true; - first_entry = false; - } - else - matches = ((sc.line_entry.file == match_file_spec) || - (sc.line_entry.original_file == match_original_file_spec)); - - if (matches) - { - tmp_sc_list.Append (sc); - sc_list.RemoveContextAtIndex(current_idx); - - // ResolveSymbolContext will always return a number that is >= the line number you pass in. - // So the smaller line number is always better. - if (sc.line_entry.line < closest_line_number) - closest_line_number = sc.line_entry.line; - } - else - current_idx++; - } - - // Okay, we've found the closest line number match, now throw away all the others: - - current_idx = 0; - while (current_idx < tmp_sc_list.GetSize()) - { - if (tmp_sc_list.GetContextAtIndex(current_idx, sc)) - { - if (sc.line_entry.line != closest_line_number) - tmp_sc_list.RemoveContextAtIndex(current_idx); - else - current_idx++; - } - } - - // Next go through and see if there are line table entries that are contiguous, and if so keep only the - // first of the contiguous range: - - current_idx = 0; - std::map<Block *, lldb::addr_t> blocks_with_breakpoints; - - while (current_idx < tmp_sc_list.GetSize()) - { - if (tmp_sc_list.GetContextAtIndex(current_idx, sc)) - { - if (blocks_with_breakpoints.find (sc.block) != blocks_with_breakpoints.end()) - tmp_sc_list.RemoveContextAtIndex(current_idx); - else - { - blocks_with_breakpoints.insert (std::pair<Block *, lldb::addr_t>(sc.block, sc.line_entry.range.GetBaseAddress().GetFileAddress())); - current_idx++; - } - } + // Okay, we've found the closest line number match, now throw away all the + // others: + + current_idx = 0; + while (current_idx < tmp_sc_list.GetSize()) { + if (tmp_sc_list.GetContextAtIndex(current_idx, sc)) { + if (sc.line_entry.line != closest_line_number) + tmp_sc_list.RemoveContextAtIndex(current_idx); + else + current_idx++; + } + } + + // Next go through and see if there are line table entries that are + // contiguous, and if so keep only the + // first of the contiguous range: + + current_idx = 0; + std::map<Block *, lldb::addr_t> blocks_with_breakpoints; + + while (current_idx < tmp_sc_list.GetSize()) { + if (tmp_sc_list.GetContextAtIndex(current_idx, sc)) { + if (blocks_with_breakpoints.find(sc.block) != + blocks_with_breakpoints.end()) + tmp_sc_list.RemoveContextAtIndex(current_idx); + else { + blocks_with_breakpoints.insert(std::pair<Block *, lldb::addr_t>( + sc.block, sc.line_entry.range.GetBaseAddress().GetFileAddress())); + current_idx++; } - - // and make breakpoints out of the closest line number match. - - uint32_t tmp_sc_list_size = tmp_sc_list.GetSize(); - - for (uint32_t i = 0; i < tmp_sc_list_size; i++) - { - if (tmp_sc_list.GetContextAtIndex(i, sc)) - { - Address line_start = sc.line_entry.range.GetBaseAddress(); - if (line_start.IsValid()) - { - if (filter.AddressPasses(line_start)) - { - // If the line number is before the prologue end, move it there... - bool skipped_prologue = false; - if (skip_prologue) - { - if (sc.function) - { - Address prologue_addr(sc.function->GetAddressRange().GetBaseAddress()); - if (prologue_addr.IsValid() && (line_start == prologue_addr)) - { - const uint32_t prologue_byte_size = sc.function->GetPrologueByteSize(); - if (prologue_byte_size) - { - prologue_addr.Slide(prologue_byte_size); - - if (filter.AddressPasses(prologue_addr)) - { - skipped_prologue = true; - line_start = prologue_addr; - } - } - } - } - } - - BreakpointLocationSP bp_loc_sp (AddLocation(line_start)); - if (log && bp_loc_sp && !m_breakpoint->IsInternal()) - { - StreamString s; - bp_loc_sp->GetDescription (&s, lldb::eDescriptionLevelVerbose); - log->Printf ("Added location (skipped prologue: %s): %s \n", skipped_prologue ? "yes" : "no", s.GetData()); - } - } - else if (log) - { - log->Printf ("Breakpoint %s at file address 0x%" PRIx64 " didn't pass the filter.\n", - log_ident ? log_ident : "", - line_start.GetFileAddress()); + } + } + + // and make breakpoints out of the closest line number match. + + uint32_t tmp_sc_list_size = tmp_sc_list.GetSize(); + + for (uint32_t i = 0; i < tmp_sc_list_size; i++) { + if (tmp_sc_list.GetContextAtIndex(i, sc)) { + Address line_start = sc.line_entry.range.GetBaseAddress(); + if (line_start.IsValid()) { + if (filter.AddressPasses(line_start)) { + // If the line number is before the prologue end, move it there... + bool skipped_prologue = false; + if (skip_prologue) { + if (sc.function) { + Address prologue_addr( + sc.function->GetAddressRange().GetBaseAddress()); + if (prologue_addr.IsValid() && (line_start == prologue_addr)) { + const uint32_t prologue_byte_size = + sc.function->GetPrologueByteSize(); + if (prologue_byte_size) { + prologue_addr.Slide(prologue_byte_size); + + if (filter.AddressPasses(prologue_addr)) { + skipped_prologue = true; + line_start = prologue_addr; } + } } - else - { - if (log) - log->Printf ("error: Unable to set breakpoint %s at file address 0x%" PRIx64 "\n", - log_ident ? log_ident : "", - line_start.GetFileAddress()); - } + } } + + BreakpointLocationSP bp_loc_sp(AddLocation(line_start)); + if (log && bp_loc_sp && !m_breakpoint->IsInternal()) { + StreamString s; + bp_loc_sp->GetDescription(&s, lldb::eDescriptionLevelVerbose); + log->Printf("Added location (skipped prologue: %s): %s \n", + skipped_prologue ? "yes" : "no", s.GetData()); + } + } else if (log) { + log->Printf("Breakpoint %s at file address 0x%" PRIx64 + " didn't pass the filter.\n", + log_ident ? log_ident : "", + line_start.GetFileAddress()); + } + } else { + if (log) + log->Printf( + "error: Unable to set breakpoint %s at file address 0x%" PRIx64 + "\n", + log_ident ? log_ident : "", line_start.GetFileAddress()); } + } } + } } -BreakpointLocationSP -BreakpointResolver::AddLocation(Address loc_addr, bool *new_location) -{ - loc_addr.Slide(m_offset); - return m_breakpoint->AddLocation(loc_addr, new_location); +BreakpointLocationSP BreakpointResolver::AddLocation(Address loc_addr, + bool *new_location) { + loc_addr.Slide(m_offset); + return m_breakpoint->AddLocation(loc_addr, new_location); } - -void -BreakpointResolver::SetOffset (lldb::addr_t offset) -{ - // There may already be an offset, so we are actually adjusting location addresses by the difference. - // lldb::addr_t slide = offset - m_offset; - // FIXME: We should go fix up all the already set locations for the new slide. +void BreakpointResolver::SetOffset(lldb::addr_t offset) { + // There may already be an offset, so we are actually adjusting location + // addresses by the difference. + // lldb::addr_t slide = offset - m_offset; + // FIXME: We should go fix up all the already set locations for the new slide. - m_offset = offset; + m_offset = offset; } - diff --git a/lldb/source/Breakpoint/BreakpointResolverAddress.cpp b/lldb/source/Breakpoint/BreakpointResolverAddress.cpp index 14942014d80..e52ec9ca9de 100644 --- a/lldb/source/Breakpoint/BreakpointResolverAddress.cpp +++ b/lldb/source/Breakpoint/BreakpointResolverAddress.cpp @@ -27,149 +27,111 @@ using namespace lldb_private; //---------------------------------------------------------------------- // BreakpointResolverAddress: //---------------------------------------------------------------------- -BreakpointResolverAddress::BreakpointResolverAddress -( - Breakpoint *bkpt, - const Address &addr, - const FileSpec &module_spec -) : - BreakpointResolver (bkpt, BreakpointResolver::AddressResolver), - m_addr (addr), - m_resolved_addr(LLDB_INVALID_ADDRESS), - m_module_filespec(module_spec) -{ +BreakpointResolverAddress::BreakpointResolverAddress( + Breakpoint *bkpt, const Address &addr, const FileSpec &module_spec) + : BreakpointResolver(bkpt, BreakpointResolver::AddressResolver), + m_addr(addr), m_resolved_addr(LLDB_INVALID_ADDRESS), + m_module_filespec(module_spec) {} + +BreakpointResolverAddress::BreakpointResolverAddress(Breakpoint *bkpt, + const Address &addr) + : BreakpointResolver(bkpt, BreakpointResolver::AddressResolver), + m_addr(addr), m_resolved_addr(LLDB_INVALID_ADDRESS), m_module_filespec() { } -BreakpointResolverAddress::BreakpointResolverAddress -( - Breakpoint *bkpt, - const Address &addr -) : - BreakpointResolver (bkpt, BreakpointResolver::AddressResolver), - m_addr (addr), - m_resolved_addr(LLDB_INVALID_ADDRESS), - m_module_filespec() -{ +BreakpointResolverAddress::~BreakpointResolverAddress() {} + +void BreakpointResolverAddress::ResolveBreakpoint(SearchFilter &filter) { + // If the address is not section relative, then we should not try to + // re-resolve it, it is just some + // random address and we wouldn't know what to do on reload. But if it is + // section relative, we need to + // re-resolve it since the section it's in may have shifted on re-run. + bool re_resolve = false; + if (m_addr.GetSection() || m_module_filespec) + re_resolve = true; + else if (m_breakpoint->GetNumLocations() == 0) + re_resolve = true; + + if (re_resolve) + BreakpointResolver::ResolveBreakpoint(filter); } -BreakpointResolverAddress::~BreakpointResolverAddress () -{ - -} - -void -BreakpointResolverAddress::ResolveBreakpoint (SearchFilter &filter) -{ - // If the address is not section relative, then we should not try to re-resolve it, it is just some - // random address and we wouldn't know what to do on reload. But if it is section relative, we need to - // re-resolve it since the section it's in may have shifted on re-run. - bool re_resolve = false; - if (m_addr.GetSection() || m_module_filespec) - re_resolve = true; - else if (m_breakpoint->GetNumLocations() == 0) - re_resolve = true; - - if (re_resolve) - BreakpointResolver::ResolveBreakpoint(filter); -} - -void -BreakpointResolverAddress::ResolveBreakpointInModules -( - SearchFilter &filter, - ModuleList &modules -) -{ - // See comment in ResolveBreakpoint. - bool re_resolve = false; - if (m_addr.GetSection()) - re_resolve = true; - else if (m_breakpoint->GetNumLocations() == 0) - re_resolve = true; - - if (re_resolve) - BreakpointResolver::ResolveBreakpointInModules (filter, modules); +void BreakpointResolverAddress::ResolveBreakpointInModules( + SearchFilter &filter, ModuleList &modules) { + // See comment in ResolveBreakpoint. + bool re_resolve = false; + if (m_addr.GetSection()) + re_resolve = true; + else if (m_breakpoint->GetNumLocations() == 0) + re_resolve = true; + + if (re_resolve) + BreakpointResolver::ResolveBreakpointInModules(filter, modules); } Searcher::CallbackReturn -BreakpointResolverAddress::SearchCallback -( - SearchFilter &filter, - SymbolContext &context, - Address *addr, - bool containing -) -{ - assert (m_breakpoint != NULL); - - if (filter.AddressPasses (m_addr)) - { - if (m_breakpoint->GetNumLocations() == 0) - { - // If the address is just an offset, and we're given a module, see if we can find the appropriate module - // loaded in the binary, and fix up m_addr to use that. - if (!m_addr.IsSectionOffset() && m_module_filespec) - { - Target &target = m_breakpoint->GetTarget(); - ModuleSpec module_spec(m_module_filespec); - ModuleSP module_sp = target.GetImages().FindFirstModule(module_spec); - if (module_sp) - { - Address tmp_address; - if (module_sp->ResolveFileAddress(m_addr.GetOffset(), tmp_address)) - m_addr = tmp_address; - } - } - - m_resolved_addr = m_addr.GetLoadAddress(&m_breakpoint->GetTarget()); - BreakpointLocationSP bp_loc_sp(AddLocation(m_addr)); - if (bp_loc_sp && !m_breakpoint->IsInternal()) - { - StreamString s; - bp_loc_sp->GetDescription(&s, lldb::eDescriptionLevelVerbose); - Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_BREAKPOINTS)); - if (log) - log->Printf ("Added location: %s\n", s.GetData()); - } - } - else - { - BreakpointLocationSP loc_sp = m_breakpoint->GetLocationAtIndex(0); - lldb::addr_t cur_load_location = m_addr.GetLoadAddress(&m_breakpoint->GetTarget()); - if (cur_load_location != m_resolved_addr) - { - m_resolved_addr = cur_load_location; - loc_sp->ClearBreakpointSite(); - loc_sp->ResolveBreakpointSite(); - } +BreakpointResolverAddress::SearchCallback(SearchFilter &filter, + SymbolContext &context, Address *addr, + bool containing) { + assert(m_breakpoint != NULL); + + if (filter.AddressPasses(m_addr)) { + if (m_breakpoint->GetNumLocations() == 0) { + // If the address is just an offset, and we're given a module, see if we + // can find the appropriate module + // loaded in the binary, and fix up m_addr to use that. + if (!m_addr.IsSectionOffset() && m_module_filespec) { + Target &target = m_breakpoint->GetTarget(); + ModuleSpec module_spec(m_module_filespec); + ModuleSP module_sp = target.GetImages().FindFirstModule(module_spec); + if (module_sp) { + Address tmp_address; + if (module_sp->ResolveFileAddress(m_addr.GetOffset(), tmp_address)) + m_addr = tmp_address; } + } + + m_resolved_addr = m_addr.GetLoadAddress(&m_breakpoint->GetTarget()); + BreakpointLocationSP bp_loc_sp(AddLocation(m_addr)); + if (bp_loc_sp && !m_breakpoint->IsInternal()) { + StreamString s; + bp_loc_sp->GetDescription(&s, lldb::eDescriptionLevelVerbose); + Log *log( + lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_BREAKPOINTS)); + if (log) + log->Printf("Added location: %s\n", s.GetData()); + } + } else { + BreakpointLocationSP loc_sp = m_breakpoint->GetLocationAtIndex(0); + lldb::addr_t cur_load_location = + m_addr.GetLoadAddress(&m_breakpoint->GetTarget()); + if (cur_load_location != m_resolved_addr) { + m_resolved_addr = cur_load_location; + loc_sp->ClearBreakpointSite(); + loc_sp->ResolveBreakpointSite(); + } } - return Searcher::eCallbackReturnStop; + } + return Searcher::eCallbackReturnStop; } -Searcher::Depth -BreakpointResolverAddress::GetDepth() -{ - return Searcher::eDepthTarget; +Searcher::Depth BreakpointResolverAddress::GetDepth() { + return Searcher::eDepthTarget; } -void -BreakpointResolverAddress::GetDescription (Stream *s) -{ - s->PutCString ("address = "); - m_addr.Dump(s, m_breakpoint->GetTarget().GetProcessSP().get(), Address::DumpStyleModuleWithFileAddress, Address::DumpStyleLoadAddress); +void BreakpointResolverAddress::GetDescription(Stream *s) { + s->PutCString("address = "); + m_addr.Dump(s, m_breakpoint->GetTarget().GetProcessSP().get(), + Address::DumpStyleModuleWithFileAddress, + Address::DumpStyleLoadAddress); } -void -BreakpointResolverAddress::Dump (Stream *s) const -{ - -} +void BreakpointResolverAddress::Dump(Stream *s) const {} lldb::BreakpointResolverSP -BreakpointResolverAddress::CopyForBreakpoint (Breakpoint &breakpoint) -{ - lldb::BreakpointResolverSP ret_sp(new BreakpointResolverAddress(&breakpoint, m_addr)); - return ret_sp; +BreakpointResolverAddress::CopyForBreakpoint(Breakpoint &breakpoint) { + lldb::BreakpointResolverSP ret_sp( + new BreakpointResolverAddress(&breakpoint, m_addr)); + return ret_sp; } - diff --git a/lldb/source/Breakpoint/BreakpointResolverFileLine.cpp b/lldb/source/Breakpoint/BreakpointResolverFileLine.cpp index e1fb87a9d87..482b1658251 100644 --- a/lldb/source/Breakpoint/BreakpointResolverFileLine.cpp +++ b/lldb/source/Breakpoint/BreakpointResolverFileLine.cpp @@ -26,102 +26,79 @@ using namespace lldb_private; //---------------------------------------------------------------------- // BreakpointResolverFileLine: //---------------------------------------------------------------------- -BreakpointResolverFileLine::BreakpointResolverFileLine -( - Breakpoint *bkpt, - const FileSpec &file_spec, - uint32_t line_no, - lldb::addr_t offset, - bool check_inlines, - bool skip_prologue, - bool exact_match -) : - BreakpointResolver (bkpt, BreakpointResolver::FileLineResolver, offset), - m_file_spec (file_spec), - m_line_number (line_no), - m_inlines (check_inlines), - m_skip_prologue(skip_prologue), - m_exact_match(exact_match) -{ -} +BreakpointResolverFileLine::BreakpointResolverFileLine( + Breakpoint *bkpt, const FileSpec &file_spec, uint32_t line_no, + lldb::addr_t offset, bool check_inlines, bool skip_prologue, + bool exact_match) + : BreakpointResolver(bkpt, BreakpointResolver::FileLineResolver, offset), + m_file_spec(file_spec), m_line_number(line_no), m_inlines(check_inlines), + m_skip_prologue(skip_prologue), m_exact_match(exact_match) {} -BreakpointResolverFileLine::~BreakpointResolverFileLine () -{ -} +BreakpointResolverFileLine::~BreakpointResolverFileLine() {} Searcher::CallbackReturn -BreakpointResolverFileLine::SearchCallback -( - SearchFilter &filter, - SymbolContext &context, - Address *addr, - bool containing -) -{ - SymbolContextList sc_list; - - assert (m_breakpoint != NULL); - - // There is a tricky bit here. You can have two compilation units that #include the same file, and - // in one of them the function at m_line_number is used (and so code and a line entry for it is generated) but in the - // other it isn't. If we considered the CU's independently, then in the second inclusion, we'd move the breakpoint - // to the next function that actually generated code in the header file. That would end up being confusing. - // So instead, we do the CU iterations by hand here, then scan through the complete list of matches, and figure out - // the closest line number match, and only set breakpoints on that match. - - // Note also that if file_spec only had a file name and not a directory, there may be many different file spec's in - // the resultant list. The closest line match for one will not be right for some totally different file. - // So we go through the match list and pull out the sets that have the same file spec in their line_entry - // and treat each set separately. - - const size_t num_comp_units = context.module_sp->GetNumCompileUnits(); - for (size_t i = 0; i < num_comp_units; i++) - { - CompUnitSP cu_sp (context.module_sp->GetCompileUnitAtIndex (i)); - if (cu_sp) - { - if (filter.CompUnitPasses(*cu_sp)) - cu_sp->ResolveSymbolContext (m_file_spec, m_line_number, m_inlines, m_exact_match, eSymbolContextEverything, sc_list); - } +BreakpointResolverFileLine::SearchCallback(SearchFilter &filter, + SymbolContext &context, + Address *addr, bool containing) { + SymbolContextList sc_list; + + assert(m_breakpoint != NULL); + + // There is a tricky bit here. You can have two compilation units that + // #include the same file, and + // in one of them the function at m_line_number is used (and so code and a + // line entry for it is generated) but in the + // other it isn't. If we considered the CU's independently, then in the + // second inclusion, we'd move the breakpoint + // to the next function that actually generated code in the header file. That + // would end up being confusing. + // So instead, we do the CU iterations by hand here, then scan through the + // complete list of matches, and figure out + // the closest line number match, and only set breakpoints on that match. + + // Note also that if file_spec only had a file name and not a directory, there + // may be many different file spec's in + // the resultant list. The closest line match for one will not be right for + // some totally different file. + // So we go through the match list and pull out the sets that have the same + // file spec in their line_entry + // and treat each set separately. + + const size_t num_comp_units = context.module_sp->GetNumCompileUnits(); + for (size_t i = 0; i < num_comp_units; i++) { + CompUnitSP cu_sp(context.module_sp->GetCompileUnitAtIndex(i)); + if (cu_sp) { + if (filter.CompUnitPasses(*cu_sp)) + cu_sp->ResolveSymbolContext(m_file_spec, m_line_number, m_inlines, + m_exact_match, eSymbolContextEverything, + sc_list); } - StreamString s; - s.Printf ("for %s:%d ", - m_file_spec.GetFilename().AsCString("<Unknown>"), - m_line_number); + } + StreamString s; + s.Printf("for %s:%d ", m_file_spec.GetFilename().AsCString("<Unknown>"), + m_line_number); - SetSCMatchesByLine (filter, sc_list, m_skip_prologue, s.GetData()); + SetSCMatchesByLine(filter, sc_list, m_skip_prologue, s.GetData()); - return Searcher::eCallbackReturnContinue; + return Searcher::eCallbackReturnContinue; } -Searcher::Depth -BreakpointResolverFileLine::GetDepth() -{ - return Searcher::eDepthModule; +Searcher::Depth BreakpointResolverFileLine::GetDepth() { + return Searcher::eDepthModule; } -void -BreakpointResolverFileLine::GetDescription (Stream *s) -{ - s->Printf ("file = '%s', line = %u, exact_match = %d", m_file_spec.GetPath().c_str(), m_line_number, m_exact_match); +void BreakpointResolverFileLine::GetDescription(Stream *s) { + s->Printf("file = '%s', line = %u, exact_match = %d", + m_file_spec.GetPath().c_str(), m_line_number, m_exact_match); } -void -BreakpointResolverFileLine::Dump (Stream *s) const -{ - -} +void BreakpointResolverFileLine::Dump(Stream *s) const {} lldb::BreakpointResolverSP -BreakpointResolverFileLine::CopyForBreakpoint (Breakpoint &breakpoint) -{ - lldb::BreakpointResolverSP ret_sp(new BreakpointResolverFileLine(&breakpoint, - m_file_spec, - m_line_number, - m_offset, - m_inlines, - m_skip_prologue, - m_exact_match)); - - return ret_sp; +BreakpointResolverFileLine::CopyForBreakpoint(Breakpoint &breakpoint) { + lldb::BreakpointResolverSP ret_sp(new BreakpointResolverFileLine( + &breakpoint, m_file_spec, m_line_number, m_offset, m_inlines, + m_skip_prologue, m_exact_match)); + + return ret_sp; } diff --git a/lldb/source/Breakpoint/BreakpointResolverFileRegex.cpp b/lldb/source/Breakpoint/BreakpointResolverFileRegex.cpp index ae7f58acb91..8d08908f9a3 100644 --- a/lldb/source/Breakpoint/BreakpointResolverFileRegex.cpp +++ b/lldb/source/Breakpoint/BreakpointResolverFileRegex.cpp @@ -1,4 +1,5 @@ -//===-- BreakpointResolverFileRegex.cpp --------------------------*- C++ -*-===// +//===-- BreakpointResolverFileRegex.cpp --------------------------*- C++ +//-*-===// // // The LLVM Compiler Infrastructure // @@ -14,8 +15,8 @@ // Other libraries and framework includes // Project includes #include "lldb/Breakpoint/BreakpointLocation.h" -#include "lldb/Core/SourceManager.h" #include "lldb/Core/Log.h" +#include "lldb/Core/SourceManager.h" #include "lldb/Core/StreamString.h" #include "lldb/Symbol/CompileUnit.h" #include "lldb/Target/Target.h" @@ -26,113 +27,90 @@ using namespace lldb_private; //---------------------------------------------------------------------- // BreakpointResolverFileRegex: //---------------------------------------------------------------------- -BreakpointResolverFileRegex::BreakpointResolverFileRegex -( - Breakpoint *bkpt, - RegularExpression ®ex, - const std::unordered_set<std::string> &func_names, - bool exact_match -) : - BreakpointResolver (bkpt, BreakpointResolver::FileLineResolver), - m_regex (regex), - m_exact_match (exact_match), - m_function_names(func_names) -{ +BreakpointResolverFileRegex::BreakpointResolverFileRegex( + Breakpoint *bkpt, RegularExpression ®ex, + const std::unordered_set<std::string> &func_names, bool exact_match) + : BreakpointResolver(bkpt, BreakpointResolver::FileLineResolver), + m_regex(regex), m_exact_match(exact_match), m_function_names(func_names) { } -BreakpointResolverFileRegex::~BreakpointResolverFileRegex () -{ -} +BreakpointResolverFileRegex::~BreakpointResolverFileRegex() {} Searcher::CallbackReturn -BreakpointResolverFileRegex::SearchCallback -( - SearchFilter &filter, - SymbolContext &context, - Address *addr, - bool containing -) -{ - - assert (m_breakpoint != NULL); - if (!context.target_sp) - return eCallbackReturnContinue; - - CompileUnit *cu = context.comp_unit; - FileSpec cu_file_spec = *(static_cast<FileSpec *>(cu)); - std::vector<uint32_t> line_matches; - context.target_sp->GetSourceManager().FindLinesMatchingRegex(cu_file_spec, m_regex, 1, UINT32_MAX, line_matches); - - uint32_t num_matches = line_matches.size(); - for (uint32_t i = 0; i < num_matches; i++) - { - SymbolContextList sc_list; - const bool search_inlines = false; - - cu->ResolveSymbolContext (cu_file_spec, line_matches[i], search_inlines, m_exact_match, eSymbolContextEverything, sc_list); - // Find all the function names: - if (!m_function_names.empty()) - { - std::vector<size_t> sc_to_remove; - for (size_t i = 0; i < sc_list.GetSize(); i++) - { - SymbolContext sc_ctx; - sc_list.GetContextAtIndex(i, sc_ctx); - std::string name(sc_ctx.GetFunctionName(Mangled::NamePreference::ePreferDemangledWithoutArguments).AsCString()); - if (!m_function_names.count(name)) - { - sc_to_remove.push_back(i); - } - } - - if (!sc_to_remove.empty()) - { - std::vector<size_t>::reverse_iterator iter; - std::vector<size_t>::reverse_iterator rend = sc_to_remove.rend(); - for (iter = sc_to_remove.rbegin(); iter != rend; iter++) - { - sc_list.RemoveContextAtIndex(*iter); - } - } +BreakpointResolverFileRegex::SearchCallback(SearchFilter &filter, + SymbolContext &context, + Address *addr, bool containing) { + + assert(m_breakpoint != NULL); + if (!context.target_sp) + return eCallbackReturnContinue; + + CompileUnit *cu = context.comp_unit; + FileSpec cu_file_spec = *(static_cast<FileSpec *>(cu)); + std::vector<uint32_t> line_matches; + context.target_sp->GetSourceManager().FindLinesMatchingRegex( + cu_file_spec, m_regex, 1, UINT32_MAX, line_matches); + + uint32_t num_matches = line_matches.size(); + for (uint32_t i = 0; i < num_matches; i++) { + SymbolContextList sc_list; + const bool search_inlines = false; + + cu->ResolveSymbolContext(cu_file_spec, line_matches[i], search_inlines, + m_exact_match, eSymbolContextEverything, sc_list); + // Find all the function names: + if (!m_function_names.empty()) { + std::vector<size_t> sc_to_remove; + for (size_t i = 0; i < sc_list.GetSize(); i++) { + SymbolContext sc_ctx; + sc_list.GetContextAtIndex(i, sc_ctx); + std::string name( + sc_ctx + .GetFunctionName( + Mangled::NamePreference::ePreferDemangledWithoutArguments) + .AsCString()); + if (!m_function_names.count(name)) { + sc_to_remove.push_back(i); + } + } + + if (!sc_to_remove.empty()) { + std::vector<size_t>::reverse_iterator iter; + std::vector<size_t>::reverse_iterator rend = sc_to_remove.rend(); + for (iter = sc_to_remove.rbegin(); iter != rend; iter++) { + sc_list.RemoveContextAtIndex(*iter); } - - const bool skip_prologue = true; - - BreakpointResolver::SetSCMatchesByLine (filter, sc_list, skip_prologue, m_regex.GetText()); + } } - assert (m_breakpoint != NULL); - return Searcher::eCallbackReturnContinue; -} + const bool skip_prologue = true; -Searcher::Depth -BreakpointResolverFileRegex::GetDepth() -{ - return Searcher::eDepthCompUnit; -} + BreakpointResolver::SetSCMatchesByLine(filter, sc_list, skip_prologue, + m_regex.GetText()); + } + assert(m_breakpoint != NULL); -void -BreakpointResolverFileRegex::GetDescription (Stream *s) -{ - s->Printf ("source regex = \"%s\", exact_match = %d", m_regex.GetText(), m_exact_match); + return Searcher::eCallbackReturnContinue; } -void -BreakpointResolverFileRegex::Dump (Stream *s) const -{ +Searcher::Depth BreakpointResolverFileRegex::GetDepth() { + return Searcher::eDepthCompUnit; +} +void BreakpointResolverFileRegex::GetDescription(Stream *s) { + s->Printf("source regex = \"%s\", exact_match = %d", m_regex.GetText(), + m_exact_match); } +void BreakpointResolverFileRegex::Dump(Stream *s) const {} + lldb::BreakpointResolverSP -BreakpointResolverFileRegex::CopyForBreakpoint (Breakpoint &breakpoint) -{ - lldb::BreakpointResolverSP ret_sp(new BreakpointResolverFileRegex(&breakpoint, m_regex, m_function_names, m_exact_match)); - return ret_sp; +BreakpointResolverFileRegex::CopyForBreakpoint(Breakpoint &breakpoint) { + lldb::BreakpointResolverSP ret_sp(new BreakpointResolverFileRegex( + &breakpoint, m_regex, m_function_names, m_exact_match)); + return ret_sp; } -void -BreakpointResolverFileRegex::AddFunctionName(const char *func_name) -{ - m_function_names.insert(func_name); +void BreakpointResolverFileRegex::AddFunctionName(const char *func_name) { + m_function_names.insert(func_name); } - diff --git a/lldb/source/Breakpoint/BreakpointResolverName.cpp b/lldb/source/Breakpoint/BreakpointResolverName.cpp index dfa09c2342f..64d0318eb1f 100644 --- a/lldb/source/Breakpoint/BreakpointResolverName.cpp +++ b/lldb/source/Breakpoint/BreakpointResolverName.cpp @@ -13,6 +13,8 @@ // Project includes #include "lldb/Breakpoint/BreakpointResolverName.h" +#include "Plugins/Language/CPlusPlus/CPlusPlusLanguage.h" +#include "Plugins/Language/ObjC/ObjCLanguage.h" #include "lldb/Breakpoint/BreakpointLocation.h" #include "lldb/Core/Log.h" #include "lldb/Core/Module.h" @@ -21,372 +23,288 @@ #include "lldb/Symbol/Function.h" #include "lldb/Symbol/Symbol.h" #include "lldb/Symbol/SymbolContext.h" -#include "Plugins/Language/ObjC/ObjCLanguage.h" -#include "Plugins/Language/CPlusPlus/CPlusPlusLanguage.h" using namespace lldb; using namespace lldb_private; -BreakpointResolverName::BreakpointResolverName (Breakpoint *bkpt, - const char *name_cstr, - uint32_t name_type_mask, - LanguageType language, - Breakpoint::MatchType type, - lldb::addr_t offset, - bool skip_prologue) : - BreakpointResolver (bkpt, BreakpointResolver::NameResolver, offset), - m_class_name (), - m_regex (), - m_match_type (type), - m_language (language), - m_skip_prologue (skip_prologue) -{ - if (m_match_type == Breakpoint::Regexp) - { - if (!m_regex.Compile (name_cstr)) - { - Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_BREAKPOINTS)); - - if (log) - log->Warning ("function name regexp: \"%s\" did not compile.", name_cstr); - } - } - else - { - AddNameLookup (ConstString(name_cstr), name_type_mask); - } -} +BreakpointResolverName::BreakpointResolverName( + Breakpoint *bkpt, const char *name_cstr, uint32_t name_type_mask, + LanguageType language, Breakpoint::MatchType type, lldb::addr_t offset, + bool skip_prologue) + : BreakpointResolver(bkpt, BreakpointResolver::NameResolver, offset), + m_class_name(), m_regex(), m_match_type(type), m_language(language), + m_skip_prologue(skip_prologue) { + if (m_match_type == Breakpoint::Regexp) { + if (!m_regex.Compile(name_cstr)) { + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_BREAKPOINTS)); -BreakpointResolverName::BreakpointResolverName (Breakpoint *bkpt, - const char *names[], - size_t num_names, - uint32_t name_type_mask, - LanguageType language, - lldb::addr_t offset, - bool skip_prologue) : - BreakpointResolver (bkpt, BreakpointResolver::NameResolver, offset), - m_match_type (Breakpoint::Exact), - m_language (language), - m_skip_prologue (skip_prologue) -{ - for (size_t i = 0; i < num_names; i++) - { - AddNameLookup (ConstString (names[i]), name_type_mask); + if (log) + log->Warning("function name regexp: \"%s\" did not compile.", + name_cstr); } + } else { + AddNameLookup(ConstString(name_cstr), name_type_mask); + } } -BreakpointResolverName::BreakpointResolverName (Breakpoint *bkpt, - std::vector<std::string> names, - uint32_t name_type_mask, - LanguageType language, - lldb::addr_t offset, - bool skip_prologue) : - BreakpointResolver (bkpt, BreakpointResolver::NameResolver, offset), - m_match_type (Breakpoint::Exact), - m_language (language), - m_skip_prologue (skip_prologue) -{ - for (const std::string& name : names) - { - AddNameLookup (ConstString (name.c_str(), name.size()), name_type_mask); - } +BreakpointResolverName::BreakpointResolverName( + Breakpoint *bkpt, const char *names[], size_t num_names, + uint32_t name_type_mask, LanguageType language, lldb::addr_t offset, + bool skip_prologue) + : BreakpointResolver(bkpt, BreakpointResolver::NameResolver, offset), + m_match_type(Breakpoint::Exact), m_language(language), + m_skip_prologue(skip_prologue) { + for (size_t i = 0; i < num_names; i++) { + AddNameLookup(ConstString(names[i]), name_type_mask); + } } -BreakpointResolverName::BreakpointResolverName (Breakpoint *bkpt, - RegularExpression &func_regex, - lldb::LanguageType language, - lldb::addr_t offset, - bool skip_prologue) : - BreakpointResolver (bkpt, BreakpointResolver::NameResolver, offset), - m_class_name (nullptr), - m_regex (func_regex), - m_match_type (Breakpoint::Regexp), - m_language (language), - m_skip_prologue (skip_prologue) -{ +BreakpointResolverName::BreakpointResolverName( + Breakpoint *bkpt, std::vector<std::string> names, uint32_t name_type_mask, + LanguageType language, lldb::addr_t offset, bool skip_prologue) + : BreakpointResolver(bkpt, BreakpointResolver::NameResolver, offset), + m_match_type(Breakpoint::Exact), m_language(language), + m_skip_prologue(skip_prologue) { + for (const std::string &name : names) { + AddNameLookup(ConstString(name.c_str(), name.size()), name_type_mask); + } } -BreakpointResolverName::BreakpointResolverName -( - Breakpoint *bkpt, - const char *class_name, - const char *method, - Breakpoint::MatchType type, - lldb::addr_t offset, - bool skip_prologue -) : - BreakpointResolver (bkpt, BreakpointResolver::NameResolver, offset), - m_class_name (class_name), - m_regex (), - m_match_type (type), - m_language (eLanguageTypeUnknown), - m_skip_prologue (skip_prologue) -{ - Module::LookupInfo lookup; - lookup.SetName(ConstString(method)); - lookup.SetLookupName(lookup.GetName()); - lookup.SetNameTypeMask(eFunctionNameTypeMethod); - m_lookups.push_back (lookup); +BreakpointResolverName::BreakpointResolverName(Breakpoint *bkpt, + RegularExpression &func_regex, + lldb::LanguageType language, + lldb::addr_t offset, + bool skip_prologue) + : BreakpointResolver(bkpt, BreakpointResolver::NameResolver, offset), + m_class_name(nullptr), m_regex(func_regex), + m_match_type(Breakpoint::Regexp), m_language(language), + m_skip_prologue(skip_prologue) {} + +BreakpointResolverName::BreakpointResolverName( + Breakpoint *bkpt, const char *class_name, const char *method, + Breakpoint::MatchType type, lldb::addr_t offset, bool skip_prologue) + : BreakpointResolver(bkpt, BreakpointResolver::NameResolver, offset), + m_class_name(class_name), m_regex(), m_match_type(type), + m_language(eLanguageTypeUnknown), m_skip_prologue(skip_prologue) { + Module::LookupInfo lookup; + lookup.SetName(ConstString(method)); + lookup.SetLookupName(lookup.GetName()); + lookup.SetNameTypeMask(eFunctionNameTypeMethod); + m_lookups.push_back(lookup); } BreakpointResolverName::~BreakpointResolverName() = default; -BreakpointResolverName::BreakpointResolverName(const BreakpointResolverName &rhs) : - BreakpointResolver(rhs.m_breakpoint, BreakpointResolver::NameResolver, rhs.m_offset), - m_lookups(rhs.m_lookups), - m_class_name(rhs.m_class_name), - m_regex(rhs.m_regex), - m_match_type (rhs.m_match_type), - m_language (rhs.m_language), - m_skip_prologue (rhs.m_skip_prologue) -{ -} +BreakpointResolverName::BreakpointResolverName( + const BreakpointResolverName &rhs) + : BreakpointResolver(rhs.m_breakpoint, BreakpointResolver::NameResolver, + rhs.m_offset), + m_lookups(rhs.m_lookups), m_class_name(rhs.m_class_name), + m_regex(rhs.m_regex), m_match_type(rhs.m_match_type), + m_language(rhs.m_language), m_skip_prologue(rhs.m_skip_prologue) {} -void -BreakpointResolverName::AddNameLookup (const ConstString &name, uint32_t name_type_mask) -{ - ObjCLanguage::MethodName objc_method(name.GetCString(), false); - if (objc_method.IsValid(false)) - { - std::vector<ConstString> objc_names; - objc_method.GetFullNames(objc_names, true); - for (ConstString objc_name : objc_names) - { - Module::LookupInfo lookup; - lookup.SetName(name); - lookup.SetLookupName(objc_name); - lookup.SetNameTypeMask(eFunctionNameTypeFull); - m_lookups.push_back (lookup); - } - } - else - { - Module::LookupInfo lookup(name, name_type_mask, m_language); - m_lookups.push_back (lookup); +void BreakpointResolverName::AddNameLookup(const ConstString &name, + uint32_t name_type_mask) { + ObjCLanguage::MethodName objc_method(name.GetCString(), false); + if (objc_method.IsValid(false)) { + std::vector<ConstString> objc_names; + objc_method.GetFullNames(objc_names, true); + for (ConstString objc_name : objc_names) { + Module::LookupInfo lookup; + lookup.SetName(name); + lookup.SetLookupName(objc_name); + lookup.SetNameTypeMask(eFunctionNameTypeFull); + m_lookups.push_back(lookup); } + } else { + Module::LookupInfo lookup(name, name_type_mask, m_language); + m_lookups.push_back(lookup); + } } -// FIXME: Right now we look at the module level, and call the module's "FindFunctions". -// Greg says he will add function tables, maybe at the CompileUnit level to accelerate function -// lookup. At that point, we should switch the depth to CompileUnit, and look in these tables. +// FIXME: Right now we look at the module level, and call the module's +// "FindFunctions". +// Greg says he will add function tables, maybe at the CompileUnit level to +// accelerate function +// lookup. At that point, we should switch the depth to CompileUnit, and look +// in these tables. Searcher::CallbackReturn BreakpointResolverName::SearchCallback(SearchFilter &filter, - SymbolContext &context, - Address *addr, - bool containing) -{ - SymbolContextList func_list; - //SymbolContextList sym_list; - - uint32_t i; - bool new_location; - Address break_addr; - assert (m_breakpoint != nullptr); - - Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_BREAKPOINTS)); - - if (m_class_name) - { - if (log) - log->Warning ("Class/method function specification not supported yet.\n"); - return Searcher::eCallbackReturnStop; + SymbolContext &context, Address *addr, + bool containing) { + SymbolContextList func_list; + // SymbolContextList sym_list; + + uint32_t i; + bool new_location; + Address break_addr; + assert(m_breakpoint != nullptr); + + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_BREAKPOINTS)); + + if (m_class_name) { + if (log) + log->Warning("Class/method function specification not supported yet.\n"); + return Searcher::eCallbackReturnStop; + } + bool filter_by_cu = + (filter.GetFilterRequiredItems() & eSymbolContextCompUnit) != 0; + bool filter_by_language = (m_language != eLanguageTypeUnknown); + const bool include_symbols = !filter_by_cu; + const bool include_inlines = true; + const bool append = true; + + switch (m_match_type) { + case Breakpoint::Exact: + if (context.module_sp) { + for (const auto &lookup : m_lookups) { + const size_t start_func_idx = func_list.GetSize(); + context.module_sp->FindFunctions( + lookup.GetLookupName(), nullptr, lookup.GetNameTypeMask(), + include_symbols, include_inlines, append, func_list); + + const size_t end_func_idx = func_list.GetSize(); + + if (start_func_idx < end_func_idx) + lookup.Prune(func_list, start_func_idx); + } } - bool filter_by_cu = (filter.GetFilterRequiredItems() & eSymbolContextCompUnit) != 0; - bool filter_by_language = (m_language != eLanguageTypeUnknown); - const bool include_symbols = !filter_by_cu; - const bool include_inlines = true; - const bool append = true; - - switch (m_match_type) - { - case Breakpoint::Exact: - if (context.module_sp) - { - for (const auto &lookup : m_lookups) - { - const size_t start_func_idx = func_list.GetSize(); - context.module_sp->FindFunctions(lookup.GetLookupName(), - nullptr, - lookup.GetNameTypeMask(), - include_symbols, - include_inlines, - append, - func_list); - - const size_t end_func_idx = func_list.GetSize(); - - if (start_func_idx < end_func_idx) - lookup.Prune (func_list, start_func_idx); - } - } - break; - case Breakpoint::Regexp: - if (context.module_sp) - { - context.module_sp->FindFunctions (m_regex, - !filter_by_cu, // include symbols only if we aren't filtering by CU - include_inlines, - append, - func_list); - } - break; - case Breakpoint::Glob: - if (log) - log->Warning ("glob is not supported yet."); - break; + break; + case Breakpoint::Regexp: + if (context.module_sp) { + context.module_sp->FindFunctions( + m_regex, + !filter_by_cu, // include symbols only if we aren't filtering by CU + include_inlines, append, func_list); } + break; + case Breakpoint::Glob: + if (log) + log->Warning("glob is not supported yet."); + break; + } - // If the filter specifies a Compilation Unit, remove the ones that don't pass at this point. - if (filter_by_cu || filter_by_language) - { - uint32_t num_functions = func_list.GetSize(); - - for (size_t idx = 0; idx < num_functions; idx++) - { - bool remove_it = false; - SymbolContext sc; - func_list.GetContextAtIndex(idx, sc); - if (filter_by_cu) - { - if (!sc.comp_unit || !filter.CompUnitPasses(*sc.comp_unit)) - remove_it = true; - } - - if (filter_by_language) - { - LanguageType sym_language = sc.GetLanguage(); - if ((Language::GetPrimaryLanguage(sym_language) != - Language::GetPrimaryLanguage(m_language)) && - (sym_language != eLanguageTypeUnknown)) - { - remove_it = true; - } - } - - if (remove_it) - { - func_list.RemoveContextAtIndex(idx); - num_functions--; - idx--; - } + // If the filter specifies a Compilation Unit, remove the ones that don't pass + // at this point. + if (filter_by_cu || filter_by_language) { + uint32_t num_functions = func_list.GetSize(); + + for (size_t idx = 0; idx < num_functions; idx++) { + bool remove_it = false; + SymbolContext sc; + func_list.GetContextAtIndex(idx, sc); + if (filter_by_cu) { + if (!sc.comp_unit || !filter.CompUnitPasses(*sc.comp_unit)) + remove_it = true; + } + + if (filter_by_language) { + LanguageType sym_language = sc.GetLanguage(); + if ((Language::GetPrimaryLanguage(sym_language) != + Language::GetPrimaryLanguage(m_language)) && + (sym_language != eLanguageTypeUnknown)) { + remove_it = true; } + } + + if (remove_it) { + func_list.RemoveContextAtIndex(idx); + num_functions--; + idx--; + } } + } + + // Remove any duplicates between the function list and the symbol list + SymbolContext sc; + if (func_list.GetSize()) { + for (i = 0; i < func_list.GetSize(); i++) { + if (func_list.GetContextAtIndex(i, sc)) { + bool is_reexported = false; - // Remove any duplicates between the function list and the symbol list - SymbolContext sc; - if (func_list.GetSize()) - { - for (i = 0; i < func_list.GetSize(); i++) - { - if (func_list.GetContextAtIndex(i, sc)) - { - bool is_reexported = false; - - if (sc.block && sc.block->GetInlinedFunctionInfo()) - { - if (!sc.block->GetStartAddress(break_addr)) - break_addr.Clear(); - } - else if (sc.function) - { - break_addr = sc.function->GetAddressRange().GetBaseAddress(); - if (m_skip_prologue && break_addr.IsValid()) - { - const uint32_t prologue_byte_size = sc.function->GetPrologueByteSize(); - if (prologue_byte_size) - break_addr.SetOffset(break_addr.GetOffset() + prologue_byte_size); - } - } - else if (sc.symbol) - { - if (sc.symbol->GetType() == eSymbolTypeReExported) - { - const Symbol *actual_symbol = sc.symbol->ResolveReExportedSymbol(m_breakpoint->GetTarget()); - if (actual_symbol) - { - is_reexported = true; - break_addr = actual_symbol->GetAddress(); - } - } - else - { - break_addr = sc.symbol->GetAddress(); - } - - if (m_skip_prologue && break_addr.IsValid()) - { - const uint32_t prologue_byte_size = sc.symbol->GetPrologueByteSize(); - if (prologue_byte_size) - break_addr.SetOffset(break_addr.GetOffset() + prologue_byte_size); - } - } - - if (break_addr.IsValid()) - { - if (filter.AddressPasses(break_addr)) - { - BreakpointLocationSP bp_loc_sp (AddLocation(break_addr, &new_location)); - bp_loc_sp->SetIsReExported(is_reexported); - if (bp_loc_sp && new_location && !m_breakpoint->IsInternal()) - { - if (log) - { - StreamString s; - bp_loc_sp->GetDescription(&s, lldb::eDescriptionLevelVerbose); - log->Printf ("Added location: %s\n", s.GetData()); - } - } - } - } + if (sc.block && sc.block->GetInlinedFunctionInfo()) { + if (!sc.block->GetStartAddress(break_addr)) + break_addr.Clear(); + } else if (sc.function) { + break_addr = sc.function->GetAddressRange().GetBaseAddress(); + if (m_skip_prologue && break_addr.IsValid()) { + const uint32_t prologue_byte_size = + sc.function->GetPrologueByteSize(); + if (prologue_byte_size) + break_addr.SetOffset(break_addr.GetOffset() + prologue_byte_size); + } + } else if (sc.symbol) { + if (sc.symbol->GetType() == eSymbolTypeReExported) { + const Symbol *actual_symbol = + sc.symbol->ResolveReExportedSymbol(m_breakpoint->GetTarget()); + if (actual_symbol) { + is_reexported = true; + break_addr = actual_symbol->GetAddress(); } + } else { + break_addr = sc.symbol->GetAddress(); + } + + if (m_skip_prologue && break_addr.IsValid()) { + const uint32_t prologue_byte_size = + sc.symbol->GetPrologueByteSize(); + if (prologue_byte_size) + break_addr.SetOffset(break_addr.GetOffset() + prologue_byte_size); + } } + + if (break_addr.IsValid()) { + if (filter.AddressPasses(break_addr)) { + BreakpointLocationSP bp_loc_sp( + AddLocation(break_addr, &new_location)); + bp_loc_sp->SetIsReExported(is_reexported); + if (bp_loc_sp && new_location && !m_breakpoint->IsInternal()) { + if (log) { + StreamString s; + bp_loc_sp->GetDescription(&s, lldb::eDescriptionLevelVerbose); + log->Printf("Added location: %s\n", s.GetData()); + } + } + } + } + } } - - return Searcher::eCallbackReturnContinue; + } + + return Searcher::eCallbackReturnContinue; } -Searcher::Depth -BreakpointResolverName::GetDepth() -{ - return Searcher::eDepthModule; +Searcher::Depth BreakpointResolverName::GetDepth() { + return Searcher::eDepthModule; } -void -BreakpointResolverName::GetDescription (Stream *s) -{ - if (m_match_type == Breakpoint::Regexp) - s->Printf("regex = '%s'", m_regex.GetText()); - else - { - size_t num_names = m_lookups.size(); - if (num_names == 1) - s->Printf("name = '%s'", m_lookups[0].GetName().GetCString()); - else - { - s->Printf("names = {"); - for (size_t i = 0; i < num_names; i++) - { - s->Printf ("%s'%s'", (i == 0 ? "" : ", "), m_lookups[i].GetName().GetCString()); - } - s->Printf ("}"); - } - } - if (m_language != eLanguageTypeUnknown) - { - s->Printf (", language = %s", Language::GetNameForLanguageType(m_language)); +void BreakpointResolverName::GetDescription(Stream *s) { + if (m_match_type == Breakpoint::Regexp) + s->Printf("regex = '%s'", m_regex.GetText()); + else { + size_t num_names = m_lookups.size(); + if (num_names == 1) + s->Printf("name = '%s'", m_lookups[0].GetName().GetCString()); + else { + s->Printf("names = {"); + for (size_t i = 0; i < num_names; i++) { + s->Printf("%s'%s'", (i == 0 ? "" : ", "), + m_lookups[i].GetName().GetCString()); + } + s->Printf("}"); } + } + if (m_language != eLanguageTypeUnknown) { + s->Printf(", language = %s", Language::GetNameForLanguageType(m_language)); + } } -void -BreakpointResolverName::Dump (Stream *s) const -{ -} +void BreakpointResolverName::Dump(Stream *s) const {} lldb::BreakpointResolverSP -BreakpointResolverName::CopyForBreakpoint (Breakpoint &breakpoint) -{ - lldb::BreakpointResolverSP ret_sp(new BreakpointResolverName(*this)); - ret_sp->SetBreakpoint(&breakpoint); - return ret_sp; +BreakpointResolverName::CopyForBreakpoint(Breakpoint &breakpoint) { + lldb::BreakpointResolverSP ret_sp(new BreakpointResolverName(*this)); + ret_sp->SetBreakpoint(&breakpoint); + return ret_sp; } diff --git a/lldb/source/Breakpoint/BreakpointSite.cpp b/lldb/source/Breakpoint/BreakpointSite.cpp index b4112f7fc01..28ba37b1b50 100644 --- a/lldb/source/Breakpoint/BreakpointSite.cpp +++ b/lldb/source/Breakpoint/BreakpointSite.cpp @@ -23,240 +23,181 @@ using namespace lldb; using namespace lldb_private; -BreakpointSite::BreakpointSite(BreakpointSiteList *list, const BreakpointLocationSP &owner, lldb::addr_t addr, - bool use_hardware) +BreakpointSite::BreakpointSite(BreakpointSiteList *list, + const BreakpointLocationSP &owner, + lldb::addr_t addr, bool use_hardware) : StoppointLocation(GetNextID(), addr, 0, use_hardware), - m_type(eSoftware), // Process subclasses need to set this correctly using SetType() - m_saved_opcode(), - m_trap_opcode(), - m_enabled(false), // Need to create it disabled, so the first enable turns it on. - m_owners(), - m_owners_mutex() -{ - m_owners.Add(owner); + m_type(eSoftware), // Process subclasses need to set this correctly using + // SetType() + m_saved_opcode(), m_trap_opcode(), + m_enabled(false), // Need to create it disabled, so the first enable turns + // it on. + m_owners(), m_owners_mutex() { + m_owners.Add(owner); } -BreakpointSite::~BreakpointSite() -{ - BreakpointLocationSP bp_loc_sp; - const size_t owner_count = m_owners.GetSize(); - for (size_t i = 0; i < owner_count; i++) - { - m_owners.GetByIndex(i)->ClearBreakpointSite(); - } +BreakpointSite::~BreakpointSite() { + BreakpointLocationSP bp_loc_sp; + const size_t owner_count = m_owners.GetSize(); + for (size_t i = 0; i < owner_count; i++) { + m_owners.GetByIndex(i)->ClearBreakpointSite(); + } } -break_id_t -BreakpointSite::GetNextID() -{ - static break_id_t g_next_id = 0; - return ++g_next_id; +break_id_t BreakpointSite::GetNextID() { + static break_id_t g_next_id = 0; + return ++g_next_id; } // RETURNS - true if we should stop at this breakpoint, false if we // should continue. -bool -BreakpointSite::ShouldStop (StoppointCallbackContext *context) -{ - std::lock_guard<std::recursive_mutex> guard(m_owners_mutex); - IncrementHitCount(); - return m_owners.ShouldStop (context); +bool BreakpointSite::ShouldStop(StoppointCallbackContext *context) { + std::lock_guard<std::recursive_mutex> guard(m_owners_mutex); + IncrementHitCount(); + return m_owners.ShouldStop(context); } -bool -BreakpointSite::IsBreakpointAtThisSite (lldb::break_id_t bp_id) -{ - std::lock_guard<std::recursive_mutex> guard(m_owners_mutex); - const size_t owner_count = m_owners.GetSize(); - for (size_t i = 0; i < owner_count; i++) - { - if (m_owners.GetByIndex(i)->GetBreakpoint().GetID() == bp_id) - return true; - } - return false; +bool BreakpointSite::IsBreakpointAtThisSite(lldb::break_id_t bp_id) { + std::lock_guard<std::recursive_mutex> guard(m_owners_mutex); + const size_t owner_count = m_owners.GetSize(); + for (size_t i = 0; i < owner_count; i++) { + if (m_owners.GetByIndex(i)->GetBreakpoint().GetID() == bp_id) + return true; + } + return false; } -void -BreakpointSite::Dump(Stream *s) const -{ - if (s == nullptr) - return; +void BreakpointSite::Dump(Stream *s) const { + if (s == nullptr) + return; - s->Printf("BreakpointSite %u: addr = 0x%8.8" PRIx64 " type = %s breakpoint hw_index = %i hit_count = %-4u", - GetID(), - (uint64_t)m_addr, - IsHardware() ? "hardware" : "software", - GetHardwareIndex(), - GetHitCount()); + s->Printf("BreakpointSite %u: addr = 0x%8.8" PRIx64 + " type = %s breakpoint hw_index = %i hit_count = %-4u", + GetID(), (uint64_t)m_addr, IsHardware() ? "hardware" : "software", + GetHardwareIndex(), GetHitCount()); } -void -BreakpointSite::GetDescription (Stream *s, lldb::DescriptionLevel level) -{ - std::lock_guard<std::recursive_mutex> guard(m_owners_mutex); - if (level != lldb::eDescriptionLevelBrief) - s->Printf ("breakpoint site: %d at 0x%8.8" PRIx64, GetID(), GetLoadAddress()); - m_owners.GetDescription (s, level); +void BreakpointSite::GetDescription(Stream *s, lldb::DescriptionLevel level) { + std::lock_guard<std::recursive_mutex> guard(m_owners_mutex); + if (level != lldb::eDescriptionLevelBrief) + s->Printf("breakpoint site: %d at 0x%8.8" PRIx64, GetID(), + GetLoadAddress()); + m_owners.GetDescription(s, level); } -bool -BreakpointSite::IsInternal() const -{ - return m_owners.IsInternal(); -} +bool BreakpointSite::IsInternal() const { return m_owners.IsInternal(); } -uint8_t * -BreakpointSite::GetTrapOpcodeBytes() -{ - return &m_trap_opcode[0]; -} +uint8_t *BreakpointSite::GetTrapOpcodeBytes() { return &m_trap_opcode[0]; } -const uint8_t * -BreakpointSite::GetTrapOpcodeBytes() const -{ - return &m_trap_opcode[0]; +const uint8_t *BreakpointSite::GetTrapOpcodeBytes() const { + return &m_trap_opcode[0]; } -size_t -BreakpointSite::GetTrapOpcodeMaxByteSize() const -{ - return sizeof(m_trap_opcode); +size_t BreakpointSite::GetTrapOpcodeMaxByteSize() const { + return sizeof(m_trap_opcode); } -bool -BreakpointSite::SetTrapOpcode (const uint8_t *trap_opcode, uint32_t trap_opcode_size) -{ - if (trap_opcode_size > 0 && trap_opcode_size <= sizeof(m_trap_opcode)) - { - m_byte_size = trap_opcode_size; - ::memcpy (m_trap_opcode, trap_opcode, trap_opcode_size); - return true; - } - m_byte_size = 0; - return false; +bool BreakpointSite::SetTrapOpcode(const uint8_t *trap_opcode, + uint32_t trap_opcode_size) { + if (trap_opcode_size > 0 && trap_opcode_size <= sizeof(m_trap_opcode)) { + m_byte_size = trap_opcode_size; + ::memcpy(m_trap_opcode, trap_opcode, trap_opcode_size); + return true; + } + m_byte_size = 0; + return false; } -uint8_t * -BreakpointSite::GetSavedOpcodeBytes() -{ - return &m_saved_opcode[0]; -} +uint8_t *BreakpointSite::GetSavedOpcodeBytes() { return &m_saved_opcode[0]; } -const uint8_t * -BreakpointSite::GetSavedOpcodeBytes() const -{ - return &m_saved_opcode[0]; +const uint8_t *BreakpointSite::GetSavedOpcodeBytes() const { + return &m_saved_opcode[0]; } -bool -BreakpointSite::IsEnabled () const -{ - return m_enabled; -} +bool BreakpointSite::IsEnabled() const { return m_enabled; } -void -BreakpointSite::SetEnabled (bool enabled) -{ - m_enabled = enabled; -} +void BreakpointSite::SetEnabled(bool enabled) { m_enabled = enabled; } -void -BreakpointSite::AddOwner (const BreakpointLocationSP &owner) -{ - std::lock_guard<std::recursive_mutex> guard(m_owners_mutex); - m_owners.Add(owner); +void BreakpointSite::AddOwner(const BreakpointLocationSP &owner) { + std::lock_guard<std::recursive_mutex> guard(m_owners_mutex); + m_owners.Add(owner); } -size_t -BreakpointSite::RemoveOwner (lldb::break_id_t break_id, lldb::break_id_t break_loc_id) -{ - std::lock_guard<std::recursive_mutex> guard(m_owners_mutex); - m_owners.Remove(break_id, break_loc_id); - return m_owners.GetSize(); +size_t BreakpointSite::RemoveOwner(lldb::break_id_t break_id, + lldb::break_id_t break_loc_id) { + std::lock_guard<std::recursive_mutex> guard(m_owners_mutex); + m_owners.Remove(break_id, break_loc_id); + return m_owners.GetSize(); } -size_t -BreakpointSite::GetNumberOfOwners () -{ - std::lock_guard<std::recursive_mutex> guard(m_owners_mutex); - return m_owners.GetSize(); +size_t BreakpointSite::GetNumberOfOwners() { + std::lock_guard<std::recursive_mutex> guard(m_owners_mutex); + return m_owners.GetSize(); } -BreakpointLocationSP -BreakpointSite::GetOwnerAtIndex (size_t index) -{ - std::lock_guard<std::recursive_mutex> guard(m_owners_mutex); - return m_owners.GetByIndex (index); +BreakpointLocationSP BreakpointSite::GetOwnerAtIndex(size_t index) { + std::lock_guard<std::recursive_mutex> guard(m_owners_mutex); + return m_owners.GetByIndex(index); } -bool -BreakpointSite::ValidForThisThread (Thread *thread) -{ - std::lock_guard<std::recursive_mutex> guard(m_owners_mutex); - return m_owners.ValidForThisThread(thread); +bool BreakpointSite::ValidForThisThread(Thread *thread) { + std::lock_guard<std::recursive_mutex> guard(m_owners_mutex); + return m_owners.ValidForThisThread(thread); } -void -BreakpointSite::BumpHitCounts() -{ - std::lock_guard<std::recursive_mutex> guard(m_owners_mutex); - for (BreakpointLocationSP loc_sp : m_owners.BreakpointLocations()) - { - loc_sp->BumpHitCount(); - } +void BreakpointSite::BumpHitCounts() { + std::lock_guard<std::recursive_mutex> guard(m_owners_mutex); + for (BreakpointLocationSP loc_sp : m_owners.BreakpointLocations()) { + loc_sp->BumpHitCount(); + } } -bool -BreakpointSite::IntersectsRange(lldb::addr_t addr, size_t size, lldb::addr_t *intersect_addr, size_t *intersect_size, size_t *opcode_offset) const -{ - // We only use software traps for software breakpoints - if (!IsHardware()) - { - if (m_byte_size > 0) - { - const lldb::addr_t bp_end_addr = m_addr + m_byte_size; - const lldb::addr_t end_addr = addr + size; - // Is the breakpoint end address before the passed in start address? - if (bp_end_addr <= addr) - return false; - // Is the breakpoint start address after passed in end address? - if (end_addr <= m_addr) - return false; - if (intersect_addr || intersect_size || opcode_offset) - { - if (m_addr < addr) - { - if (intersect_addr) - *intersect_addr = addr; - if (intersect_size) - *intersect_size = std::min<lldb::addr_t>(bp_end_addr, end_addr) - addr; - if (opcode_offset) - *opcode_offset = addr - m_addr; - } - else - { - if (intersect_addr) - *intersect_addr = m_addr; - if (intersect_size) - *intersect_size = std::min<lldb::addr_t>(bp_end_addr, end_addr) - m_addr; - if (opcode_offset) - *opcode_offset = 0; - } - } - return true; +bool BreakpointSite::IntersectsRange(lldb::addr_t addr, size_t size, + lldb::addr_t *intersect_addr, + size_t *intersect_size, + size_t *opcode_offset) const { + // We only use software traps for software breakpoints + if (!IsHardware()) { + if (m_byte_size > 0) { + const lldb::addr_t bp_end_addr = m_addr + m_byte_size; + const lldb::addr_t end_addr = addr + size; + // Is the breakpoint end address before the passed in start address? + if (bp_end_addr <= addr) + return false; + // Is the breakpoint start address after passed in end address? + if (end_addr <= m_addr) + return false; + if (intersect_addr || intersect_size || opcode_offset) { + if (m_addr < addr) { + if (intersect_addr) + *intersect_addr = addr; + if (intersect_size) + *intersect_size = + std::min<lldb::addr_t>(bp_end_addr, end_addr) - addr; + if (opcode_offset) + *opcode_offset = addr - m_addr; + } else { + if (intersect_addr) + *intersect_addr = m_addr; + if (intersect_size) + *intersect_size = + std::min<lldb::addr_t>(bp_end_addr, end_addr) - m_addr; + if (opcode_offset) + *opcode_offset = 0; } + } + return true; } - return false; + } + return false; } size_t -BreakpointSite::CopyOwnersList (BreakpointLocationCollection &out_collection) -{ - std::lock_guard<std::recursive_mutex> guard(m_owners_mutex); - for (BreakpointLocationSP loc_sp : m_owners.BreakpointLocations()) - { - out_collection.Add(loc_sp); - } - return out_collection.GetSize(); +BreakpointSite::CopyOwnersList(BreakpointLocationCollection &out_collection) { + std::lock_guard<std::recursive_mutex> guard(m_owners_mutex); + for (BreakpointLocationSP loc_sp : m_owners.BreakpointLocations()) { + out_collection.Add(loc_sp); + } + return out_collection.GetSize(); } diff --git a/lldb/source/Breakpoint/BreakpointSiteList.cpp b/lldb/source/Breakpoint/BreakpointSiteList.cpp index de9a5ad0b31..06155ee8b79 100644 --- a/lldb/source/Breakpoint/BreakpointSiteList.cpp +++ b/lldb/source/Breakpoint/BreakpointSiteList.cpp @@ -19,220 +19,188 @@ using namespace lldb; using namespace lldb_private; -BreakpointSiteList::BreakpointSiteList() : m_mutex(), m_bp_site_list() -{ -} +BreakpointSiteList::BreakpointSiteList() : m_mutex(), m_bp_site_list() {} -BreakpointSiteList::~BreakpointSiteList() -{ -} +BreakpointSiteList::~BreakpointSiteList() {} -// Add breakpoint site to the list. However, if the element already exists in the +// Add breakpoint site to the list. However, if the element already exists in +// the // list, then we don't add it, and return LLDB_INVALID_BREAK_ID. -lldb::break_id_t -BreakpointSiteList::Add(const BreakpointSiteSP &bp) -{ - lldb::addr_t bp_site_load_addr = bp->GetLoadAddress(); - std::lock_guard<std::recursive_mutex> guard(m_mutex); - collection::iterator iter = m_bp_site_list.find (bp_site_load_addr); - - if (iter == m_bp_site_list.end()) - { - m_bp_site_list.insert (iter, collection::value_type (bp_site_load_addr, bp)); - return bp->GetID(); - } - else - { - return LLDB_INVALID_BREAK_ID; - } -} +lldb::break_id_t BreakpointSiteList::Add(const BreakpointSiteSP &bp) { + lldb::addr_t bp_site_load_addr = bp->GetLoadAddress(); + std::lock_guard<std::recursive_mutex> guard(m_mutex); + collection::iterator iter = m_bp_site_list.find(bp_site_load_addr); -bool -BreakpointSiteList::ShouldStop (StoppointCallbackContext *context, lldb::break_id_t site_id) -{ - BreakpointSiteSP site_sp (FindByID (site_id)); - if (site_sp) - { - // Let the BreakpointSite decide if it should stop here (could not have - // reached it's target hit count yet, or it could have a callback - // that decided it shouldn't stop (shared library loads/unloads). - return site_sp->ShouldStop (context); - } - // We should stop here since this BreakpointSite isn't valid anymore or it - // doesn't exist. - return true; -} -lldb::break_id_t -BreakpointSiteList::FindIDByAddress (lldb::addr_t addr) -{ - BreakpointSiteSP bp = FindByAddress (addr); - if (bp) - { - //DBLogIf(PD_LOG_BREAKPOINTS, "BreakpointSiteList::%s ( addr = 0x%8.8" PRIx64 " ) => %u", __FUNCTION__, (uint64_t)addr, bp->GetID()); - return bp.get()->GetID(); - } - //DBLogIf(PD_LOG_BREAKPOINTS, "BreakpointSiteList::%s ( addr = 0x%8.8" PRIx64 " ) => NONE", __FUNCTION__, (uint64_t)addr); + if (iter == m_bp_site_list.end()) { + m_bp_site_list.insert(iter, collection::value_type(bp_site_load_addr, bp)); + return bp->GetID(); + } else { return LLDB_INVALID_BREAK_ID; + } +} + +bool BreakpointSiteList::ShouldStop(StoppointCallbackContext *context, + lldb::break_id_t site_id) { + BreakpointSiteSP site_sp(FindByID(site_id)); + if (site_sp) { + // Let the BreakpointSite decide if it should stop here (could not have + // reached it's target hit count yet, or it could have a callback + // that decided it shouldn't stop (shared library loads/unloads). + return site_sp->ShouldStop(context); + } + // We should stop here since this BreakpointSite isn't valid anymore or it + // doesn't exist. + return true; +} +lldb::break_id_t BreakpointSiteList::FindIDByAddress(lldb::addr_t addr) { + BreakpointSiteSP bp = FindByAddress(addr); + if (bp) { + // DBLogIf(PD_LOG_BREAKPOINTS, "BreakpointSiteList::%s ( addr = 0x%8.8" + // PRIx64 " ) => %u", __FUNCTION__, (uint64_t)addr, bp->GetID()); + return bp.get()->GetID(); + } + // DBLogIf(PD_LOG_BREAKPOINTS, "BreakpointSiteList::%s ( addr = 0x%8.8" PRIx64 + // " ) => NONE", __FUNCTION__, (uint64_t)addr); + return LLDB_INVALID_BREAK_ID; +} + +bool BreakpointSiteList::Remove(lldb::break_id_t break_id) { + std::lock_guard<std::recursive_mutex> guard(m_mutex); + collection::iterator pos = GetIDIterator(break_id); // Predicate + if (pos != m_bp_site_list.end()) { + m_bp_site_list.erase(pos); + return true; + } + return false; } -bool -BreakpointSiteList::Remove (lldb::break_id_t break_id) -{ - std::lock_guard<std::recursive_mutex> guard(m_mutex); - collection::iterator pos = GetIDIterator(break_id); // Predicate - if (pos != m_bp_site_list.end()) - { - m_bp_site_list.erase(pos); - return true; - } - return false; -} - -bool -BreakpointSiteList::RemoveByAddress (lldb::addr_t address) -{ - std::lock_guard<std::recursive_mutex> guard(m_mutex); - collection::iterator pos = m_bp_site_list.find(address); - if (pos != m_bp_site_list.end()) - { - m_bp_site_list.erase(pos); - return true; - } - return false; +bool BreakpointSiteList::RemoveByAddress(lldb::addr_t address) { + std::lock_guard<std::recursive_mutex> guard(m_mutex); + collection::iterator pos = m_bp_site_list.find(address); + if (pos != m_bp_site_list.end()) { + m_bp_site_list.erase(pos); + return true; + } + return false; } -class BreakpointSiteIDMatches -{ +class BreakpointSiteIDMatches { public: - BreakpointSiteIDMatches (lldb::break_id_t break_id) : - m_break_id(break_id) - { - } + BreakpointSiteIDMatches(lldb::break_id_t break_id) : m_break_id(break_id) {} - bool operator() (std::pair <lldb::addr_t, BreakpointSiteSP> val_pair) const - { - return m_break_id == val_pair.second.get()->GetID(); - } + bool operator()(std::pair<lldb::addr_t, BreakpointSiteSP> val_pair) const { + return m_break_id == val_pair.second.get()->GetID(); + } private: - const lldb::break_id_t m_break_id; + const lldb::break_id_t m_break_id; }; BreakpointSiteList::collection::iterator -BreakpointSiteList::GetIDIterator (lldb::break_id_t break_id) -{ - std::lock_guard<std::recursive_mutex> guard(m_mutex); - return std::find_if(m_bp_site_list.begin(), m_bp_site_list.end(), // Search full range - BreakpointSiteIDMatches(break_id)); // Predicate +BreakpointSiteList::GetIDIterator(lldb::break_id_t break_id) { + std::lock_guard<std::recursive_mutex> guard(m_mutex); + return std::find_if(m_bp_site_list.begin(), + m_bp_site_list.end(), // Search full range + BreakpointSiteIDMatches(break_id)); // Predicate } BreakpointSiteList::collection::const_iterator -BreakpointSiteList::GetIDConstIterator (lldb::break_id_t break_id) const -{ - std::lock_guard<std::recursive_mutex> guard(m_mutex); - return std::find_if(m_bp_site_list.begin(), m_bp_site_list.end(), // Search full range - BreakpointSiteIDMatches(break_id)); // Predicate +BreakpointSiteList::GetIDConstIterator(lldb::break_id_t break_id) const { + std::lock_guard<std::recursive_mutex> guard(m_mutex); + return std::find_if(m_bp_site_list.begin(), + m_bp_site_list.end(), // Search full range + BreakpointSiteIDMatches(break_id)); // Predicate } -BreakpointSiteSP -BreakpointSiteList::FindByID (lldb::break_id_t break_id) -{ - std::lock_guard<std::recursive_mutex> guard(m_mutex); - BreakpointSiteSP stop_sp; - collection::iterator pos = GetIDIterator(break_id); - if (pos != m_bp_site_list.end()) - stop_sp = pos->second; +BreakpointSiteSP BreakpointSiteList::FindByID(lldb::break_id_t break_id) { + std::lock_guard<std::recursive_mutex> guard(m_mutex); + BreakpointSiteSP stop_sp; + collection::iterator pos = GetIDIterator(break_id); + if (pos != m_bp_site_list.end()) + stop_sp = pos->second; - return stop_sp; + return stop_sp; } const BreakpointSiteSP -BreakpointSiteList::FindByID (lldb::break_id_t break_id) const -{ - std::lock_guard<std::recursive_mutex> guard(m_mutex); - BreakpointSiteSP stop_sp; - collection::const_iterator pos = GetIDConstIterator(break_id); - if (pos != m_bp_site_list.end()) - stop_sp = pos->second; - - return stop_sp; -} - -BreakpointSiteSP -BreakpointSiteList::FindByAddress (lldb::addr_t addr) -{ - BreakpointSiteSP found_sp; - std::lock_guard<std::recursive_mutex> guard(m_mutex); - collection::iterator iter = m_bp_site_list.find(addr); - if (iter != m_bp_site_list.end()) - found_sp = iter->second; - return found_sp; -} - -bool -BreakpointSiteList::BreakpointSiteContainsBreakpoint (lldb::break_id_t bp_site_id, lldb::break_id_t bp_id) -{ - std::lock_guard<std::recursive_mutex> guard(m_mutex); - collection::const_iterator pos = GetIDConstIterator(bp_site_id); - if (pos != m_bp_site_list.end()) - return pos->second->IsBreakpointAtThisSite (bp_id); - +BreakpointSiteList::FindByID(lldb::break_id_t break_id) const { + std::lock_guard<std::recursive_mutex> guard(m_mutex); + BreakpointSiteSP stop_sp; + collection::const_iterator pos = GetIDConstIterator(break_id); + if (pos != m_bp_site_list.end()) + stop_sp = pos->second; + + return stop_sp; +} + +BreakpointSiteSP BreakpointSiteList::FindByAddress(lldb::addr_t addr) { + BreakpointSiteSP found_sp; + std::lock_guard<std::recursive_mutex> guard(m_mutex); + collection::iterator iter = m_bp_site_list.find(addr); + if (iter != m_bp_site_list.end()) + found_sp = iter->second; + return found_sp; +} + +bool BreakpointSiteList::BreakpointSiteContainsBreakpoint( + lldb::break_id_t bp_site_id, lldb::break_id_t bp_id) { + std::lock_guard<std::recursive_mutex> guard(m_mutex); + collection::const_iterator pos = GetIDConstIterator(bp_site_id); + if (pos != m_bp_site_list.end()) + return pos->second->IsBreakpointAtThisSite(bp_id); + + return false; +} + +void BreakpointSiteList::Dump(Stream *s) const { + s->Printf("%p: ", static_cast<const void *>(this)); + // s->Indent(); + s->Printf("BreakpointSiteList with %u BreakpointSites:\n", + (uint32_t)m_bp_site_list.size()); + s->IndentMore(); + collection::const_iterator pos; + collection::const_iterator end = m_bp_site_list.end(); + for (pos = m_bp_site_list.begin(); pos != end; ++pos) + pos->second.get()->Dump(s); + s->IndentLess(); +} + +void BreakpointSiteList::ForEach( + std::function<void(BreakpointSite *)> const &callback) { + std::lock_guard<std::recursive_mutex> guard(m_mutex); + for (auto pair : m_bp_site_list) + callback(pair.second.get()); +} + +bool BreakpointSiteList::FindInRange(lldb::addr_t lower_bound, + lldb::addr_t upper_bound, + BreakpointSiteList &bp_site_list) const { + if (lower_bound > upper_bound) return false; -} -void -BreakpointSiteList::Dump (Stream *s) const -{ - s->Printf("%p: ", static_cast<const void*>(this)); - //s->Indent(); - s->Printf("BreakpointSiteList with %u BreakpointSites:\n", (uint32_t)m_bp_site_list.size()); - s->IndentMore(); - collection::const_iterator pos; - collection::const_iterator end = m_bp_site_list.end(); - for (pos = m_bp_site_list.begin(); pos != end; ++pos) - pos->second.get()->Dump(s); - s->IndentLess(); -} - -void -BreakpointSiteList::ForEach (std::function <void(BreakpointSite *)> const &callback) -{ - std::lock_guard<std::recursive_mutex> guard(m_mutex); - for (auto pair : m_bp_site_list) - callback (pair.second.get()); -} + std::lock_guard<std::recursive_mutex> guard(m_mutex); + collection::const_iterator lower, upper, pos; + lower = m_bp_site_list.lower_bound(lower_bound); + if (lower == m_bp_site_list.end() || (*lower).first >= upper_bound) + return false; -bool -BreakpointSiteList::FindInRange (lldb::addr_t lower_bound, lldb::addr_t upper_bound, BreakpointSiteList &bp_site_list) const -{ - if (lower_bound > upper_bound) - return false; - - std::lock_guard<std::recursive_mutex> guard(m_mutex); - collection::const_iterator lower, upper, pos; - lower = m_bp_site_list.lower_bound(lower_bound); - if (lower == m_bp_site_list.end() - || (*lower).first >= upper_bound) - return false; - - // This is one tricky bit. The breakpoint might overlap the bottom end of the range. So we grab the - // breakpoint prior to the lower bound, and check that that + its byte size isn't in our range. - if (lower != m_bp_site_list.begin()) - { - collection::const_iterator prev_pos = lower; - prev_pos--; - const BreakpointSiteSP &prev_bp = (*prev_pos).second; - if (prev_bp->GetLoadAddress() + prev_bp->GetByteSize() > lower_bound) - bp_site_list.Add (prev_bp); - - } - - upper = m_bp_site_list.upper_bound(upper_bound); - - for (pos = lower; pos != upper; pos++) - { - bp_site_list.Add ((*pos).second); - } - return true; + // This is one tricky bit. The breakpoint might overlap the bottom end of the + // range. So we grab the + // breakpoint prior to the lower bound, and check that that + its byte size + // isn't in our range. + if (lower != m_bp_site_list.begin()) { + collection::const_iterator prev_pos = lower; + prev_pos--; + const BreakpointSiteSP &prev_bp = (*prev_pos).second; + if (prev_bp->GetLoadAddress() + prev_bp->GetByteSize() > lower_bound) + bp_site_list.Add(prev_bp); + } + + upper = m_bp_site_list.upper_bound(upper_bound); + + for (pos = lower; pos != upper; pos++) { + bp_site_list.Add((*pos).second); + } + return true; } diff --git a/lldb/source/Breakpoint/Stoppoint.cpp b/lldb/source/Breakpoint/Stoppoint.cpp index 583ab47005f..dbc832b4307 100644 --- a/lldb/source/Breakpoint/Stoppoint.cpp +++ b/lldb/source/Breakpoint/Stoppoint.cpp @@ -7,8 +7,8 @@ // //===----------------------------------------------------------------------===// -#include "lldb/lldb-private.h" #include "lldb/Breakpoint/Stoppoint.h" +#include "lldb/lldb-private.h" // C Includes // C++ Includes @@ -21,26 +21,13 @@ using namespace lldb_private; //---------------------------------------------------------------------- // Stoppoint constructor //---------------------------------------------------------------------- -Stoppoint::Stoppoint() : - m_bid (LLDB_INVALID_BREAK_ID) -{ -} +Stoppoint::Stoppoint() : m_bid(LLDB_INVALID_BREAK_ID) {} //---------------------------------------------------------------------- // Destructor //---------------------------------------------------------------------- -Stoppoint::~Stoppoint() -{ -} +Stoppoint::~Stoppoint() {} -break_id_t -Stoppoint::GetID () const -{ - return m_bid; -} +break_id_t Stoppoint::GetID() const { return m_bid; } -void -Stoppoint::SetID (break_id_t bid) -{ - m_bid = bid; -} +void Stoppoint::SetID(break_id_t bid) { m_bid = bid; } diff --git a/lldb/source/Breakpoint/StoppointCallbackContext.cpp b/lldb/source/Breakpoint/StoppointCallbackContext.cpp index 9932843714f..3d24eb78c45 100644 --- a/lldb/source/Breakpoint/StoppointCallbackContext.cpp +++ b/lldb/source/Breakpoint/StoppointCallbackContext.cpp @@ -15,24 +15,15 @@ using namespace lldb_private; -StoppointCallbackContext::StoppointCallbackContext() : - event (nullptr), - exe_ctx_ref (), - is_synchronous (false) -{ -} +StoppointCallbackContext::StoppointCallbackContext() + : event(nullptr), exe_ctx_ref(), is_synchronous(false) {} -StoppointCallbackContext::StoppointCallbackContext(Event *e, const ExecutionContext &exe_ctx, bool synchronously) : - event (e), - exe_ctx_ref (exe_ctx), - is_synchronous(synchronously) -{ -} +StoppointCallbackContext::StoppointCallbackContext( + Event *e, const ExecutionContext &exe_ctx, bool synchronously) + : event(e), exe_ctx_ref(exe_ctx), is_synchronous(synchronously) {} -void -StoppointCallbackContext::Clear() -{ - event = nullptr; - exe_ctx_ref.Clear(); - is_synchronous = false; +void StoppointCallbackContext::Clear() { + event = nullptr; + exe_ctx_ref.Clear(); + is_synchronous = false; } diff --git a/lldb/source/Breakpoint/StoppointLocation.cpp b/lldb/source/Breakpoint/StoppointLocation.cpp index 35e5979bd9e..d624ddbfa51 100644 --- a/lldb/source/Breakpoint/StoppointLocation.cpp +++ b/lldb/source/Breakpoint/StoppointLocation.cpp @@ -20,36 +20,22 @@ using namespace lldb_private; //---------------------------------------------------------------------- // StoppointLocation constructor //---------------------------------------------------------------------- -StoppointLocation::StoppointLocation (break_id_t bid, addr_t addr, bool hardware) : - m_loc_id(bid), - m_addr(addr), - m_hardware(hardware), - m_hardware_index(LLDB_INVALID_INDEX32), - m_byte_size(0), - m_hit_count(0) -{ -} +StoppointLocation::StoppointLocation(break_id_t bid, addr_t addr, bool hardware) + : m_loc_id(bid), m_addr(addr), m_hardware(hardware), + m_hardware_index(LLDB_INVALID_INDEX32), m_byte_size(0), m_hit_count(0) {} -StoppointLocation::StoppointLocation (break_id_t bid, addr_t addr, uint32_t byte_size, bool hardware) : - m_loc_id(bid), - m_addr(addr), - m_hardware(hardware), - m_hardware_index(LLDB_INVALID_INDEX32), - m_byte_size(byte_size), - m_hit_count(0) -{ -} +StoppointLocation::StoppointLocation(break_id_t bid, addr_t addr, + uint32_t byte_size, bool hardware) + : m_loc_id(bid), m_addr(addr), m_hardware(hardware), + m_hardware_index(LLDB_INVALID_INDEX32), m_byte_size(byte_size), + m_hit_count(0) {} //---------------------------------------------------------------------- // Destructor //---------------------------------------------------------------------- -StoppointLocation::~StoppointLocation() -{ -} +StoppointLocation::~StoppointLocation() {} -void -StoppointLocation::DecrementHitCount () -{ - assert (m_hit_count > 0); - --m_hit_count; +void StoppointLocation::DecrementHitCount() { + assert(m_hit_count > 0); + --m_hit_count; } diff --git a/lldb/source/Breakpoint/Watchpoint.cpp b/lldb/source/Breakpoint/Watchpoint.cpp index 00a328e3039..15fcff68399 100644 --- a/lldb/source/Breakpoint/Watchpoint.cpp +++ b/lldb/source/Breakpoint/Watchpoint.cpp @@ -18,487 +18,370 @@ #include "lldb/Core/Value.h" #include "lldb/Core/ValueObject.h" #include "lldb/Core/ValueObjectMemory.h" +#include "lldb/Expression/UserExpression.h" #include "lldb/Symbol/ClangASTContext.h" #include "lldb/Target/Process.h" #include "lldb/Target/Target.h" #include "lldb/Target/ThreadSpec.h" -#include "lldb/Expression/UserExpression.h" using namespace lldb; using namespace lldb_private; -Watchpoint::Watchpoint (Target& target, lldb::addr_t addr, uint32_t size, const CompilerType *type, bool hardware) : - StoppointLocation (0, addr, size, hardware), - m_target(target), - m_enabled(false), - m_is_hardware(hardware), - m_is_watch_variable(false), - m_is_ephemeral(false), - m_disabled_count(0), - m_watch_read(0), - m_watch_write(0), - m_watch_was_read(0), - m_watch_was_written(0), - m_ignore_count(0), - m_false_alarms(0), - m_decl_str(), - m_watch_spec_str(), - m_type(), - m_error(), - m_options (), - m_being_created(true) -{ - if (type && type->IsValid()) - m_type = *type; - else - { - // If we don't have a known type, then we force it to unsigned int of the right size. - ClangASTContext *ast_context = target.GetScratchClangASTContext(); - m_type = ast_context->GetBuiltinTypeForEncodingAndBitSize(eEncodingUint, 8 * size); - } - - // Set the initial value of the watched variable: - if (m_target.GetProcessSP()) - { - ExecutionContext exe_ctx; - m_target.GetProcessSP()->CalculateExecutionContext(exe_ctx); - CaptureWatchedValue (exe_ctx); - } - m_being_created = false; +Watchpoint::Watchpoint(Target &target, lldb::addr_t addr, uint32_t size, + const CompilerType *type, bool hardware) + : StoppointLocation(0, addr, size, hardware), m_target(target), + m_enabled(false), m_is_hardware(hardware), m_is_watch_variable(false), + m_is_ephemeral(false), m_disabled_count(0), m_watch_read(0), + m_watch_write(0), m_watch_was_read(0), m_watch_was_written(0), + m_ignore_count(0), m_false_alarms(0), m_decl_str(), m_watch_spec_str(), + m_type(), m_error(), m_options(), m_being_created(true) { + if (type && type->IsValid()) + m_type = *type; + else { + // If we don't have a known type, then we force it to unsigned int of the + // right size. + ClangASTContext *ast_context = target.GetScratchClangASTContext(); + m_type = ast_context->GetBuiltinTypeForEncodingAndBitSize(eEncodingUint, + 8 * size); + } + + // Set the initial value of the watched variable: + if (m_target.GetProcessSP()) { + ExecutionContext exe_ctx; + m_target.GetProcessSP()->CalculateExecutionContext(exe_ctx); + CaptureWatchedValue(exe_ctx); + } + m_being_created = false; } Watchpoint::~Watchpoint() = default; // This function is used when "baton" doesn't need to be freed -void -Watchpoint::SetCallback (WatchpointHitCallback callback, void *baton, bool is_synchronous) -{ - // The default "Baton" class will keep a copy of "baton" and won't free - // or delete it when it goes goes out of scope. - m_options.SetCallback(callback, BatonSP (new Baton(baton)), is_synchronous); - - SendWatchpointChangedEvent (eWatchpointEventTypeCommandChanged); +void Watchpoint::SetCallback(WatchpointHitCallback callback, void *baton, + bool is_synchronous) { + // The default "Baton" class will keep a copy of "baton" and won't free + // or delete it when it goes goes out of scope. + m_options.SetCallback(callback, BatonSP(new Baton(baton)), is_synchronous); + + SendWatchpointChangedEvent(eWatchpointEventTypeCommandChanged); } -// This function is used when a baton needs to be freed and therefore is +// This function is used when a baton needs to be freed and therefore is // contained in a "Baton" subclass. -void -Watchpoint::SetCallback (WatchpointHitCallback callback, const BatonSP &callback_baton_sp, bool is_synchronous) -{ - m_options.SetCallback(callback, callback_baton_sp, is_synchronous); - SendWatchpointChangedEvent (eWatchpointEventTypeCommandChanged); +void Watchpoint::SetCallback(WatchpointHitCallback callback, + const BatonSP &callback_baton_sp, + bool is_synchronous) { + m_options.SetCallback(callback, callback_baton_sp, is_synchronous); + SendWatchpointChangedEvent(eWatchpointEventTypeCommandChanged); } -void -Watchpoint::ClearCallback () -{ - m_options.ClearCallback (); - SendWatchpointChangedEvent (eWatchpointEventTypeCommandChanged); +void Watchpoint::ClearCallback() { + m_options.ClearCallback(); + SendWatchpointChangedEvent(eWatchpointEventTypeCommandChanged); } -void -Watchpoint::SetDeclInfo (const std::string &str) -{ - m_decl_str = str; -} +void Watchpoint::SetDeclInfo(const std::string &str) { m_decl_str = str; } -std::string -Watchpoint::GetWatchSpec() -{ - return m_watch_spec_str; -} +std::string Watchpoint::GetWatchSpec() { return m_watch_spec_str; } -void -Watchpoint::SetWatchSpec (const std::string &str) -{ - m_watch_spec_str = str; +void Watchpoint::SetWatchSpec(const std::string &str) { + m_watch_spec_str = str; } // Override default impl of StoppointLocation::IsHardware() since m_is_hardware // member field is more accurate. -bool -Watchpoint::IsHardware () const -{ - return m_is_hardware; -} - -bool -Watchpoint::IsWatchVariable() const -{ - return m_is_watch_variable; -} - -void -Watchpoint::SetWatchVariable(bool val) -{ - m_is_watch_variable = val; -} - -bool -Watchpoint::CaptureWatchedValue (const ExecutionContext &exe_ctx) -{ - ConstString watch_name("$__lldb__watch_value"); - m_old_value_sp = m_new_value_sp; - Address watch_address(GetLoadAddress()); - if (!m_type.IsValid()) - { - // Don't know how to report new & old values, since we couldn't make a scalar type for this watchpoint. - // This works around an assert in ValueObjectMemory::Create. - // FIXME: This should not happen, but if it does in some case we care about, - // we can go grab the value raw and print it as unsigned. - return false; - } - m_new_value_sp = ValueObjectMemory::Create (exe_ctx.GetBestExecutionContextScope(), watch_name.AsCString(), watch_address, m_type); - m_new_value_sp = m_new_value_sp->CreateConstantValue(watch_name); - return (m_new_value_sp && m_new_value_sp->GetError().Success()); -} - -void -Watchpoint::IncrementFalseAlarmsAndReviseHitCount() -{ - ++m_false_alarms; - if (m_false_alarms) - { - if (m_hit_count >= m_false_alarms) - { - m_hit_count -= m_false_alarms; - m_false_alarms = 0; - } - else - { - m_false_alarms -= m_hit_count; - m_hit_count = 0; - } +bool Watchpoint::IsHardware() const { return m_is_hardware; } + +bool Watchpoint::IsWatchVariable() const { return m_is_watch_variable; } + +void Watchpoint::SetWatchVariable(bool val) { m_is_watch_variable = val; } + +bool Watchpoint::CaptureWatchedValue(const ExecutionContext &exe_ctx) { + ConstString watch_name("$__lldb__watch_value"); + m_old_value_sp = m_new_value_sp; + Address watch_address(GetLoadAddress()); + if (!m_type.IsValid()) { + // Don't know how to report new & old values, since we couldn't make a + // scalar type for this watchpoint. + // This works around an assert in ValueObjectMemory::Create. + // FIXME: This should not happen, but if it does in some case we care about, + // we can go grab the value raw and print it as unsigned. + return false; + } + m_new_value_sp = + ValueObjectMemory::Create(exe_ctx.GetBestExecutionContextScope(), + watch_name.AsCString(), watch_address, m_type); + m_new_value_sp = m_new_value_sp->CreateConstantValue(watch_name); + return (m_new_value_sp && m_new_value_sp->GetError().Success()); +} + +void Watchpoint::IncrementFalseAlarmsAndReviseHitCount() { + ++m_false_alarms; + if (m_false_alarms) { + if (m_hit_count >= m_false_alarms) { + m_hit_count -= m_false_alarms; + m_false_alarms = 0; + } else { + m_false_alarms -= m_hit_count; + m_hit_count = 0; } + } } // RETURNS - true if we should stop at this breakpoint, false if we // should continue. -bool -Watchpoint::ShouldStop (StoppointCallbackContext *context) -{ - IncrementHitCount(); +bool Watchpoint::ShouldStop(StoppointCallbackContext *context) { + IncrementHitCount(); - if (!IsEnabled()) - return false; + if (!IsEnabled()) + return false; - return true; + return true; } -void -Watchpoint::GetDescription (Stream *s, lldb::DescriptionLevel level) -{ - DumpWithLevel(s, level); +void Watchpoint::GetDescription(Stream *s, lldb::DescriptionLevel level) { + DumpWithLevel(s, level); } -void -Watchpoint::Dump(Stream *s) const -{ - DumpWithLevel(s, lldb::eDescriptionLevelBrief); +void Watchpoint::Dump(Stream *s) const { + DumpWithLevel(s, lldb::eDescriptionLevelBrief); } -// If prefix is nullptr, we display the watch id and ignore the prefix altogether. -void -Watchpoint::DumpSnapshots(Stream *s, const char *prefix) const -{ - if (!prefix) - { - s->Printf("\nWatchpoint %u hit:", GetID()); - prefix = ""; - } +// If prefix is nullptr, we display the watch id and ignore the prefix +// altogether. +void Watchpoint::DumpSnapshots(Stream *s, const char *prefix) const { + if (!prefix) { + s->Printf("\nWatchpoint %u hit:", GetID()); + prefix = ""; + } - if (m_old_value_sp) - { - const char *old_value_cstr = m_old_value_sp->GetValueAsCString(); - if (old_value_cstr && old_value_cstr[0]) - s->Printf("\n%sold value: %s", prefix, old_value_cstr); - else - { - const char *old_summary_cstr = m_old_value_sp-> GetSummaryAsCString(); - if (old_summary_cstr && old_summary_cstr[0]) - s->Printf("\n%sold value: %s", prefix, old_summary_cstr); - } + if (m_old_value_sp) { + const char *old_value_cstr = m_old_value_sp->GetValueAsCString(); + if (old_value_cstr && old_value_cstr[0]) + s->Printf("\n%sold value: %s", prefix, old_value_cstr); + else { + const char *old_summary_cstr = m_old_value_sp->GetSummaryAsCString(); + if (old_summary_cstr && old_summary_cstr[0]) + s->Printf("\n%sold value: %s", prefix, old_summary_cstr); } - - if (m_new_value_sp) - { - const char *new_value_cstr = m_new_value_sp->GetValueAsCString(); - if (new_value_cstr && new_value_cstr[0]) - s->Printf("\n%snew value: %s", prefix, new_value_cstr); - else - { - const char *new_summary_cstr = m_new_value_sp-> GetSummaryAsCString(); - if (new_summary_cstr && new_summary_cstr[0]) - s->Printf("\n%snew value: %s", prefix, new_summary_cstr); - } + } + + if (m_new_value_sp) { + const char *new_value_cstr = m_new_value_sp->GetValueAsCString(); + if (new_value_cstr && new_value_cstr[0]) + s->Printf("\n%snew value: %s", prefix, new_value_cstr); + else { + const char *new_summary_cstr = m_new_value_sp->GetSummaryAsCString(); + if (new_summary_cstr && new_summary_cstr[0]) + s->Printf("\n%snew value: %s", prefix, new_summary_cstr); } + } } -void -Watchpoint::DumpWithLevel(Stream *s, lldb::DescriptionLevel description_level) const -{ - if (s == nullptr) - return; - - assert(description_level >= lldb::eDescriptionLevelBrief && - description_level <= lldb::eDescriptionLevelVerbose); - - s->Printf("Watchpoint %u: addr = 0x%8.8" PRIx64 " size = %u state = %s type = %s%s", - GetID(), - GetLoadAddress(), - m_byte_size, - IsEnabled() ? "enabled" : "disabled", - m_watch_read ? "r" : "", - m_watch_write ? "w" : ""); - - if (description_level >= lldb::eDescriptionLevelFull) { - if (!m_decl_str.empty()) - s->Printf("\n declare @ '%s'", m_decl_str.c_str()); - if (!m_watch_spec_str.empty()) - s->Printf("\n watchpoint spec = '%s'", m_watch_spec_str.c_str()); - - // Dump the snapshots we have taken. - DumpSnapshots(s, " "); - - if (GetConditionText()) - s->Printf("\n condition = '%s'", GetConditionText()); - m_options.GetCallbackDescription(s, description_level); - } +void Watchpoint::DumpWithLevel(Stream *s, + lldb::DescriptionLevel description_level) const { + if (s == nullptr) + return; - if (description_level >= lldb::eDescriptionLevelVerbose) - { - s->Printf("\n hw_index = %i hit_count = %-4u ignore_count = %-4u", - GetHardwareIndex(), - GetHitCount(), - GetIgnoreCount()); - } -} + assert(description_level >= lldb::eDescriptionLevelBrief && + description_level <= lldb::eDescriptionLevelVerbose); -bool -Watchpoint::IsEnabled() const -{ - return m_enabled; -} + s->Printf("Watchpoint %u: addr = 0x%8.8" PRIx64 + " size = %u state = %s type = %s%s", + GetID(), GetLoadAddress(), m_byte_size, + IsEnabled() ? "enabled" : "disabled", m_watch_read ? "r" : "", + m_watch_write ? "w" : ""); -// Within StopInfo.cpp, we purposely turn on the ephemeral mode right before temporarily disable the watchpoint -// in order to perform possible watchpoint actions without triggering further watchpoint events. -// After the temporary disabled watchpoint is enabled, we then turn off the ephemeral mode. + if (description_level >= lldb::eDescriptionLevelFull) { + if (!m_decl_str.empty()) + s->Printf("\n declare @ '%s'", m_decl_str.c_str()); + if (!m_watch_spec_str.empty()) + s->Printf("\n watchpoint spec = '%s'", m_watch_spec_str.c_str()); -void -Watchpoint::TurnOnEphemeralMode() -{ - m_is_ephemeral = true; -} + // Dump the snapshots we have taken. + DumpSnapshots(s, " "); -void -Watchpoint::TurnOffEphemeralMode() -{ - m_is_ephemeral = false; - // Leaving ephemeral mode, reset the m_disabled_count! - m_disabled_count = 0; -} + if (GetConditionText()) + s->Printf("\n condition = '%s'", GetConditionText()); + m_options.GetCallbackDescription(s, description_level); + } -bool -Watchpoint::IsDisabledDuringEphemeralMode() -{ - return m_disabled_count > 1; + if (description_level >= lldb::eDescriptionLevelVerbose) { + s->Printf("\n hw_index = %i hit_count = %-4u ignore_count = %-4u", + GetHardwareIndex(), GetHitCount(), GetIgnoreCount()); + } } -void -Watchpoint::SetEnabled(bool enabled, bool notify) -{ - if (!enabled) - { - if (!m_is_ephemeral) - SetHardwareIndex(LLDB_INVALID_INDEX32); - else - ++m_disabled_count; - - // Don't clear the snapshots for now. - // Within StopInfo.cpp, we purposely do disable/enable watchpoint while performing watchpoint actions. - } - bool changed = enabled != m_enabled; - m_enabled = enabled; - if (notify && !m_is_ephemeral && changed) - SendWatchpointChangedEvent (enabled ? eWatchpointEventTypeEnabled : eWatchpointEventTypeDisabled); -} +bool Watchpoint::IsEnabled() const { return m_enabled; } -void -Watchpoint::SetWatchpointType (uint32_t type, bool notify) -{ - int old_watch_read = m_watch_read; - int old_watch_write = m_watch_write; - m_watch_read = (type & LLDB_WATCH_TYPE_READ) != 0; - m_watch_write = (type & LLDB_WATCH_TYPE_WRITE) != 0; - if (notify && (old_watch_read != m_watch_read || old_watch_write != m_watch_write)) - SendWatchpointChangedEvent (eWatchpointEventTypeTypeChanged); -} +// Within StopInfo.cpp, we purposely turn on the ephemeral mode right before +// temporarily disable the watchpoint +// in order to perform possible watchpoint actions without triggering further +// watchpoint events. +// After the temporary disabled watchpoint is enabled, we then turn off the +// ephemeral mode. + +void Watchpoint::TurnOnEphemeralMode() { m_is_ephemeral = true; } -bool -Watchpoint::WatchpointRead () const -{ - return m_watch_read != 0; +void Watchpoint::TurnOffEphemeralMode() { + m_is_ephemeral = false; + // Leaving ephemeral mode, reset the m_disabled_count! + m_disabled_count = 0; } -bool -Watchpoint::WatchpointWrite () const -{ - return m_watch_write != 0; +bool Watchpoint::IsDisabledDuringEphemeralMode() { + return m_disabled_count > 1; } -uint32_t -Watchpoint::GetIgnoreCount () const -{ - return m_ignore_count; +void Watchpoint::SetEnabled(bool enabled, bool notify) { + if (!enabled) { + if (!m_is_ephemeral) + SetHardwareIndex(LLDB_INVALID_INDEX32); + else + ++m_disabled_count; + + // Don't clear the snapshots for now. + // Within StopInfo.cpp, we purposely do disable/enable watchpoint while + // performing watchpoint actions. + } + bool changed = enabled != m_enabled; + m_enabled = enabled; + if (notify && !m_is_ephemeral && changed) + SendWatchpointChangedEvent(enabled ? eWatchpointEventTypeEnabled + : eWatchpointEventTypeDisabled); } -void -Watchpoint::SetIgnoreCount (uint32_t n) -{ - bool changed = m_ignore_count != n; - m_ignore_count = n; - if (changed) - SendWatchpointChangedEvent (eWatchpointEventTypeIgnoreChanged); +void Watchpoint::SetWatchpointType(uint32_t type, bool notify) { + int old_watch_read = m_watch_read; + int old_watch_write = m_watch_write; + m_watch_read = (type & LLDB_WATCH_TYPE_READ) != 0; + m_watch_write = (type & LLDB_WATCH_TYPE_WRITE) != 0; + if (notify && + (old_watch_read != m_watch_read || old_watch_write != m_watch_write)) + SendWatchpointChangedEvent(eWatchpointEventTypeTypeChanged); } -bool -Watchpoint::InvokeCallback (StoppointCallbackContext *context) -{ - return m_options.InvokeCallback (context, GetID()); +bool Watchpoint::WatchpointRead() const { return m_watch_read != 0; } + +bool Watchpoint::WatchpointWrite() const { return m_watch_write != 0; } + +uint32_t Watchpoint::GetIgnoreCount() const { return m_ignore_count; } + +void Watchpoint::SetIgnoreCount(uint32_t n) { + bool changed = m_ignore_count != n; + m_ignore_count = n; + if (changed) + SendWatchpointChangedEvent(eWatchpointEventTypeIgnoreChanged); } -void -Watchpoint::SetCondition (const char *condition) -{ - if (condition == nullptr || condition[0] == '\0') - { - if (m_condition_ap.get()) - m_condition_ap.reset(); - } - else - { - // Pass nullptr for expr_prefix (no translation-unit level definitions). - Error error; - m_condition_ap.reset(m_target.GetUserExpressionForLanguage(condition, - nullptr, - lldb::eLanguageTypeUnknown, - UserExpression::eResultTypeAny, - EvaluateExpressionOptions(), - error)); - if (error.Fail()) - { - // FIXME: Log something... - m_condition_ap.reset(); - } - } - SendWatchpointChangedEvent (eWatchpointEventTypeConditionChanged); +bool Watchpoint::InvokeCallback(StoppointCallbackContext *context) { + return m_options.InvokeCallback(context, GetID()); } -const char * -Watchpoint::GetConditionText () const -{ +void Watchpoint::SetCondition(const char *condition) { + if (condition == nullptr || condition[0] == '\0') { if (m_condition_ap.get()) - return m_condition_ap->GetUserText(); - else - return nullptr; + m_condition_ap.reset(); + } else { + // Pass nullptr for expr_prefix (no translation-unit level definitions). + Error error; + m_condition_ap.reset(m_target.GetUserExpressionForLanguage( + condition, nullptr, lldb::eLanguageTypeUnknown, + UserExpression::eResultTypeAny, EvaluateExpressionOptions(), error)); + if (error.Fail()) { + // FIXME: Log something... + m_condition_ap.reset(); + } + } + SendWatchpointChangedEvent(eWatchpointEventTypeConditionChanged); } -void -Watchpoint::SendWatchpointChangedEvent (lldb::WatchpointEventType eventKind) -{ - if (!m_being_created - && GetTarget().EventTypeHasListeners(Target::eBroadcastBitWatchpointChanged)) - { - WatchpointEventData *data = new Watchpoint::WatchpointEventData (eventKind, shared_from_this()); - GetTarget().BroadcastEvent (Target::eBroadcastBitWatchpointChanged, data); - } +const char *Watchpoint::GetConditionText() const { + if (m_condition_ap.get()) + return m_condition_ap->GetUserText(); + else + return nullptr; } -void -Watchpoint::SendWatchpointChangedEvent (WatchpointEventData *data) -{ - if (data == nullptr) - return; - - if (!m_being_created - && GetTarget().EventTypeHasListeners(Target::eBroadcastBitWatchpointChanged)) - GetTarget().BroadcastEvent (Target::eBroadcastBitWatchpointChanged, data); - else - delete data; +void Watchpoint::SendWatchpointChangedEvent( + lldb::WatchpointEventType eventKind) { + if (!m_being_created && + GetTarget().EventTypeHasListeners( + Target::eBroadcastBitWatchpointChanged)) { + WatchpointEventData *data = + new Watchpoint::WatchpointEventData(eventKind, shared_from_this()); + GetTarget().BroadcastEvent(Target::eBroadcastBitWatchpointChanged, data); + } } -Watchpoint::WatchpointEventData::WatchpointEventData (WatchpointEventType sub_type, - const WatchpointSP &new_watchpoint_sp) : - EventData (), - m_watchpoint_event (sub_type), - m_new_watchpoint_sp (new_watchpoint_sp) -{ +void Watchpoint::SendWatchpointChangedEvent(WatchpointEventData *data) { + if (data == nullptr) + return; + + if (!m_being_created && + GetTarget().EventTypeHasListeners(Target::eBroadcastBitWatchpointChanged)) + GetTarget().BroadcastEvent(Target::eBroadcastBitWatchpointChanged, data); + else + delete data; } +Watchpoint::WatchpointEventData::WatchpointEventData( + WatchpointEventType sub_type, const WatchpointSP &new_watchpoint_sp) + : EventData(), m_watchpoint_event(sub_type), + m_new_watchpoint_sp(new_watchpoint_sp) {} + Watchpoint::WatchpointEventData::~WatchpointEventData() = default; -const ConstString & -Watchpoint::WatchpointEventData::GetFlavorString () -{ - static ConstString g_flavor ("Watchpoint::WatchpointEventData"); - return g_flavor; +const ConstString &Watchpoint::WatchpointEventData::GetFlavorString() { + static ConstString g_flavor("Watchpoint::WatchpointEventData"); + return g_flavor; } -const ConstString & -Watchpoint::WatchpointEventData::GetFlavor () const -{ - return WatchpointEventData::GetFlavorString (); +const ConstString &Watchpoint::WatchpointEventData::GetFlavor() const { + return WatchpointEventData::GetFlavorString(); } -WatchpointSP & -Watchpoint::WatchpointEventData::GetWatchpoint () -{ - return m_new_watchpoint_sp; +WatchpointSP &Watchpoint::WatchpointEventData::GetWatchpoint() { + return m_new_watchpoint_sp; } WatchpointEventType -Watchpoint::WatchpointEventData::GetWatchpointEventType () const -{ - return m_watchpoint_event; +Watchpoint::WatchpointEventData::GetWatchpointEventType() const { + return m_watchpoint_event; } -void -Watchpoint::WatchpointEventData::Dump (Stream *s) const -{ -} +void Watchpoint::WatchpointEventData::Dump(Stream *s) const {} const Watchpoint::WatchpointEventData * -Watchpoint::WatchpointEventData::GetEventDataFromEvent (const Event *event) -{ - if (event) - { - const EventData *event_data = event->GetData(); - if (event_data && event_data->GetFlavor() == WatchpointEventData::GetFlavorString()) - return static_cast <const WatchpointEventData *> (event->GetData()); - } - return nullptr; +Watchpoint::WatchpointEventData::GetEventDataFromEvent(const Event *event) { + if (event) { + const EventData *event_data = event->GetData(); + if (event_data && + event_data->GetFlavor() == WatchpointEventData::GetFlavorString()) + return static_cast<const WatchpointEventData *>(event->GetData()); + } + return nullptr; } WatchpointEventType -Watchpoint::WatchpointEventData::GetWatchpointEventTypeFromEvent (const EventSP &event_sp) -{ - const WatchpointEventData *data = GetEventDataFromEvent (event_sp.get()); +Watchpoint::WatchpointEventData::GetWatchpointEventTypeFromEvent( + const EventSP &event_sp) { + const WatchpointEventData *data = GetEventDataFromEvent(event_sp.get()); - if (data == nullptr) - return eWatchpointEventTypeInvalidType; - else - return data->GetWatchpointEventType(); + if (data == nullptr) + return eWatchpointEventTypeInvalidType; + else + return data->GetWatchpointEventType(); } -WatchpointSP -Watchpoint::WatchpointEventData::GetWatchpointFromEvent (const EventSP &event_sp) -{ - WatchpointSP wp_sp; +WatchpointSP Watchpoint::WatchpointEventData::GetWatchpointFromEvent( + const EventSP &event_sp) { + WatchpointSP wp_sp; - const WatchpointEventData *data = GetEventDataFromEvent (event_sp.get()); - if (data) - wp_sp = data->m_new_watchpoint_sp; + const WatchpointEventData *data = GetEventDataFromEvent(event_sp.get()); + if (data) + wp_sp = data->m_new_watchpoint_sp; - return wp_sp; + return wp_sp; } diff --git a/lldb/source/Breakpoint/WatchpointList.cpp b/lldb/source/Breakpoint/WatchpointList.cpp index f662c24cece..6ec3bd09c14 100644 --- a/lldb/source/Breakpoint/WatchpointList.cpp +++ b/lldb/source/Breakpoint/WatchpointList.cpp @@ -7,7 +7,6 @@ // //===----------------------------------------------------------------------===// - // C Includes // C++ Includes // Other libraries and framework includes @@ -18,291 +17,241 @@ using namespace lldb; using namespace lldb_private; -WatchpointList::WatchpointList() : m_watchpoints(), m_mutex(), m_next_wp_id(0) -{ -} +WatchpointList::WatchpointList() + : m_watchpoints(), m_mutex(), m_next_wp_id(0) {} -WatchpointList::~WatchpointList() -{ -} +WatchpointList::~WatchpointList() {} // Add a watchpoint to the list. -lldb::watch_id_t -WatchpointList::Add (const WatchpointSP &wp_sp, bool notify) -{ - std::lock_guard<std::recursive_mutex> guard(m_mutex); - wp_sp->SetID(++m_next_wp_id); - m_watchpoints.push_back(wp_sp); - if (notify) - { - if (wp_sp->GetTarget().EventTypeHasListeners(Target::eBroadcastBitWatchpointChanged)) - wp_sp->GetTarget().BroadcastEvent (Target::eBroadcastBitWatchpointChanged, - new Watchpoint::WatchpointEventData (eWatchpointEventTypeAdded, wp_sp)); - } - return wp_sp->GetID(); +lldb::watch_id_t WatchpointList::Add(const WatchpointSP &wp_sp, bool notify) { + std::lock_guard<std::recursive_mutex> guard(m_mutex); + wp_sp->SetID(++m_next_wp_id); + m_watchpoints.push_back(wp_sp); + if (notify) { + if (wp_sp->GetTarget().EventTypeHasListeners( + Target::eBroadcastBitWatchpointChanged)) + wp_sp->GetTarget().BroadcastEvent(Target::eBroadcastBitWatchpointChanged, + new Watchpoint::WatchpointEventData( + eWatchpointEventTypeAdded, wp_sp)); + } + return wp_sp->GetID(); } -void -WatchpointList::Dump (Stream *s) const -{ - DumpWithLevel(s, lldb::eDescriptionLevelBrief); +void WatchpointList::Dump(Stream *s) const { + DumpWithLevel(s, lldb::eDescriptionLevelBrief); } -void -WatchpointList::DumpWithLevel (Stream *s, lldb::DescriptionLevel description_level) const -{ - std::lock_guard<std::recursive_mutex> guard(m_mutex); - s->Printf("%p: ", static_cast<const void*>(this)); - //s->Indent(); - s->Printf("WatchpointList with %" PRIu64 " Watchpoints:\n", - (uint64_t)m_watchpoints.size()); - s->IndentMore(); - wp_collection::const_iterator pos, end = m_watchpoints.end(); - for (pos = m_watchpoints.begin(); pos != end; ++pos) - (*pos)->DumpWithLevel(s, description_level); - s->IndentLess(); +void WatchpointList::DumpWithLevel( + Stream *s, lldb::DescriptionLevel description_level) const { + std::lock_guard<std::recursive_mutex> guard(m_mutex); + s->Printf("%p: ", static_cast<const void *>(this)); + // s->Indent(); + s->Printf("WatchpointList with %" PRIu64 " Watchpoints:\n", + (uint64_t)m_watchpoints.size()); + s->IndentMore(); + wp_collection::const_iterator pos, end = m_watchpoints.end(); + for (pos = m_watchpoints.begin(); pos != end; ++pos) + (*pos)->DumpWithLevel(s, description_level); + s->IndentLess(); } -const WatchpointSP -WatchpointList::FindByAddress (lldb::addr_t addr) const -{ - WatchpointSP wp_sp; - std::lock_guard<std::recursive_mutex> guard(m_mutex); - if (!m_watchpoints.empty()) - { - wp_collection::const_iterator pos, end = m_watchpoints.end(); - for (pos = m_watchpoints.begin(); pos != end; ++pos) - { - lldb::addr_t wp_addr = (*pos)->GetLoadAddress(); - uint32_t wp_bytesize = (*pos)->GetByteSize(); - if ((wp_addr <= addr) && ((wp_addr + wp_bytesize) > addr)) - { - wp_sp = *pos; - break; - } - } +const WatchpointSP WatchpointList::FindByAddress(lldb::addr_t addr) const { + WatchpointSP wp_sp; + std::lock_guard<std::recursive_mutex> guard(m_mutex); + if (!m_watchpoints.empty()) { + wp_collection::const_iterator pos, end = m_watchpoints.end(); + for (pos = m_watchpoints.begin(); pos != end; ++pos) { + lldb::addr_t wp_addr = (*pos)->GetLoadAddress(); + uint32_t wp_bytesize = (*pos)->GetByteSize(); + if ((wp_addr <= addr) && ((wp_addr + wp_bytesize) > addr)) { + wp_sp = *pos; + break; + } } + } - return wp_sp; + return wp_sp; } -const WatchpointSP -WatchpointList::FindBySpec (std::string spec) const -{ - WatchpointSP wp_sp; - std::lock_guard<std::recursive_mutex> guard(m_mutex); - if (!m_watchpoints.empty()) - { - wp_collection::const_iterator pos, end = m_watchpoints.end(); - for (pos = m_watchpoints.begin(); pos != end; ++pos) - if ((*pos)->GetWatchSpec() == spec) { - wp_sp = *pos; - break; - } - } +const WatchpointSP WatchpointList::FindBySpec(std::string spec) const { + WatchpointSP wp_sp; + std::lock_guard<std::recursive_mutex> guard(m_mutex); + if (!m_watchpoints.empty()) { + wp_collection::const_iterator pos, end = m_watchpoints.end(); + for (pos = m_watchpoints.begin(); pos != end; ++pos) + if ((*pos)->GetWatchSpec() == spec) { + wp_sp = *pos; + break; + } + } - return wp_sp; + return wp_sp; } -class WatchpointIDMatches -{ +class WatchpointIDMatches { public: - WatchpointIDMatches (lldb::watch_id_t watch_id) : - m_watch_id(watch_id) - { - } + WatchpointIDMatches(lldb::watch_id_t watch_id) : m_watch_id(watch_id) {} - bool operator() (const WatchpointSP &wp) const - { - return m_watch_id == wp->GetID(); - } + bool operator()(const WatchpointSP &wp) const { + return m_watch_id == wp->GetID(); + } private: - const lldb::watch_id_t m_watch_id; + const lldb::watch_id_t m_watch_id; }; WatchpointList::wp_collection::iterator -WatchpointList::GetIDIterator (lldb::watch_id_t watch_id) -{ - return std::find_if(m_watchpoints.begin(), m_watchpoints.end(), // Search full range - WatchpointIDMatches(watch_id)); // Predicate +WatchpointList::GetIDIterator(lldb::watch_id_t watch_id) { + return std::find_if(m_watchpoints.begin(), + m_watchpoints.end(), // Search full range + WatchpointIDMatches(watch_id)); // Predicate } WatchpointList::wp_collection::const_iterator -WatchpointList::GetIDConstIterator (lldb::watch_id_t watch_id) const -{ - return std::find_if(m_watchpoints.begin(), m_watchpoints.end(), // Search full range - WatchpointIDMatches(watch_id)); // Predicate +WatchpointList::GetIDConstIterator(lldb::watch_id_t watch_id) const { + return std::find_if(m_watchpoints.begin(), + m_watchpoints.end(), // Search full range + WatchpointIDMatches(watch_id)); // Predicate } -WatchpointSP -WatchpointList::FindByID (lldb::watch_id_t watch_id) const -{ - WatchpointSP wp_sp; - std::lock_guard<std::recursive_mutex> guard(m_mutex); - wp_collection::const_iterator pos = GetIDConstIterator(watch_id); - if (pos != m_watchpoints.end()) - wp_sp = *pos; +WatchpointSP WatchpointList::FindByID(lldb::watch_id_t watch_id) const { + WatchpointSP wp_sp; + std::lock_guard<std::recursive_mutex> guard(m_mutex); + wp_collection::const_iterator pos = GetIDConstIterator(watch_id); + if (pos != m_watchpoints.end()) + wp_sp = *pos; - return wp_sp; + return wp_sp; } -lldb::watch_id_t -WatchpointList::FindIDByAddress (lldb::addr_t addr) -{ - WatchpointSP wp_sp = FindByAddress (addr); - if (wp_sp) - { - return wp_sp->GetID(); - } - return LLDB_INVALID_WATCH_ID; +lldb::watch_id_t WatchpointList::FindIDByAddress(lldb::addr_t addr) { + WatchpointSP wp_sp = FindByAddress(addr); + if (wp_sp) { + return wp_sp->GetID(); + } + return LLDB_INVALID_WATCH_ID; } -lldb::watch_id_t -WatchpointList::FindIDBySpec (std::string spec) -{ - WatchpointSP wp_sp = FindBySpec (spec); - if (wp_sp) - { - return wp_sp->GetID(); - } - return LLDB_INVALID_WATCH_ID; +lldb::watch_id_t WatchpointList::FindIDBySpec(std::string spec) { + WatchpointSP wp_sp = FindBySpec(spec); + if (wp_sp) { + return wp_sp->GetID(); + } + return LLDB_INVALID_WATCH_ID; } -WatchpointSP -WatchpointList::GetByIndex (uint32_t i) -{ - std::lock_guard<std::recursive_mutex> guard(m_mutex); - WatchpointSP wp_sp; - if (i < m_watchpoints.size()) - { - wp_collection::const_iterator pos = m_watchpoints.begin(); - std::advance(pos, i); - wp_sp = *pos; - } - return wp_sp; +WatchpointSP WatchpointList::GetByIndex(uint32_t i) { + std::lock_guard<std::recursive_mutex> guard(m_mutex); + WatchpointSP wp_sp; + if (i < m_watchpoints.size()) { + wp_collection::const_iterator pos = m_watchpoints.begin(); + std::advance(pos, i); + wp_sp = *pos; + } + return wp_sp; } -const WatchpointSP -WatchpointList::GetByIndex (uint32_t i) const -{ - std::lock_guard<std::recursive_mutex> guard(m_mutex); - WatchpointSP wp_sp; - if (i < m_watchpoints.size()) - { - wp_collection::const_iterator pos = m_watchpoints.begin(); - std::advance(pos, i); - wp_sp = *pos; - } - return wp_sp; +const WatchpointSP WatchpointList::GetByIndex(uint32_t i) const { + std::lock_guard<std::recursive_mutex> guard(m_mutex); + WatchpointSP wp_sp; + if (i < m_watchpoints.size()) { + wp_collection::const_iterator pos = m_watchpoints.begin(); + std::advance(pos, i); + wp_sp = *pos; + } + return wp_sp; } -std::vector<lldb::watch_id_t> -WatchpointList::GetWatchpointIDs() const -{ - std::vector<lldb::watch_id_t> IDs; - wp_collection::const_iterator pos, end = m_watchpoints.end(); - for (pos = m_watchpoints.begin(); pos != end; ++pos) - IDs.push_back((*pos)->GetID()); - return IDs; +std::vector<lldb::watch_id_t> WatchpointList::GetWatchpointIDs() const { + std::vector<lldb::watch_id_t> IDs; + wp_collection::const_iterator pos, end = m_watchpoints.end(); + for (pos = m_watchpoints.begin(); pos != end; ++pos) + IDs.push_back((*pos)->GetID()); + return IDs; } -bool -WatchpointList::Remove (lldb::watch_id_t watch_id, bool notify) -{ - std::lock_guard<std::recursive_mutex> guard(m_mutex); - wp_collection::iterator pos = GetIDIterator(watch_id); - if (pos != m_watchpoints.end()) - { - WatchpointSP wp_sp = *pos; - if (notify) - { - if (wp_sp->GetTarget().EventTypeHasListeners(Target::eBroadcastBitWatchpointChanged)) - wp_sp->GetTarget().BroadcastEvent (Target::eBroadcastBitWatchpointChanged, - new Watchpoint::WatchpointEventData (eWatchpointEventTypeRemoved, wp_sp)); - } - m_watchpoints.erase(pos); - return true; +bool WatchpointList::Remove(lldb::watch_id_t watch_id, bool notify) { + std::lock_guard<std::recursive_mutex> guard(m_mutex); + wp_collection::iterator pos = GetIDIterator(watch_id); + if (pos != m_watchpoints.end()) { + WatchpointSP wp_sp = *pos; + if (notify) { + if (wp_sp->GetTarget().EventTypeHasListeners( + Target::eBroadcastBitWatchpointChanged)) + wp_sp->GetTarget().BroadcastEvent( + Target::eBroadcastBitWatchpointChanged, + new Watchpoint::WatchpointEventData(eWatchpointEventTypeRemoved, + wp_sp)); } - return false; + m_watchpoints.erase(pos); + return true; + } + return false; } -uint32_t -WatchpointList::GetHitCount () const -{ - uint32_t hit_count = 0; - std::lock_guard<std::recursive_mutex> guard(m_mutex); - wp_collection::const_iterator pos, end = m_watchpoints.end(); - for (pos = m_watchpoints.begin(); pos != end; ++pos) - hit_count += (*pos)->GetHitCount(); - return hit_count; +uint32_t WatchpointList::GetHitCount() const { + uint32_t hit_count = 0; + std::lock_guard<std::recursive_mutex> guard(m_mutex); + wp_collection::const_iterator pos, end = m_watchpoints.end(); + for (pos = m_watchpoints.begin(); pos != end; ++pos) + hit_count += (*pos)->GetHitCount(); + return hit_count; } -bool -WatchpointList::ShouldStop (StoppointCallbackContext *context, lldb::watch_id_t watch_id) -{ - - WatchpointSP wp_sp = FindByID (watch_id); - if (wp_sp) - { - // Let the Watchpoint decide if it should stop here (could not have - // reached it's target hit count yet, or it could have a callback - // that decided it shouldn't stop. - return wp_sp->ShouldStop (context); - } - // We should stop here since this Watchpoint isn't valid anymore or it - // doesn't exist. - return true; +bool WatchpointList::ShouldStop(StoppointCallbackContext *context, + lldb::watch_id_t watch_id) { + + WatchpointSP wp_sp = FindByID(watch_id); + if (wp_sp) { + // Let the Watchpoint decide if it should stop here (could not have + // reached it's target hit count yet, or it could have a callback + // that decided it shouldn't stop. + return wp_sp->ShouldStop(context); + } + // We should stop here since this Watchpoint isn't valid anymore or it + // doesn't exist. + return true; } -void -WatchpointList::GetDescription (Stream *s, lldb::DescriptionLevel level) -{ - std::lock_guard<std::recursive_mutex> guard(m_mutex); - wp_collection::iterator pos, end = m_watchpoints.end(); +void WatchpointList::GetDescription(Stream *s, lldb::DescriptionLevel level) { + std::lock_guard<std::recursive_mutex> guard(m_mutex); + wp_collection::iterator pos, end = m_watchpoints.end(); - for (pos = m_watchpoints.begin(); pos != end; ++pos) - { - s->Printf(" "); - (*pos)->Dump(s); - } + for (pos = m_watchpoints.begin(); pos != end; ++pos) { + s->Printf(" "); + (*pos)->Dump(s); + } } -void -WatchpointList::SetEnabledAll (bool enabled) -{ - std::lock_guard<std::recursive_mutex> guard(m_mutex); +void WatchpointList::SetEnabledAll(bool enabled) { + std::lock_guard<std::recursive_mutex> guard(m_mutex); - wp_collection::iterator pos, end = m_watchpoints.end(); - for (pos = m_watchpoints.begin(); pos != end; ++pos) - (*pos)->SetEnabled (enabled); + wp_collection::iterator pos, end = m_watchpoints.end(); + for (pos = m_watchpoints.begin(); pos != end; ++pos) + (*pos)->SetEnabled(enabled); } -void -WatchpointList::RemoveAll (bool notify) -{ - std::lock_guard<std::recursive_mutex> guard(m_mutex); - if (notify) +void WatchpointList::RemoveAll(bool notify) { + std::lock_guard<std::recursive_mutex> guard(m_mutex); + if (notify) { + { - - { - wp_collection::iterator pos, end = m_watchpoints.end(); - for (pos = m_watchpoints.begin(); pos != end; ++pos) - { - if ((*pos)->GetTarget().EventTypeHasListeners(Target::eBroadcastBitBreakpointChanged)) - { - (*pos)->GetTarget().BroadcastEvent (Target::eBroadcastBitWatchpointChanged, - new Watchpoint::WatchpointEventData (eWatchpointEventTypeRemoved, - *pos)); - } - } + wp_collection::iterator pos, end = m_watchpoints.end(); + for (pos = m_watchpoints.begin(); pos != end; ++pos) { + if ((*pos)->GetTarget().EventTypeHasListeners( + Target::eBroadcastBitBreakpointChanged)) { + (*pos)->GetTarget().BroadcastEvent( + Target::eBroadcastBitWatchpointChanged, + new Watchpoint::WatchpointEventData(eWatchpointEventTypeRemoved, + *pos)); } + } } - m_watchpoints.clear(); + } + m_watchpoints.clear(); } -void -WatchpointList::GetListMutex(std::unique_lock<std::recursive_mutex> &lock) -{ - lock = std::unique_lock<std::recursive_mutex>(m_mutex); +void WatchpointList::GetListMutex( + std::unique_lock<std::recursive_mutex> &lock) { + lock = std::unique_lock<std::recursive_mutex>(m_mutex); } diff --git a/lldb/source/Breakpoint/WatchpointOptions.cpp b/lldb/source/Breakpoint/WatchpointOptions.cpp index 365d884691e..1108f44561c 100644 --- a/lldb/source/Breakpoint/WatchpointOptions.cpp +++ b/lldb/source/Breakpoint/WatchpointOptions.cpp @@ -13,10 +13,10 @@ // Project includes #include "lldb/Breakpoint/WatchpointOptions.h" +#include "lldb/Breakpoint/StoppointCallbackContext.h" #include "lldb/Core/Stream.h" #include "lldb/Core/StringList.h" #include "lldb/Core/Value.h" -#include "lldb/Breakpoint/StoppointCallbackContext.h" #include "lldb/Target/Process.h" #include "lldb/Target/Target.h" #include "lldb/Target/ThreadSpec.h" @@ -24,63 +24,55 @@ using namespace lldb; using namespace lldb_private; -bool -WatchpointOptions::NullCallback (void *baton, StoppointCallbackContext *context, lldb::user_id_t watch_id) -{ - return true; +bool WatchpointOptions::NullCallback(void *baton, + StoppointCallbackContext *context, + lldb::user_id_t watch_id) { + return true; } //---------------------------------------------------------------------- // WatchpointOptions constructor //---------------------------------------------------------------------- -WatchpointOptions::WatchpointOptions() : - m_callback (WatchpointOptions::NullCallback), - m_callback_baton_sp (), - m_callback_is_synchronous (false), - m_thread_spec_ap () -{ -} +WatchpointOptions::WatchpointOptions() + : m_callback(WatchpointOptions::NullCallback), m_callback_baton_sp(), + m_callback_is_synchronous(false), m_thread_spec_ap() {} //---------------------------------------------------------------------- // WatchpointOptions copy constructor //---------------------------------------------------------------------- -WatchpointOptions::WatchpointOptions(const WatchpointOptions& rhs) : - m_callback (rhs.m_callback), - m_callback_baton_sp (rhs.m_callback_baton_sp), - m_callback_is_synchronous (rhs.m_callback_is_synchronous), - m_thread_spec_ap () -{ - if (rhs.m_thread_spec_ap.get() != nullptr) - m_thread_spec_ap.reset (new ThreadSpec(*rhs.m_thread_spec_ap.get())); +WatchpointOptions::WatchpointOptions(const WatchpointOptions &rhs) + : m_callback(rhs.m_callback), m_callback_baton_sp(rhs.m_callback_baton_sp), + m_callback_is_synchronous(rhs.m_callback_is_synchronous), + m_thread_spec_ap() { + if (rhs.m_thread_spec_ap.get() != nullptr) + m_thread_spec_ap.reset(new ThreadSpec(*rhs.m_thread_spec_ap.get())); } //---------------------------------------------------------------------- // WatchpointOptions assignment operator //---------------------------------------------------------------------- -const WatchpointOptions& -WatchpointOptions::operator=(const WatchpointOptions& rhs) -{ - m_callback = rhs.m_callback; - m_callback_baton_sp = rhs.m_callback_baton_sp; - m_callback_is_synchronous = rhs.m_callback_is_synchronous; - if (rhs.m_thread_spec_ap.get() != nullptr) - m_thread_spec_ap.reset(new ThreadSpec(*rhs.m_thread_spec_ap.get())); - return *this; +const WatchpointOptions &WatchpointOptions:: +operator=(const WatchpointOptions &rhs) { + m_callback = rhs.m_callback; + m_callback_baton_sp = rhs.m_callback_baton_sp; + m_callback_is_synchronous = rhs.m_callback_is_synchronous; + if (rhs.m_thread_spec_ap.get() != nullptr) + m_thread_spec_ap.reset(new ThreadSpec(*rhs.m_thread_spec_ap.get())); + return *this; } WatchpointOptions * -WatchpointOptions::CopyOptionsNoCallback (WatchpointOptions &orig) -{ - WatchpointHitCallback orig_callback = orig.m_callback; - lldb::BatonSP orig_callback_baton_sp = orig.m_callback_baton_sp; - bool orig_is_sync = orig.m_callback_is_synchronous; - - orig.ClearCallback(); - WatchpointOptions *ret_val = new WatchpointOptions(orig); - - orig.SetCallback (orig_callback, orig_callback_baton_sp, orig_is_sync); - - return ret_val; +WatchpointOptions::CopyOptionsNoCallback(WatchpointOptions &orig) { + WatchpointHitCallback orig_callback = orig.m_callback; + lldb::BatonSP orig_callback_baton_sp = orig.m_callback_baton_sp; + bool orig_is_sync = orig.m_callback_is_synchronous; + + orig.ClearCallback(); + WatchpointOptions *ret_val = new WatchpointOptions(orig); + + orig.SetCallback(orig_callback, orig_callback_baton_sp, orig_is_sync); + + return ret_val; } //---------------------------------------------------------------------- @@ -91,147 +83,117 @@ WatchpointOptions::~WatchpointOptions() = default; //------------------------------------------------------------------ // Callbacks //------------------------------------------------------------------ -void -WatchpointOptions::SetCallback (WatchpointHitCallback callback, const BatonSP &callback_baton_sp, bool callback_is_synchronous) -{ - m_callback_is_synchronous = callback_is_synchronous; - m_callback = callback; - m_callback_baton_sp = callback_baton_sp; +void WatchpointOptions::SetCallback(WatchpointHitCallback callback, + const BatonSP &callback_baton_sp, + bool callback_is_synchronous) { + m_callback_is_synchronous = callback_is_synchronous; + m_callback = callback; + m_callback_baton_sp = callback_baton_sp; } -void -WatchpointOptions::ClearCallback () -{ - m_callback = WatchpointOptions::NullCallback; - m_callback_is_synchronous = false; - m_callback_baton_sp.reset(); +void WatchpointOptions::ClearCallback() { + m_callback = WatchpointOptions::NullCallback; + m_callback_is_synchronous = false; + m_callback_baton_sp.reset(); } -Baton * -WatchpointOptions::GetBaton () -{ - return m_callback_baton_sp.get(); -} +Baton *WatchpointOptions::GetBaton() { return m_callback_baton_sp.get(); } -const Baton * -WatchpointOptions::GetBaton () const -{ - return m_callback_baton_sp.get(); +const Baton *WatchpointOptions::GetBaton() const { + return m_callback_baton_sp.get(); } -bool -WatchpointOptions::InvokeCallback (StoppointCallbackContext *context, - lldb::user_id_t watch_id) -{ - if (m_callback && context->is_synchronous == IsCallbackSynchronous()) - { - return m_callback(m_callback_baton_sp ? m_callback_baton_sp->m_data : nullptr, - context, - watch_id); - } - else - return true; +bool WatchpointOptions::InvokeCallback(StoppointCallbackContext *context, + lldb::user_id_t watch_id) { + if (m_callback && context->is_synchronous == IsCallbackSynchronous()) { + return m_callback(m_callback_baton_sp ? m_callback_baton_sp->m_data + : nullptr, + context, watch_id); + } else + return true; } -bool -WatchpointOptions::HasCallback () -{ - return m_callback != WatchpointOptions::NullCallback; +bool WatchpointOptions::HasCallback() { + return m_callback != WatchpointOptions::NullCallback; } -const ThreadSpec * -WatchpointOptions::GetThreadSpecNoCreate () const -{ - return m_thread_spec_ap.get(); +const ThreadSpec *WatchpointOptions::GetThreadSpecNoCreate() const { + return m_thread_spec_ap.get(); } -ThreadSpec * -WatchpointOptions::GetThreadSpec () -{ - if (m_thread_spec_ap.get() == nullptr) - m_thread_spec_ap.reset (new ThreadSpec()); - - return m_thread_spec_ap.get(); +ThreadSpec *WatchpointOptions::GetThreadSpec() { + if (m_thread_spec_ap.get() == nullptr) + m_thread_spec_ap.reset(new ThreadSpec()); + + return m_thread_spec_ap.get(); } -void -WatchpointOptions::SetThreadID (lldb::tid_t thread_id) -{ - GetThreadSpec()->SetTID(thread_id); +void WatchpointOptions::SetThreadID(lldb::tid_t thread_id) { + GetThreadSpec()->SetTID(thread_id); } -void -WatchpointOptions::GetCallbackDescription (Stream *s, lldb::DescriptionLevel level) const -{ - if (m_callback_baton_sp.get()) - { - s->EOL(); - m_callback_baton_sp->GetDescription (s, level); - } +void WatchpointOptions::GetCallbackDescription( + Stream *s, lldb::DescriptionLevel level) const { + if (m_callback_baton_sp.get()) { + s->EOL(); + m_callback_baton_sp->GetDescription(s, level); + } } -void -WatchpointOptions::GetDescription (Stream *s, lldb::DescriptionLevel level) const -{ - // Figure out if there are any options not at their default value, and only print - // anything if there are: - - if ((GetThreadSpecNoCreate() != nullptr && GetThreadSpecNoCreate()->HasSpecification ())) - { - if (level == lldb::eDescriptionLevelVerbose) - { - s->EOL (); - s->IndentMore(); - s->Indent(); - s->PutCString("Watchpoint Options:\n"); - s->IndentMore(); - s->Indent(); - } - else - s->PutCString(" Options: "); - - if (m_thread_spec_ap.get()) - m_thread_spec_ap->GetDescription (s, level); - else if (level == eDescriptionLevelBrief) - s->PutCString ("thread spec: no "); - if (level == lldb::eDescriptionLevelFull) - { - s->IndentLess(); - s->IndentMore(); - } +void WatchpointOptions::GetDescription(Stream *s, + lldb::DescriptionLevel level) const { + // Figure out if there are any options not at their default value, and only + // print + // anything if there are: + + if ((GetThreadSpecNoCreate() != nullptr && + GetThreadSpecNoCreate()->HasSpecification())) { + if (level == lldb::eDescriptionLevelVerbose) { + s->EOL(); + s->IndentMore(); + s->Indent(); + s->PutCString("Watchpoint Options:\n"); + s->IndentMore(); + s->Indent(); + } else + s->PutCString(" Options: "); + + if (m_thread_spec_ap.get()) + m_thread_spec_ap->GetDescription(s, level); + else if (level == eDescriptionLevelBrief) + s->PutCString("thread spec: no "); + if (level == lldb::eDescriptionLevelFull) { + s->IndentLess(); + s->IndentMore(); } - - GetCallbackDescription(s, level); + } + + GetCallbackDescription(s, level); } -void -WatchpointOptions::CommandBaton::GetDescription (Stream *s, lldb::DescriptionLevel level) const -{ - CommandData *data = (CommandData *)m_data; +void WatchpointOptions::CommandBaton::GetDescription( + Stream *s, lldb::DescriptionLevel level) const { + CommandData *data = (CommandData *)m_data; - if (level == eDescriptionLevelBrief) - { - s->Printf (", commands = %s", (data && data->user_source.GetSize() > 0) ? "yes" : "no"); - return; - } - - s->IndentMore (); - s->Indent("watchpoint commands:\n"); - - s->IndentMore (); - if (data && data->user_source.GetSize() > 0) - { - const size_t num_strings = data->user_source.GetSize(); - for (size_t i = 0; i < num_strings; ++i) - { - s->Indent(data->user_source.GetStringAtIndex(i)); - s->EOL(); - } - } - else - { - s->PutCString ("No commands.\n"); + if (level == eDescriptionLevelBrief) { + s->Printf(", commands = %s", + (data && data->user_source.GetSize() > 0) ? "yes" : "no"); + return; + } + + s->IndentMore(); + s->Indent("watchpoint commands:\n"); + + s->IndentMore(); + if (data && data->user_source.GetSize() > 0) { + const size_t num_strings = data->user_source.GetSize(); + for (size_t i = 0; i < num_strings; ++i) { + s->Indent(data->user_source.GetStringAtIndex(i)); + s->EOL(); } - s->IndentLess (); - s->IndentLess (); + } else { + s->PutCString("No commands.\n"); + } + s->IndentLess(); + s->IndentLess(); } |
