mirror of
https://github.com/Gericom/teak-llvm.git
synced 2025-06-22 13:05:52 -04:00
595048f3ec
in TestBase::getBuildArtifact(). This NFC commit is in preparation for https://reviews.llvm.org/D42281 (compile the LLDB tests out-of-tree). Differential Revision: https://reviews.llvm.org/D42280 llvm-svn: 323007
299 lines
12 KiB
Python
299 lines
12 KiB
Python
"""Test stepping over vrs. hitting breakpoints & subsequent stepping in various forms."""
|
|
|
|
from __future__ import print_function
|
|
|
|
|
|
import os
|
|
import time
|
|
import lldb
|
|
from lldbsuite.test.decorators import *
|
|
from lldbsuite.test.lldbtest import *
|
|
from lldbsuite.test import lldbutil
|
|
|
|
|
|
class TestCStepping(TestBase):
|
|
|
|
mydir = TestBase.compute_mydir(__file__)
|
|
|
|
def setUp(self):
|
|
# Call super's setUp().
|
|
TestBase.setUp(self)
|
|
# Find the line numbers that we will step to in main:
|
|
self.main_source = "main.c"
|
|
|
|
@add_test_categories(['pyapi', 'basic_process'])
|
|
@expectedFailureAll(oslist=['freebsd'], bugnumber='llvm.org/pr17932')
|
|
@expectedFailureAll(oslist=["linux"], bugnumber="llvm.org/pr14437")
|
|
@expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24777")
|
|
def test_and_python_api(self):
|
|
"""Test stepping over vrs. hitting breakpoints & subsequent stepping in various forms."""
|
|
self.build()
|
|
exe = self.getBuildArtifact("a.out")
|
|
|
|
target = self.dbg.CreateTarget(exe)
|
|
self.assertTrue(target, VALID_TARGET)
|
|
|
|
self.main_source_spec = lldb.SBFileSpec(self.main_source)
|
|
|
|
breakpoints_to_disable = []
|
|
|
|
break_1_in_main = target.BreakpointCreateBySourceRegex(
|
|
'// frame select 2, thread step-out while stopped at .c.1..',
|
|
self.main_source_spec)
|
|
self.assertTrue(break_1_in_main, VALID_BREAKPOINT)
|
|
breakpoints_to_disable.append(break_1_in_main)
|
|
|
|
break_in_a = target.BreakpointCreateBySourceRegex(
|
|
'// break here to stop in a before calling b', self.main_source_spec)
|
|
self.assertTrue(break_in_a, VALID_BREAKPOINT)
|
|
breakpoints_to_disable.append(break_in_a)
|
|
|
|
break_in_b = target.BreakpointCreateBySourceRegex(
|
|
'// thread step-out while stopped at .c.2..', self.main_source_spec)
|
|
self.assertTrue(break_in_b, VALID_BREAKPOINT)
|
|
breakpoints_to_disable.append(break_in_b)
|
|
|
|
break_in_c = target.BreakpointCreateBySourceRegex(
|
|
'// Find the line number of function .c. here.', self.main_source_spec)
|
|
self.assertTrue(break_in_c, VALID_BREAKPOINT)
|
|
breakpoints_to_disable.append(break_in_c)
|
|
|
|
# Now launch the process, and do not stop at entry point.
|
|
process = target.LaunchSimple(
|
|
None, None, self.get_process_working_directory())
|
|
|
|
self.assertTrue(process, PROCESS_IS_VALID)
|
|
|
|
# The stop reason of the thread should be breakpoint.
|
|
threads = lldbutil.get_threads_stopped_at_breakpoint(
|
|
process, break_1_in_main)
|
|
|
|
if len(threads) != 1:
|
|
self.fail("Failed to stop at first breakpoint in main.")
|
|
|
|
thread = threads[0]
|
|
|
|
# Get the stop id and for fun make sure it increases:
|
|
old_stop_id = process.GetStopID()
|
|
|
|
# Now step over, which should cause us to hit the breakpoint in "a"
|
|
thread.StepOver()
|
|
|
|
# The stop reason of the thread should be breakpoint.
|
|
threads = lldbutil.get_threads_stopped_at_breakpoint(
|
|
process, break_in_a)
|
|
if len(threads) != 1:
|
|
self.fail("Failed to stop at breakpoint in a.")
|
|
|
|
# Check that the stop ID increases:
|
|
new_stop_id = process.GetStopID()
|
|
self.assertTrue(
|
|
new_stop_id > old_stop_id,
|
|
"Stop ID increases monotonically.")
|
|
|
|
thread = threads[0]
|
|
|
|
# Step over, and we should hit the breakpoint in b:
|
|
thread.StepOver()
|
|
|
|
threads = lldbutil.get_threads_stopped_at_breakpoint(
|
|
process, break_in_b)
|
|
if len(threads) != 1:
|
|
self.fail("Failed to stop at breakpoint in b.")
|
|
thread = threads[0]
|
|
|
|
# Now try running some function, and make sure that we still end up in the same place
|
|
# and with the same stop reason.
|
|
frame = thread.GetFrameAtIndex(0)
|
|
current_line = frame.GetLineEntry().GetLine()
|
|
current_file = frame.GetLineEntry().GetFileSpec()
|
|
current_bp = []
|
|
current_bp.append(thread.GetStopReasonDataAtIndex(0))
|
|
current_bp.append(thread.GetStopReasonDataAtIndex(1))
|
|
|
|
stop_id_before_expression = process.GetStopID()
|
|
stop_id_before_including_expressions = process.GetStopID(True)
|
|
|
|
frame.EvaluateExpression("(int) printf (print_string)")
|
|
|
|
frame = thread.GetFrameAtIndex(0)
|
|
self.assertTrue(
|
|
current_line == frame.GetLineEntry().GetLine(),
|
|
"The line stayed the same after expression.")
|
|
self.assertTrue(
|
|
current_file == frame.GetLineEntry().GetFileSpec(),
|
|
"The file stayed the same after expression.")
|
|
self.assertTrue(
|
|
thread.GetStopReason() == lldb.eStopReasonBreakpoint,
|
|
"We still say we stopped for a breakpoint.")
|
|
self.assertTrue(thread.GetStopReasonDataAtIndex(0) == current_bp[
|
|
0] and thread.GetStopReasonDataAtIndex(1) == current_bp[1], "And it is the same breakpoint.")
|
|
|
|
# Also make sure running the expression didn't change the public stop id
|
|
# but did change if we are asking for expression stops as well.
|
|
stop_id_after_expression = process.GetStopID()
|
|
stop_id_after_including_expressions = process.GetStopID(True)
|
|
|
|
self.assertTrue(
|
|
stop_id_before_expression == stop_id_after_expression,
|
|
"Expression calling doesn't change stop ID")
|
|
|
|
self.assertTrue(
|
|
stop_id_after_including_expressions > stop_id_before_including_expressions,
|
|
"Stop ID including expressions increments over expression call.")
|
|
|
|
# Do the same thing with an expression that's going to crash, and make
|
|
# sure we are still unchanged.
|
|
|
|
frame.EvaluateExpression("((char *) 0)[0] = 'a'")
|
|
|
|
frame = thread.GetFrameAtIndex(0)
|
|
self.assertTrue(
|
|
current_line == frame.GetLineEntry().GetLine(),
|
|
"The line stayed the same after expression.")
|
|
self.assertTrue(
|
|
current_file == frame.GetLineEntry().GetFileSpec(),
|
|
"The file stayed the same after expression.")
|
|
self.assertTrue(
|
|
thread.GetStopReason() == lldb.eStopReasonBreakpoint,
|
|
"We still say we stopped for a breakpoint.")
|
|
self.assertTrue(thread.GetStopReasonDataAtIndex(0) == current_bp[
|
|
0] and thread.GetStopReasonDataAtIndex(1) == current_bp[1], "And it is the same breakpoint.")
|
|
|
|
# Now continue and make sure we just complete the step:
|
|
# Disable all our breakpoints first - sometimes the compiler puts two line table entries in for the
|
|
# breakpoint a "b" and we don't want to hit that.
|
|
for bkpt in breakpoints_to_disable:
|
|
bkpt.SetEnabled(False)
|
|
|
|
process.Continue()
|
|
|
|
self.assertTrue(thread.GetFrameAtIndex(0).GetFunctionName() == "a")
|
|
self.assertTrue(thread.GetStopReason() == lldb.eStopReasonPlanComplete)
|
|
|
|
# And one more time should get us back to main:
|
|
process.Continue()
|
|
|
|
self.assertTrue(thread.GetFrameAtIndex(0).GetFunctionName() == "main")
|
|
self.assertTrue(thread.GetStopReason() == lldb.eStopReasonPlanComplete)
|
|
|
|
# Now make sure we can call a function, break in the called function,
|
|
# then have "continue" get us back out again:
|
|
frame = thread.GetFrameAtIndex(0)
|
|
frame = thread.GetFrameAtIndex(0)
|
|
current_line = frame.GetLineEntry().GetLine()
|
|
current_file = frame.GetLineEntry().GetFileSpec()
|
|
|
|
break_in_b.SetEnabled(True)
|
|
options = lldb.SBExpressionOptions()
|
|
options.SetIgnoreBreakpoints(False)
|
|
options.SetFetchDynamicValue(False)
|
|
options.SetUnwindOnError(False)
|
|
frame.EvaluateExpression("b (4)", options)
|
|
|
|
threads = lldbutil.get_threads_stopped_at_breakpoint(
|
|
process, break_in_b)
|
|
|
|
if len(threads) != 1:
|
|
self.fail("Failed to stop at breakpoint in b when calling b.")
|
|
thread = threads[0]
|
|
|
|
# So do a step over here to make sure we can still do that:
|
|
|
|
thread.StepOver()
|
|
|
|
# See that we are still in b:
|
|
func_name = thread.GetFrameAtIndex(0).GetFunctionName()
|
|
self.assertTrue(
|
|
func_name == "b",
|
|
"Should be in 'b', were in %s" %
|
|
(func_name))
|
|
|
|
# Okay, now if we continue, we will finish off our function call and we
|
|
# should end up back in "a" as if nothing had happened:
|
|
process.Continue()
|
|
|
|
self.assertTrue(thread.GetFrameAtIndex(
|
|
0).GetLineEntry().GetLine() == current_line)
|
|
self.assertTrue(thread.GetFrameAtIndex(
|
|
0).GetLineEntry().GetFileSpec() == current_file)
|
|
|
|
# Now we are going to test step in targeting a function:
|
|
|
|
break_in_b.SetEnabled(False)
|
|
|
|
break_before_complex_1 = target.BreakpointCreateBySourceRegex(
|
|
'// Stop here to try step in targeting b.', self.main_source_spec)
|
|
self.assertTrue(break_before_complex_1, VALID_BREAKPOINT)
|
|
|
|
break_before_complex_2 = target.BreakpointCreateBySourceRegex(
|
|
'// Stop here to try step in targeting complex.', self.main_source_spec)
|
|
self.assertTrue(break_before_complex_2, VALID_BREAKPOINT)
|
|
|
|
break_before_complex_3 = target.BreakpointCreateBySourceRegex(
|
|
'// Stop here to step targeting b and hitting breakpoint.', self.main_source_spec)
|
|
self.assertTrue(break_before_complex_3, VALID_BREAKPOINT)
|
|
|
|
break_before_complex_4 = target.BreakpointCreateBySourceRegex(
|
|
'// Stop here to make sure bogus target steps over.', self.main_source_spec)
|
|
self.assertTrue(break_before_complex_4, VALID_BREAKPOINT)
|
|
|
|
threads = lldbutil.continue_to_breakpoint(
|
|
process, break_before_complex_1)
|
|
self.assertTrue(len(threads) == 1)
|
|
thread = threads[0]
|
|
break_before_complex_1.SetEnabled(False)
|
|
|
|
thread.StepInto("b")
|
|
self.assertTrue(thread.GetFrameAtIndex(0).GetFunctionName() == "b")
|
|
|
|
# Now continue out and stop at the next call to complex. This time
|
|
# step all the way into complex:
|
|
threads = lldbutil.continue_to_breakpoint(
|
|
process, break_before_complex_2)
|
|
self.assertTrue(len(threads) == 1)
|
|
thread = threads[0]
|
|
break_before_complex_2.SetEnabled(False)
|
|
|
|
thread.StepInto("complex")
|
|
self.assertTrue(thread.GetFrameAtIndex(
|
|
0).GetFunctionName() == "complex")
|
|
|
|
# Now continue out and stop at the next call to complex. This time
|
|
# enable breakpoints in a and c and then step targeting b:
|
|
threads = lldbutil.continue_to_breakpoint(
|
|
process, break_before_complex_3)
|
|
self.assertTrue(len(threads) == 1)
|
|
thread = threads[0]
|
|
break_before_complex_3.SetEnabled(False)
|
|
|
|
break_at_start_of_a = target.BreakpointCreateByName('a')
|
|
break_at_start_of_c = target.BreakpointCreateByName('c')
|
|
|
|
thread.StepInto("b")
|
|
threads = lldbutil.get_stopped_threads(
|
|
process, lldb.eStopReasonBreakpoint)
|
|
|
|
self.assertTrue(len(threads) == 1)
|
|
thread = threads[0]
|
|
stop_break_id = thread.GetStopReasonDataAtIndex(0)
|
|
self.assertTrue(stop_break_id == break_at_start_of_a.GetID()
|
|
or stop_break_id == break_at_start_of_c.GetID())
|
|
|
|
break_at_start_of_a.SetEnabled(False)
|
|
break_at_start_of_c.SetEnabled(False)
|
|
|
|
process.Continue()
|
|
self.assertTrue(thread.GetFrameAtIndex(0).GetFunctionName() == "b")
|
|
|
|
# Now continue out and stop at the next call to complex. This time
|
|
# enable breakpoints in a and c and then step targeting b:
|
|
threads = lldbutil.continue_to_breakpoint(
|
|
process, break_before_complex_4)
|
|
self.assertTrue(len(threads) == 1)
|
|
thread = threads[0]
|
|
break_before_complex_4.SetEnabled(False)
|
|
|
|
thread.StepInto("NoSuchFunction")
|
|
self.assertTrue(thread.GetFrameAtIndex(0).GetFunctionName() == "main")
|