Package lldb :: Class SBBreakpoint |
[hide private]
[frames] | no frames]

# Class SBBreakpoint

source code

    Represents a logical breakpoint and its associated settings.

    For example (from test/functionalities/breakpoint/breakpoint_ignore_count/
    TestBreakpointIgnoreCount.py),

        def breakpoint_ignore_count_python(self):
            '''Use Python APIs to set breakpoint ignore count.'''
            exe = os.path.join(os.getcwd(), 'a.out')

            # Create a target by the debugger.
            target = self.dbg.CreateTarget(exe)
            self.assertTrue(target, VALID_TARGET)

            # Now create a breakpoint on main.c by name 'c'.
            breakpoint = target.BreakpointCreateByName('c', 'a.out')
            self.assertTrue(breakpoint and
                            breakpoint.GetNumLocations() == 1,
                            VALID_BREAKPOINT)

            # Get the breakpoint location from breakpoint after we verified that,
            # indeed, it has one location.
            location = breakpoint.GetLocationAtIndex(0)
            self.assertTrue(location and
                            location.IsEnabled(),
                            VALID_BREAKPOINT_LOCATION)

            # Set the ignore count on the breakpoint location.
            location.SetIgnoreCount(2)
            self.assertTrue(location.GetIgnoreCount() == 2,
                            'SetIgnoreCount() works correctly')

            # Now launch the process, and do not stop at entry point.
            process = target.LaunchSimple(None, None, os.getcwd())
            self.assertTrue(process, PROCESS_IS_VALID)

            # Frame#0 should be on main.c:37, frame#1 should be on main.c:25, and
            # frame#2 should be on main.c:48.
            #lldbutil.print_stacktraces(process)
            from lldbutil import get_stopped_thread
            thread = get_stopped_thread(process, lldb.eStopReasonBreakpoint)
            self.assertTrue(thread != None, 'There should be a thread stopped due to breakpoint')
            frame0 = thread.GetFrameAtIndex(0)
            frame1 = thread.GetFrameAtIndex(1)
            frame2 = thread.GetFrameAtIndex(2)
            self.assertTrue(frame0.GetLineEntry().GetLine() == self.line1 and
                            frame1.GetLineEntry().GetLine() == self.line3 and
                            frame2.GetLineEntry().GetLine() == self.line4,
                            STOPPED_DUE_TO_BREAKPOINT_IGNORE_COUNT)

            # The hit count for the breakpoint should be 3.
            self.assertTrue(breakpoint.GetHitCount() == 3)

            process.Continue()

    SBBreakpoint supports breakpoint location iteration, for example,

        for bl in breakpoint:
            print 'breakpoint location load addr: %s' % hex(bl.GetLoadAddress())
            print 'breakpoint location condition: %s' % hex(bl.GetCondition())

    and rich comparion methods which allow the API program to use,

        if aBreakpoint == bBreakpoint:
            ...

    to compare two breakpoints for equality.

Instance Methods | [hide private]
__setattr__(self, name, value) x.__setattr__('name', value) <==> x.name = value | source code
__getattr__(self, name) | source code
__repr__(self) repr(x) | source code
__iter__(self) | source code
__len__(self) | source code
__init__(self, *args) __init__(lldb::SBBreakpoint self) -> SBBreakpoint __init__(lldb::SBBreakpoint self, SBBreakpoint rhs) -> SBBreakpoint | source code
__swig_destroy__(...) delete_SBBreakpoint(SBBreakpoint self) |
__del__(self) | source code
GetID(self) GetID(SBBreakpoint self) -> lldb::break_id_t | source code
__nonzero__(self) | source code
IsValid(self) IsValid(SBBreakpoint self) -> bool | source code
ClearAllBreakpointSites(self) ClearAllBreakpointSites(SBBreakpoint self) | source code
FindLocationByAddress(self, *args) FindLocationByAddress(SBBreakpoint self, lldb::addr_t vm_addr) -> SBBreakpointLocation | source code
FindLocationIDByAddress(self, *args) FindLocationIDByAddress(SBBreakpoint self, lldb::addr_t vm_addr) -> lldb::break_id_t | source code
FindLocationByID(self, *args) FindLocationByID(SBBreakpoint self, lldb::break_id_t bp_loc_id) -> SBBreakpointLocation | source code
GetLocationAtIndex(self, *args) GetLocationAtIndex(SBBreakpoint self, uint32_t index) -> SBBreakpointLocation | source code
SetEnabled(self, *args) SetEnabled(SBBreakpoint self, bool enable) | source code
IsEnabled(self) IsEnabled(SBBreakpoint self) -> bool | source code
SetOneShot(self, *args) SetOneShot(SBBreakpoint self, bool one_shot) | source code
IsOneShot(self) IsOneShot(SBBreakpoint self) -> bool | source code
IsInternal(self) IsInternal(SBBreakpoint self) -> bool | source code
GetHitCount(self) GetHitCount(SBBreakpoint self) -> uint32_t | source code
SetIgnoreCount(self, *args) SetIgnoreCount(SBBreakpoint self, uint32_t count) | source code
GetIgnoreCount(self) GetIgnoreCount(SBBreakpoint self) -> uint32_t | source code
SetCondition(self, *args) SetCondition(SBBreakpoint self, str const * condition) | source code
GetCondition(self) GetCondition(SBBreakpoint self) -> str const * | source code
SetThreadID(self, *args) SetThreadID(SBBreakpoint self, lldb::tid_t sb_thread_id) | source code
GetThreadID(self) GetThreadID(SBBreakpoint self) -> lldb::tid_t | source code
SetThreadIndex(self, *args) SetThreadIndex(SBBreakpoint self, uint32_t index) | source code
GetThreadIndex(self) GetThreadIndex(SBBreakpoint self) -> uint32_t | source code
SetThreadName(self, *args) SetThreadName(SBBreakpoint self, str const * thread_name) | source code
GetThreadName(self) GetThreadName(SBBreakpoint self) -> str const * | source code
SetQueueName(self, *args) SetQueueName(SBBreakpoint self, str const * queue_name) | source code
GetQueueName(self) GetQueueName(SBBreakpoint self) -> str const * | source code
SetCallback(self, *args) SetCallback(SBBreakpoint self, lldb::SBBreakpoint::BreakpointHitCallback callback, void * baton) | source code
GetNumResolvedLocations(self) GetNumResolvedLocations(SBBreakpoint self) -> size_t | source code
GetNumLocations(self) GetNumLocations(SBBreakpoint self) -> size_t | source code
GetDescription(self, *args) GetDescription(SBBreakpoint self, SBStream description) -> bool | source code
__str__(self) __str__(SBBreakpoint self) -> PyObject * | source code
__eq__(self, rhs) | source code
__ne__(self, rhs) | source code
Inherited from `object`: `__delattr__`, `__format__`, `__getattribute__`, `__hash__`, `__new__`, `__reduce__`, `__reduce_ex__`, `__sizeof__`, `__subclasshook__`

Static Methods | [hide private]
EventIsBreakpointEvent(*args) EventIsBreakpointEvent(SBEvent event) -> bool | source code
GetBreakpointEventTypeFromEvent(*args) GetBreakpointEventTypeFromEvent(SBEvent event) -> lldb::BreakpointEventType | source code
GetBreakpointFromEvent(*args) GetBreakpointFromEvent(SBEvent event) -> SBBreakpoint | source code
GetBreakpointLocationAtIndexFromEvent(*args) GetBreakpointLocationAtIndexFromEvent(SBEvent event, uint32_t loc_idx) -> SBBreakpointLocation | source code
GetNumBreakpointLocationsFromEvent(*args) GetNumBreakpointLocationsFromEvent(SBEvent event_sp) -> uint32_t | source code

Class Variables | [hide private]
| __swig_setmethods__ = `{}`
| __swig_getmethods__ = `{}`

Properties | [hide private]
| enabled A read/write property that configures whether this breakpoint is enabled or not.
| id A read only property that returns the ID of this breakpoint.
| num_locations A read only property that returns the count of locations of this breakpoint.
| one_shot A read/write property that configures whether this breakpoint is one-shot (deleted when hit) or not.
Inherited from `object`: `__class__`

Method Details | [hide private]

### __setattr__(self, name, value) | source code
x.__setattr__('name', value) <==> x.name = value Overrides: object.__setattr__ (inherited documentation)

### __repr__(self) (Representation operator) | source code
repr(x) Overrides: object.__repr__ (inherited documentation)

### __init__(self, *args) (Constructor) | source code
__init__(lldb::SBBreakpoint self) -> SBBreakpoint __init__(lldb::SBBreakpoint self, SBBreakpoint rhs) -> SBBreakpoint Overrides: object.__init__

### SetCondition(self, *args) | source code
SetCondition(SBBreakpoint self, str const * condition) The breakpoint stops only if the condition expression evaluates to true.

### GetCondition(self) | source code
GetCondition(SBBreakpoint self) -> str const * Get the condition expression for the breakpoint.

### __str__(self) (Informal representation operator) | source code
__str__(SBBreakpoint self) -> PyObject * Overrides: object.__str__

Property Details | [hide private]

### enabled A read/write property that configures whether this breakpoint is enabled or not. Get Method: IsEnabled(self) - IsEnabled(SBBreakpoint self) -> bool Set Method: SetEnabled(self, *args) - SetEnabled(SBBreakpoint self, bool enable)

### id A read only property that returns the ID of this breakpoint. Get Method: GetID(self) - GetID(SBBreakpoint self) -> lldb::break_id_t

### num_locations A read only property that returns the count of locations of this breakpoint. Get Method: GetNumLocations(self) - GetNumLocations(SBBreakpoint self) -> size_t

### one_shot A read/write property that configures whether this breakpoint is one-shot (deleted when hit) or not. Get Method: IsOneShot(self) - IsOneShot(SBBreakpoint self) -> bool Set Method: SetOneShot(self, *args) - SetOneShot(SBBreakpoint self, bool one_shot)