a3fe9221ab
The Watchpoint and Breakpoint objects try to track the hardware index that was used for them, if they are hardware wp/bp's. The majority of our debugging goes over the gdb remote serial protocol, and when we set the watchpoint/breakpoint, there is no (standard) way for the remote stub to communicate to lldb which hardware index was used. We have an lldb-extension packet to query the total number of watchpoint registers. When a watchpoint is hit, there is an lldb extension to the stop reply packet (documented in lldb-gdb-remote.txt) to describe the watchpoint including its actual hardware index, <addr within wp range> <wp hw index> <actual accessed address> (the third field is specifically needed for MIPS). At this point, if the stub reported these three fields (the stub is only required to provide the first), we can know the actual hardware index for this watchpoint. Breakpoints are worse; there's never any way for us to be notified about which hardware index was used. Breakpoints got this as a side effect of inherting from StoppointSite with Watchpoints. We expose the watchpoint hardware index through "watchpoint list -v" and through SBWatchpoint::GetHardwareIndex. With my large watchpoint support, there is no *single* hardware index that may be used for a watchpoint, it may need multiple resources. Also I don't see what a user is supposed to do with this information, or an IDE. Knowing the total number of watchpoint registers on the target, and knowing how many Watchpoint Resources are currently in use, is helpful. Knowing how many Watchpoint Resources a single user-specified watchpoint needed to be implemented is useful. But knowing which registers were used is an implementation detail and not available until we hit the watchpoint when using gdb remote serial protocol. So given all that, I'm removing watchpoint hardware index numbers. I'm changing the SB API to always return -1.
107 lines
4.0 KiB
Python
107 lines
4.0 KiB
Python
"""
|
|
Use lldb Python SBTarget API to iterate on the watchpoint(s) for the target.
|
|
"""
|
|
|
|
import lldb
|
|
from lldbsuite.test.decorators import *
|
|
from lldbsuite.test.lldbtest import *
|
|
from lldbsuite.test import lldbutil
|
|
|
|
|
|
class WatchpointIteratorTestCase(TestBase):
|
|
NO_DEBUG_INFO_TESTCASE = True
|
|
|
|
# hardware watchpoints are not reported with a hardware index # on armv7 on ios devices
|
|
def affected_by_radar_34564183(self):
|
|
return (
|
|
self.getArchitecture() in ["armv7", "armv7k", "arm64_32"]
|
|
) and self.platformIsDarwin()
|
|
|
|
def setUp(self):
|
|
# Call super's setUp().
|
|
TestBase.setUp(self)
|
|
# Our simple source filename.
|
|
self.source = "main.c"
|
|
# Find the line number to break inside main().
|
|
self.line = line_number(self.source, "// Set break point at this line.")
|
|
|
|
def test_watch_iter(self):
|
|
"""Exercise SBTarget.watchpoint_iter() API to iterate on the available watchpoints."""
|
|
self.build()
|
|
exe = self.getBuildArtifact("a.out")
|
|
|
|
# Create a target by the debugger.
|
|
target = self.dbg.CreateTarget(exe)
|
|
self.assertTrue(target, VALID_TARGET)
|
|
|
|
# Create a breakpoint on main.c in order to set our watchpoint later.
|
|
breakpoint = target.BreakpointCreateByLocation(self.source, self.line)
|
|
self.assertTrue(
|
|
breakpoint and breakpoint.GetNumLocations() == 1, VALID_BREAKPOINT
|
|
)
|
|
|
|
# Now launch the process, and do not stop at the entry point.
|
|
process = target.LaunchSimple(None, None, self.get_process_working_directory())
|
|
|
|
# We should be stopped due to the breakpoint. Get frame #0.
|
|
process = target.GetProcess()
|
|
self.assertState(process.GetState(), lldb.eStateStopped, PROCESS_STOPPED)
|
|
thread = lldbutil.get_stopped_thread(process, lldb.eStopReasonBreakpoint)
|
|
frame0 = thread.GetFrameAtIndex(0)
|
|
|
|
# Watch 'global' for read and write.
|
|
value = frame0.FindValue("global", lldb.eValueTypeVariableGlobal)
|
|
error = lldb.SBError()
|
|
watchpoint = value.Watch(True, False, True, error)
|
|
self.assertTrue(
|
|
value and watchpoint, "Successfully found the variable and set a watchpoint"
|
|
)
|
|
self.DebugSBValue(value)
|
|
|
|
# Hide stdout if not running with '-t' option.
|
|
if not self.TraceOn():
|
|
self.HideStdout()
|
|
|
|
# There should be only 1 watchpoint location under the target.
|
|
self.assertEqual(target.GetNumWatchpoints(), 1)
|
|
self.assertTrue(watchpoint.IsEnabled())
|
|
watch_id = watchpoint.GetID()
|
|
self.assertTrue(watch_id != 0)
|
|
|
|
# Continue. Expect the program to stop due to the variable being
|
|
# written to.
|
|
process.Continue()
|
|
|
|
# Hide stdout if not running with '-t' option.
|
|
if not self.TraceOn():
|
|
self.HideStdout()
|
|
|
|
# Print the stack traces.
|
|
lldbutil.print_stacktraces(process)
|
|
|
|
thread = lldbutil.get_stopped_thread(process, lldb.eStopReasonWatchpoint)
|
|
self.assertTrue(thread, "The thread stopped due to watchpoint")
|
|
self.DebugSBValue(value)
|
|
|
|
# SBWatchpoint.GetDescription() takes a description level arg.
|
|
print(lldbutil.get_description(watchpoint, lldb.eDescriptionLevelFull))
|
|
|
|
# Now disable the 'rw' watchpoint. The program won't stop when it reads
|
|
# 'global' next.
|
|
watchpoint.SetEnabled(False)
|
|
self.assertFalse(watchpoint.IsEnabled())
|
|
|
|
# Continue. The program does not stop again when the variable is being
|
|
# read from because the watchpoint location has been disabled.
|
|
process.Continue()
|
|
|
|
# At this point, the inferior process should have exited.
|
|
self.assertEqual(process.GetState(), lldb.eStateExited, PROCESS_EXITED)
|
|
|
|
# Verify some vital statistics and exercise the iterator API.
|
|
for watchpoint in target.watchpoint_iter():
|
|
self.assertTrue(watchpoint)
|
|
self.assertEqual(watchpoint.GetWatchSize(), 4)
|
|
self.assertEqual(watchpoint.GetHitCount(), 1)
|
|
print(watchpoint)
|