1460e4bf0e
symbols correctly. There were a couple of pieces to this. 1) When a breakpoint location finds itself pointing to an Indirect symbol, when the site for it is created it needs to resolve the symbol and actually set the site at its target. 2) Not all breakpoints want to do this (i.e. a straight address breakpoint should always set itself on the specified address, so somem machinery was needed to specify that. 3) I added some info to the break list output for indirect symbols so you could see what was happening. Also I made it clear when we re-route through re-exported symbols. 4) I moved ResolveIndirectFunction from ProcessPosix to Process since it works the exact same way on Mac OS X and the other posix systems. If we find a platform that doesn't do it this way, they can override the call in Process. 5) Fixed one bug in RunThreadPlan, if you were trying to run a thread plan after a "running" event had been broadcast, the event coalescing would cause you to miss the ThreadPlan running event. So I added a way to override the coalescing. 6) Made DynamicLoaderMacOSXDYLD::GetStepThroughTrampolinePlan handle Indirect & Re-exported symbols. <rdar://problem/15280639> llvm-svn: 198976
807 lines
23 KiB
C++
807 lines
23 KiB
C++
//===-- Breakpoint.cpp ------------------------------------------*- C++ -*-===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
// C Includes
|
|
// 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/Breakpoint/BreakpointLocationCollection.h"
|
|
#include "lldb/Breakpoint/BreakpointResolver.h"
|
|
#include "lldb/Breakpoint/BreakpointResolverFileLine.h"
|
|
#include "lldb/Core/Log.h"
|
|
#include "lldb/Core/ModuleList.h"
|
|
#include "lldb/Core/SearchFilter.h"
|
|
#include "lldb/Core/Section.h"
|
|
#include "lldb/Core/Stream.h"
|
|
#include "lldb/Core/StreamString.h"
|
|
#include "lldb/Symbol/SymbolContext.h"
|
|
#include "lldb/Target/Target.h"
|
|
#include "lldb/Target/ThreadSpec.h"
|
|
#include "lldb/lldb-private-log.h"
|
|
#include "llvm/Support/Casting.h"
|
|
|
|
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;
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
// 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_being_created = false;
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
// Destructor
|
|
//----------------------------------------------------------------------
|
|
Breakpoint::~Breakpoint()
|
|
{
|
|
}
|
|
|
|
bool
|
|
Breakpoint::IsInternal () const
|
|
{
|
|
return LLDB_BREAK_ID_IS_INTERNAL(m_bid);
|
|
}
|
|
|
|
|
|
|
|
Target&
|
|
Breakpoint::GetTarget ()
|
|
{
|
|
return m_target;
|
|
}
|
|
|
|
const Target&
|
|
Breakpoint::GetTarget () const
|
|
{
|
|
return m_target;
|
|
}
|
|
|
|
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);
|
|
}
|
|
|
|
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::GetLocationAtIndex (size_t index)
|
|
{
|
|
return m_locations.GetByIndex(index);
|
|
}
|
|
|
|
void
|
|
Breakpoint::RemoveInvalidLocations (const ArchSpec &arch)
|
|
{
|
|
m_locations.RemoveInvalidLocations(arch);
|
|
}
|
|
|
|
// For each of the overall options we need to decide how they propagate to
|
|
// the location options. This will determine the precedence of options on
|
|
// the breakpoint vs. its locations.
|
|
|
|
// Disable at the breakpoint level should override the location settings.
|
|
// 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;
|
|
|
|
m_options.SetEnabled(enable);
|
|
if (enable)
|
|
m_locations.ResolveAllBreakpointSites();
|
|
else
|
|
m_locations.ClearAllBreakpointSites();
|
|
|
|
SendBreakpointChangedEvent (enable ? eBreakpointEventTypeEnabled : eBreakpointEventTypeDisabled);
|
|
|
|
}
|
|
|
|
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::DecrementIgnoreCount ()
|
|
{
|
|
uint32_t ignore = m_options.GetIgnoreCount();
|
|
if (ignore != 0)
|
|
m_options.SetIgnoreCount(ignore - 1);
|
|
}
|
|
|
|
uint32_t
|
|
Breakpoint::GetIgnoreCount () const
|
|
{
|
|
return m_options.GetIgnoreCount();
|
|
}
|
|
|
|
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::GetHitCount () const
|
|
{
|
|
return m_locations.GetHitCount();
|
|
}
|
|
|
|
bool
|
|
Breakpoint::IsOneShot () const
|
|
{
|
|
return m_options.IsOneShot();
|
|
}
|
|
|
|
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() == NULL)
|
|
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);
|
|
}
|
|
|
|
uint32_t
|
|
Breakpoint::GetThreadIndex() const
|
|
{
|
|
if (m_options.GetThreadSpecNoCreate() == NULL)
|
|
return 0;
|
|
else
|
|
return m_options.GetThreadSpecNoCreate()->GetIndex();
|
|
}
|
|
|
|
void
|
|
Breakpoint::SetThreadName (const char *thread_name)
|
|
{
|
|
if (m_options.GetThreadSpec()->GetName() != NULL
|
|
&& ::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() == NULL)
|
|
return NULL;
|
|
else
|
|
return m_options.GetThreadSpecNoCreate()->GetName();
|
|
}
|
|
|
|
void
|
|
Breakpoint::SetQueueName (const char *queue_name)
|
|
{
|
|
if (m_options.GetThreadSpec()->GetQueueName() != NULL
|
|
&& ::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() == NULL)
|
|
return NULL;
|
|
else
|
|
return m_options.GetThreadSpecNoCreate()->GetQueueName();
|
|
}
|
|
|
|
void
|
|
Breakpoint::SetCondition (const char *condition)
|
|
{
|
|
m_options.SetCondition (condition);
|
|
SendBreakpointChangedEvent (eBreakpointEventTypeConditionChanged);
|
|
}
|
|
|
|
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);
|
|
}
|
|
|
|
// 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::ClearCallback ()
|
|
{
|
|
m_options.ClearCallback ();
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
void
|
|
Breakpoint::ResolveBreakpoint ()
|
|
{
|
|
if (m_resolver_sp)
|
|
m_resolver_sp->ResolveBreakpoint(*m_filter_sp);
|
|
}
|
|
|
|
void
|
|
Breakpoint::ResolveBreakpointInModules (ModuleList &module_list)
|
|
{
|
|
if (m_resolver_sp)
|
|
m_resolver_sp->ResolveBreakpointInModules(*m_filter_sp, module_list);
|
|
}
|
|
|
|
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)
|
|
{
|
|
Mutex::Locker modules_mutex(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.
|
|
|
|
const size_t num_locs = m_locations.GetSize();
|
|
size_t num_modules = module_list.GetSize();
|
|
for (size_t i = 0; i < num_modules; i++)
|
|
{
|
|
bool seen = false;
|
|
ModuleSP module_sp (module_list.GetModuleAtIndexUnlocked (i));
|
|
if (!m_filter_sp->ModulePasses (module_sp))
|
|
continue;
|
|
|
|
for (size_t loc_idx = 0; loc_idx < num_locs; loc_idx++)
|
|
{
|
|
BreakpointLocationSP break_loc = m_locations.GetByIndex(loc_idx);
|
|
if (!break_loc->IsEnabled())
|
|
continue;
|
|
SectionSP section_sp (break_loc->GetAddress().GetSection());
|
|
if (!section_sp || section_sp->GetModule() == module_sp)
|
|
{
|
|
if (!seen)
|
|
seen = true;
|
|
|
|
if (!break_loc->ResolveBreakpointSite())
|
|
{
|
|
Log *log (lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_BREAKPOINTS));
|
|
if (log)
|
|
log->Printf ("Warning: could not set breakpoint site for breakpoint location %d of breakpoint %d.\n",
|
|
break_loc->GetID(), GetID());
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!seen)
|
|
new_modules.AppendIfNeeded (module_sp);
|
|
|
|
}
|
|
|
|
if (new_modules.GetSize() > 0)
|
|
{
|
|
// If this is not an internal breakpoint, set up to record the new locations, then dispatch
|
|
// an event with the new locations.
|
|
if (!IsInternal())
|
|
{
|
|
BreakpointEventData *new_locations_event = new BreakpointEventData (eBreakpointEventTypeLocationsAdded,
|
|
shared_from_this());
|
|
|
|
m_locations.StartRecordingNewLocations(new_locations_event->GetBreakpointLocationCollection());
|
|
|
|
ResolveBreakpointInModules(new_modules);
|
|
|
|
m_locations.StopRecordingNewLocations();
|
|
if (new_locations_event->GetBreakpointLocationCollection().GetSize() != 0)
|
|
{
|
|
SendBreakpointChangedEvent (new_locations_event);
|
|
}
|
|
else
|
|
delete new_locations_event;
|
|
}
|
|
else
|
|
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
|
|
removed_locations_event = NULL;
|
|
|
|
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));
|
|
}
|
|
}
|
|
}
|
|
SendBreakpointChangedEvent (removed_locations_event);
|
|
}
|
|
}
|
|
|
|
void
|
|
Breakpoint::ModuleReplaced (ModuleSP old_module_sp, ModuleSP new_module_sp)
|
|
{
|
|
ModuleList temp_list;
|
|
temp_list.Append (new_module_sp);
|
|
ModulesChanged (temp_list, true);
|
|
|
|
// TO DO: For now I'm just adding locations for the new module and removing the
|
|
// breakpoint locations that were in the old module.
|
|
// We should really go find the ones that are in the new module & if we can determine that they are "equivalent"
|
|
// carry over the options from the old location to the new.
|
|
|
|
temp_list.Clear();
|
|
temp_list.Append (old_module_sp);
|
|
ModulesChanged (temp_list, false, 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();
|
|
}
|
|
|
|
size_t
|
|
Breakpoint::GetNumLocations() const
|
|
{
|
|
return m_locations.GetSize();
|
|
}
|
|
|
|
void
|
|
Breakpoint::GetDescription (Stream *s, lldb::DescriptionLevel level, bool show_locations)
|
|
{
|
|
assert (s != NULL);
|
|
|
|
if (!m_kind_description.empty())
|
|
{
|
|
if (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)");
|
|
}
|
|
|
|
GetOptions()->GetDescription(s, level);
|
|
|
|
if (level == lldb::eDescriptionLevelFull)
|
|
{
|
|
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)
|
|
{
|
|
// If there is one location only, we'll just print that location information. But don't do this if
|
|
// show locations is true, then that will be handled below.
|
|
if (show_locations == false)
|
|
{
|
|
GetLocationAtIndex(0)->GetDescription(s, level);
|
|
}
|
|
else
|
|
{
|
|
s->Printf ("%zd locations.", num_locations);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
s->Printf ("%zd locations.", 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::GetFilterDescription (Stream *s)
|
|
{
|
|
m_filter_sp->GetDescription (s);
|
|
}
|
|
|
|
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);
|
|
}
|
|
}
|
|
|
|
void
|
|
Breakpoint::SendBreakpointChangedEvent (BreakpointEventData *data)
|
|
{
|
|
|
|
if (data == NULL)
|
|
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 ()
|
|
{
|
|
}
|
|
|
|
const ConstString &
|
|
Breakpoint::BreakpointEventData::GetFlavorString ()
|
|
{
|
|
static ConstString g_flavor ("Breakpoint::BreakpointEventData");
|
|
return g_flavor;
|
|
}
|
|
|
|
const ConstString &
|
|
Breakpoint::BreakpointEventData::GetFlavor () const
|
|
{
|
|
return BreakpointEventData::GetFlavorString ();
|
|
}
|
|
|
|
|
|
BreakpointSP &
|
|
Breakpoint::BreakpointEventData::GetBreakpoint ()
|
|
{
|
|
return m_new_breakpoint_sp;
|
|
}
|
|
|
|
BreakpointEventType
|
|
Breakpoint::BreakpointEventData::GetBreakpointEventType () const
|
|
{
|
|
return m_breakpoint_event;
|
|
}
|
|
|
|
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 NULL;
|
|
}
|
|
|
|
BreakpointEventType
|
|
Breakpoint::BreakpointEventData::GetBreakpointEventTypeFromEvent (const EventSP &event_sp)
|
|
{
|
|
const BreakpointEventData *data = GetEventDataFromEvent (event_sp.get());
|
|
|
|
if (data == NULL)
|
|
return eBreakpointEventTypeInvalidType;
|
|
else
|
|
return data->GetBreakpointEventType();
|
|
}
|
|
|
|
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;
|
|
|
|
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();
|
|
|
|
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);
|
|
}
|
|
|
|
return bp_loc_sp;
|
|
}
|