def test_break(self):
"""Test 'expr member' continues to work for optimized build."""
self.build()
exe = os.path.join(os.getcwd(), "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_symbol (self, self.method_spec, num_expected_locations=1, sym_exact=True)
self.runCmd("run", RUN_SUCCEEDED)
self.expect("thread backtrace", STOPPED_DUE_TO_BREAKPOINT,
substrs = ["stop reason = breakpoint"],
patterns = ["frame.*0:.*%s %s" % (self.myclass, self.mymethod)])
self.expect('expression member',
startstr = "(int) $0 = 5")
# <rdar://problem/12693963>
interp = self.dbg.GetCommandInterpreter()
result = lldb.SBCommandReturnObject()
interp.HandleCommand('frame variable self', result)
output = result.GetOutput()
desired_pointer = "0x0"
mo = re.search("0x[0-9a-f]+", output)
if mo:
desired_pointer = mo.group(0)
self.expect('expression (self)',
substrs = [("(%s *) $1 = " % self.myclass), desired_pointer])
self.expect('expression self->non_member', error=True,
substrs = ["does not have a member named 'non_member'"])
def test(self):
"""Break inside a() and b() defined within libfoo.a."""
self.build()
exe = os.path.join(os.getcwd(), "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Break inside a() by file and line first.
lldbutil.run_break_set_by_file_and_line (self, "a.c", self.line, num_expected_locations=1, loc_exact=True)
self.runCmd("run", RUN_SUCCEEDED)
# The stop reason of the thread should be breakpoint.
self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
substrs = ['stopped',
'stop reason = breakpoint'])
# Break at a(int) first.
self.expect("frame variable", VARIABLES_DISPLAYED_CORRECTLY,
substrs = ['(int) arg = 1'])
self.expect("frame variable __a_global", VARIABLES_DISPLAYED_CORRECTLY,
substrs = ['(int) __a_global = 1'])
# Set breakpoint for b() next.
lldbutil.run_break_set_by_symbol (self, "b", num_expected_locations=1, sym_exact=True)
# Continue the program, we should break at b(int) next.
self.runCmd("continue")
self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
substrs = ['stopped',
'stop reason = breakpoint'])
self.expect("frame variable", VARIABLES_DISPLAYED_CORRECTLY,
substrs = ['(int) arg = 2'])
self.expect("frame variable __b_global", VARIABLES_DISPLAYED_CORRECTLY,
substrs = ['(int) __b_global = 2'])
def forward_declaration(self):
"""Display *bar_ptr when stopped on a function with forward declaration of struct bar."""
exe = os.path.join(os.getcwd(), "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Break inside the foo function which takes a bar_ptr argument.
lldbutil.run_break_set_by_symbol(self,
"foo",
num_expected_locations=1,
sym_exact=True)
self.runCmd("run", RUN_SUCCEEDED)
# The stop reason of the thread should be breakpoint.
self.expect("thread list",
STOPPED_DUE_TO_BREAKPOINT,
substrs=['stopped', 'stop reason = breakpoint'])
# The breakpoint should have a hit count of 1.
self.expect("breakpoint list -f",
BREAKPOINT_HIT_ONCE,
substrs=[' resolved, hit count = 1'])
# This should display correctly.
# Note that the member fields of a = 1 and b = 2 is by design.
self.expect(
"frame variable --show-types *bar_ptr",
VARIABLES_DISPLAYED_CORRECTLY,
substrs=['(bar) *bar_ptr = ', '(int) a = 1', '(int) b = 2'])
# And so should this.
self.expect("expression --show-types -- *bar_ptr",
VARIABLES_DISPLAYED_CORRECTLY,
substrs=['(bar)', '(int) a = 1', '(int) b = 2'])
def test_break(self):
"""Test setting objc breakpoints using '_regexp-break' and 'breakpoint set'."""
if self.getArchitecture() != 'x86_64':
self.skipTest("This only applies to the v2 runtime")
self.build()
exe = os.path.join(os.getcwd(), "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Stop at -[MyString description].
lldbutil.run_break_set_by_symbol (self, '-[MyString description]', num_expected_locations=1, sym_exact=True)
self.runCmd("run", RUN_SUCCEEDED)
# The backtrace should show we stop at -[MyString description].
self.expect("thread backtrace", "Stop at -[MyString description]",
substrs = ["a.out`-[MyString description]"])
# Use runtime information about NSString.
# The length property should be usable.
self.expect("expression str.length", VARIABLES_DISPLAYED_CORRECTLY,
patterns = [r"(\(unsigned long long\))|\(NSUInteger\)"])
# Static methods on NSString should work.
self.expect("expr [NSString stringWithCString:\"foo\" encoding:1]", VALID_TYPE,
substrs = ["(id)", "$1"])
self.expect("po $1", VARIABLES_DISPLAYED_CORRECTLY,
substrs = ["foo"])
def forward_declaration(self):
"""Display *bar_ptr when stopped on a function with forward declaration of struct bar."""
exe = os.path.join(os.getcwd(), "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Break inside the foo function which takes a bar_ptr argument.
lldbutil.run_break_set_by_symbol(self, "foo", num_expected_locations=1, sym_exact=True)
self.runCmd("run", RUN_SUCCEEDED)
# The stop reason of the thread should be breakpoint.
self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT, substrs=["stopped", "stop reason = breakpoint"])
# The breakpoint should have a hit count of 1.
self.expect("breakpoint list -f", BREAKPOINT_HIT_ONCE, substrs=[" resolved, hit count = 1"])
# This should display correctly.
# Note that the member fields of a = 1 and b = 2 is by design.
self.expect(
"frame variable --show-types *bar_ptr",
VARIABLES_DISPLAYED_CORRECTLY,
substrs=["(bar) *bar_ptr = ", "(int) a = 1", "(int) b = 2"],
)
# And so should this.
self.expect(
"expression --show-types -- *bar_ptr",
VARIABLES_DISPLAYED_CORRECTLY,
substrs=["(bar)", "(int) a = 1", "(int) b = 2"],
)
def convenience_registers(self):
"""Test convenience registers."""
exe = os.path.join(os.getcwd(), "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Break in main().
lldbutil.run_break_set_by_symbol (self, "main", num_expected_locations=-1)
self.runCmd("run", RUN_SUCCEEDED)
# The stop reason of the thread should be breakpoint.
self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
substrs = ['stopped', 'stop reason = breakpoint'])
# The vanilla "register read" command does not output derived register like eax.
self.expect("register read", matching=False,
substrs = ['eax'])
# While "register read -a" does output derived register like eax.
self.expect("register read -a", matching=True,
substrs = ['eax'])
# Test reading of rax and eax.
self.runCmd("register read rax eax")
# Now write rax with a unique bit pattern and test that eax indeed represents the lower half of rax.
self.runCmd("register write rax 0x1234567887654321")
self.expect("expr -- ($rax & 0xffffffff) == $eax",
substrs = ['true'])
self.expect("expr -- $ax == (($ah << 8) | $al)",
substrs = ['true'])
def test_and_run_command(self):
"""Test interpreted and JITted expressions on constant values."""
self.build()
exe = os.path.join(os.getcwd(), "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Break inside the main.
lldbutil.run_break_set_by_symbol (self, "main", num_expected_locations=1)
self.runCmd("run", RUN_SUCCEEDED)
# The stop reason of the thread should be breakpoint.
self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
substrs = ['stopped',
'stop reason = breakpoint'])
# The breakpoint should have a hit count of 1.
self.expect("breakpoint list -f", BREAKPOINT_HIT_ONCE,
substrs = [' resolved, hit count = 1'])
self.runCmd("next")
# Try frame variable.
self.expect("frame variable index", VARIABLES_DISPLAYED_CORRECTLY,
substrs = ['(int32_t) index = 512'])
# Try an interpreted expression.
self.expect("expr (index + 512)", VARIABLES_DISPLAYED_CORRECTLY,
substrs = ['(int) $0 = 1024'])
# Try a JITted expression.
self.expect("expr (int)getpid(); (index - 256)", VARIABLES_DISPLAYED_CORRECTLY,
substrs = ['(int) $1 = 256'])
self.runCmd("kill")
def register_commands(self):
"""Test commands related to registers, in particular xmm registers."""
exe = os.path.join(os.getcwd(), "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Break in main().
lldbutil.run_break_set_by_symbol(self,
"main",
num_expected_locations=-1)
self.runCmd("run", RUN_SUCCEEDED)
# The stop reason of the thread should be breakpoint.
self.expect("thread list",
STOPPED_DUE_TO_BREAKPOINT,
substrs=['stopped', 'stop reason = breakpoint'])
# Test some register-related commands.
self.expect("register read -a",
MISSING_EXPECTED_REGISTERS,
substrs=['registers were unavailable'],
matching=False)
self.runCmd("register read xmm0")
# rdar://problem/10611315
# expression command doesn't handle xmm or stmm registers...
self.expect("expr $xmm0", substrs=['vector_type'])
self.expect("expr (unsigned int)$xmm0[0]", substrs=['unsigned int'])
def runtime_types(self):
exe = os.path.join(os.getcwd(), "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Stop at -[MyString description].
lldbutil.run_break_set_by_symbol (self, '-[MyString description]', num_expected_locations=1, sym_exact=True)
self.runCmd("run", RUN_SUCCEEDED)
# The backtrace should show we stop at -[MyString description].
self.expect("thread backtrace", "Stop at -[MyString description]",
substrs = ["a.out`-[MyString description]"])
# Use runtime information about NSString.
# The length property should be usable.
self.expect("expression str.length", VARIABLES_DISPLAYED_CORRECTLY,
substrs = ["(unsigned long long)"])
# Static methods on NSString should work.
self.expect("expr [NSString stringWithCString:\"foo\" encoding:1]", VALID_TYPE,
substrs = ["(id)", "$1"])
self.expect("po $1", VARIABLES_DISPLAYED_CORRECTLY,
substrs = ["foo"])
def breakpoint_id_tests (self):
exe = os.path.join (os.getcwd(), "a.out")
self.expect("file " + exe,
patterns = [ "Current executable set to .*a.out" ])
bpno = lldbutil.run_break_set_by_symbol (self, 'product', num_expected_locations=-1, sym_exact=False)
self.assertTrue (bpno == 1, "First breakpoint number is 1.")
bpno = lldbutil.run_break_set_by_symbol (self, 'sum', num_expected_locations=-1, sym_exact=False)
self.assertTrue (bpno == 2, "Second breakpoint number is 2.")
bpno = lldbutil.run_break_set_by_symbol (self, 'junk', num_expected_locations=0, sym_exact=False)
self.assertTrue (bpno == 3, "Third breakpoint number is 3.")
self.expect ("breakpoint disable 1.1 - 2.2 ",
COMMAND_FAILED_AS_EXPECTED, error = True,
startstr = "error: Invalid range: Ranges that specify particular breakpoint locations must be within the same major breakpoint; you specified two different major breakpoints, 1 and 2.")
self.expect ("breakpoint disable 2 - 2.2",
COMMAND_FAILED_AS_EXPECTED, error = True,
startstr = "error: Invalid breakpoint id range: Either both ends of range must specify a breakpoint location, or neither can specify a breakpoint location.")
self.expect ("breakpoint disable 2.1 - 2",
COMMAND_FAILED_AS_EXPECTED, error = True,
startstr = "error: Invalid breakpoint id range: Either both ends of range must specify a breakpoint location, or neither can specify a breakpoint location.")
self.expect ("breakpoint disable 2.1 - 2.2",
startstr = "2 breakpoints disabled.")
self.expect ("breakpoint enable 2.*",
patterns = [ ".* breakpoints enabled."] )
def convenience_registers(self):
"""Test convenience registers."""
exe = os.path.join(os.getcwd(), "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Break in main().
lldbutil.run_break_set_by_symbol(self,
"main",
num_expected_locations=-1)
self.runCmd("run", RUN_SUCCEEDED)
# The stop reason of the thread should be breakpoint.
self.expect("thread list",
STOPPED_DUE_TO_BREAKPOINT,
substrs=['stopped', 'stop reason = breakpoint'])
# The vanilla "register read" command does not output derived register like eax.
self.expect("register read", matching=False, substrs=['eax'])
# While "register read -a" does output derived register like eax.
self.expect("register read -a", matching=True, substrs=['eax'])
# Test reading of rax and eax.
self.runCmd("register read rax eax")
# Now write rax with a unique bit pattern and test that eax indeed represents the lower half of rax.
self.runCmd("register write rax 0x1234567887654321")
self.expect("expr -- ($rax & 0xffffffff) == $eax", substrs=['true'])
self.expect("expr -- $ax == (($ah << 8) | $al)", substrs=['true'])
def test_expr_commands(self):
"""The evaluating printf(...) after break stop and then up a stack frame."""
self.buildDefault()
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_symbol(self,
'foo',
sym_exact=True,
num_expected_locations=1)
self.runCmd("run", RUN_SUCCEEDED)
self.runCmd("frame variable")
# This works fine.
self.runCmd('expression (int)printf("value is: %d.\\n", value);')
# rdar://problem/9531204
# "Error dematerializing struct" error when evaluating expressions "up" on the stack
self.runCmd('up') # frame select -r 1
self.runCmd("frame variable")
# This does not currently.
self.runCmd('expression (int)printf("argc is: %d.\\n", argc)')
def objc_optimized(self):
"""Test 'expr member' continues to work for optimized build."""
exe = os.path.join(os.getcwd(), "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_symbol (self, self.method_spec, num_expected_locations=1, sym_exact=True)
self.runCmd("run", RUN_SUCCEEDED)
self.expect("thread backtrace", STOPPED_DUE_TO_BREAKPOINT,
substrs = ["stop reason = breakpoint"],
patterns = ["frame.*0:.*%s %s" % (self.myclass, self.mymethod)])
self.expect('expression member',
startstr = "(int) $0 = 5")
# <rdar://problem/12693963>
interp = self.dbg.GetCommandInterpreter()
result = lldb.SBCommandReturnObject()
interp.HandleCommand('frame variable self', result)
output = result.GetOutput()
desired_pointer = "0x0"
mo = re.search("0x[0-9a-f]+", output)
if mo:
desired_pointer = mo.group(0)
self.expect('expression (self)',
substrs = [("(%s *) $1 = " % self.myclass), desired_pointer])
self.expect('expression self->non_member', error=True,
substrs = ["does not have a member named 'non_member'"])
def register_commands(self):
"""Test commands related to registers, in particular xmm registers."""
exe = os.path.join(os.getcwd(), "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Break in main().
lldbutil.run_break_set_by_symbol (self, "main", num_expected_locations=-1)
self.runCmd("run", RUN_SUCCEEDED)
# The stop reason of the thread should be breakpoint.
self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
substrs = ['stopped', 'stop reason = breakpoint'])
# Test some register-related commands.
self.expect("register read -a", MISSING_EXPECTED_REGISTERS,
substrs = ['registers were unavailable'], matching = False)
self.runCmd("register read xmm0")
# rdar://problem/10611315
# expression command doesn't handle xmm or stmm registers...
self.expect("expr $xmm0",
substrs = ['vector_type'])
self.expect("expr (unsigned int)$xmm0[0]",
substrs = ['unsigned int'])
def const_variable(self):
"""Test interpreted and JITted expressions on constant values."""
exe = os.path.join(os.getcwd(), "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Break inside the main.
lldbutil.run_break_set_by_symbol (self, "main", num_expected_locations=1)
self.runCmd("run", RUN_SUCCEEDED)
# The stop reason of the thread should be breakpoint.
self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
substrs = ['stopped',
'stop reason = breakpoint'])
# The breakpoint should have a hit count of 1.
self.expect("breakpoint list -f", BREAKPOINT_HIT_ONCE,
substrs = [' resolved, hit count = 1'])
self.runCmd("next")
# Try frame variable.
self.expect("frame variable index", VARIABLES_DISPLAYED_CORRECTLY,
substrs = ['(int32_t) index = 512'])
# Try an interpreted expression.
self.expect("expr (index + 512)", VARIABLES_DISPLAYED_CORRECTLY,
substrs = ['(int) $0 = 1024'])
# Try a JITted expression.
self.expect("expr (int)getpid(); (index - 256)", VARIABLES_DISPLAYED_CORRECTLY,
substrs = ['(int) $1 = 256'])
self.runCmd("kill")
def expression_lookups_objc(self):
"""Test running an expression and make sure we don't search all dwarf files for any internal names (anything that contains '__lldb')."""
exe = os.path.join(os.getcwd(), "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Stop at -[MyString initWithNSString:].
lldbutil.run_break_set_by_symbol(
self, "-[MyString initWithNSString:]", num_expected_locations=1, sym_exact=True
)
self.runCmd("run", RUN_SUCCEEDED)
# Log any DWARF lookups
logfile = os.path.join(os.getcwd(), "dwarf-lookups.txt")
self.runCmd("log enable -f %s dwarf lookups" % (logfile))
self.runCmd("expr self")
self.runCmd("log disable dwarf lookups")
def cleanup():
os.unlink(logfile)
self.addTearDownHook(cleanup)
f = open(logfile)
lines = f.readlines()
num_errors = 0
for line in lines:
if string.find(line, "$__lldb") != -1:
if num_errors == 0:
print "error: found spurious name lookups when evaluating an expression:"
num_errors += 1
print line,
self.assertTrue(num_errors == 0, "Spurious lookups detected")
f.close()
def do_simple_disasm(self):
"""Do a bunch of simple disassemble commands."""
exe = os.path.join(os.getcwd(), "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Stop at +[NSString stringWithFormat:].
symbol_name = "+[NSString stringWithFormat:]"
break_results = lldbutil.run_break_set_command (self, "_regexp-break %s"%(symbol_name))
lldbutil.check_breakpoint_result (self, break_results, symbol_name=symbol_name, num_locations=1)
# Stop at -[MyString initWithNSString:].
lldbutil.run_break_set_by_symbol (self, '-[MyString initWithNSString:]', num_expected_locations=1, sym_exact=True)
# Stop at the "description" selector.
lldbutil.run_break_set_by_selector (self, 'description', num_expected_locations=1)
# Stop at -[NSAutoreleasePool release].
break_results = lldbutil.run_break_set_command (self, "_regexp-break -[NSAutoreleasePool release]")
lldbutil.check_breakpoint_result (self, break_results, symbol_name='-[NSAutoreleasePool release]', num_locations=1)
self.runCmd("run", RUN_SUCCEEDED)
# First stop is +[NSString stringWithFormat:].
self.expect("thread backtrace", "Stop at +[NSString stringWithFormat:]",
substrs = ["Foundation`+[NSString stringWithFormat:]"])
# Do the disassemble for the currently stopped function.
self.runCmd("disassemble -f")
self.runCmd("process continue")
# Skip another breakpoint for +[NSString stringWithFormat:].
self.runCmd("process continue")
# Followed by a.out`-[MyString initWithNSString:].
self.expect("thread backtrace", "Stop at a.out`-[MyString initWithNSString:]",
substrs = ["a.out`-[MyString initWithNSString:]"])
# Do the disassemble for the currently stopped function.
self.runCmd("disassemble -f")
self.runCmd("process continue")
# Followed by -[MyString description].
self.expect("thread backtrace", "Stop at -[MyString description]",
substrs = ["a.out`-[MyString description]"])
# Do the disassemble for the currently stopped function.
self.runCmd("disassemble -f")
self.runCmd("process continue")
# Skip another breakpoint for -[MyString description].
self.runCmd("process continue")
# Followed by -[NSAutoreleasePool release].
self.expect("thread backtrace", "Stop at -[NSAutoreleasePool release]",
substrs = ["Foundation`-[NSAutoreleasePool release]"])
# Do the disassemble for the currently stopped function.
self.runCmd("disassemble -f")
def fp_register_write(self):
exe = os.path.join(os.getcwd(), "a.out")
# Create a target by the debugger.
target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET)
lldbutil.run_break_set_by_symbol (self, "main", num_expected_locations=-1)
# Launch the process, and do not stop at the entry point.
process = target.LaunchSimple(None, None, os.getcwd())
process = target.GetProcess()
self.assertTrue(process.GetState() == lldb.eStateStopped,
PROCESS_STOPPED)
thread = process.GetThreadAtIndex(0)
self.assertTrue(thread.IsValid(), "current thread is valid")
currentFrame = thread.GetFrameAtIndex(0)
self.assertTrue(currentFrame.IsValid(), "current frame is valid")
self.write_and_restore(currentFrame, "fcw", False)
self.write_and_restore(currentFrame, "fsw", False)
self.write_and_restore(currentFrame, "ftw", False)
self.write_and_restore(currentFrame, "ip", False)
self.write_and_restore(currentFrame, "dp", False)
self.write_and_restore(currentFrame, "mxcsr", False)
self.write_and_restore(currentFrame, "mxcsrmask", False)
new_value = "{0x01 0x02 0x03 0x00 0x00 0x00 0x00 0x00 0x00 0x00}"
self.vector_write_and_read(currentFrame, "stmm0", new_value)
new_value = "{0x01 0x02 0x03 0x00 0x00 0x00 0x00 0x00 0x09 0x0a}"
self.vector_write_and_read(currentFrame, "stmm7", new_value)
new_value = "{0x01 0x02 0x03 0x00 0x00 0x00 0x00 0x00 0x09 0x0a 0x2f 0x2f 0x2f 0x2f 0x2f 0x2f}"
self.vector_write_and_read(currentFrame, "xmm0", new_value)
new_value = "{0x01 0x02 0x03 0x00 0x00 0x00 0x00 0x00 0x09 0x0a 0x2f 0x2f 0x2f 0x2f 0x0e 0x0f}"
self.vector_write_and_read(currentFrame, "xmm15", new_value, False)
self.runCmd("register write stmm0 \"{0x00 0x00 0x00 0x00 0x00 0x00 0x40 0x9a 0x09 0x40}\"")
self.expect("register read stmm0 --format f",
substrs = ['stmm0 = 1234'])
has_avx = False
registerSets = currentFrame.GetRegisters() # Returns an SBValueList.
for registerSet in registerSets:
if 'advanced vector extensions' in registerSet.GetName().lower():
has_avx = True
break
if has_avx:
new_value = "{0x01 0x02 0x03 0x00 0x00 0x00 0x00 0x00 0x09 0x0a 0x2f 0x2f 0x2f 0x2f 0x0e 0x0f 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x0c 0x0d 0x0e 0x0f}"
self.vector_write_and_read(currentFrame, "ymm0", new_value)
self.vector_write_and_read(currentFrame, "ymm15", new_value)
self.expect("expr $ymm0", substrs = ['vector_type'])
else:
self.runCmd("register read ymm0")
def sigtramp_unwind_tests (self):
exe = os.path.join(os.getcwd(), "a.out")
target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET)
lldbutil.run_break_set_by_file_and_line (self, "main.c", line_number('main.c', '// Set breakpoint here'), num_expected_locations=1)
process = target.LaunchSimple (None, None, self.get_process_working_directory())
if not process:
self.fail("SBTarget.Launch() failed")
if process.GetState() != lldb.eStateStopped:
self.fail("Process should be in the 'stopped' state, "
"instead the actual state is: '%s'" %
lldbutil.state_type_to_str(process.GetState()))
self.expect("pro handle -n false -p true -s false SIGUSR1", "Have lldb pass SIGUSR1 signals",
substrs = ["SIGUSR1", "true", "false", "false"])
lldbutil.run_break_set_by_symbol (self, "handler", num_expected_locations=1, module_name="a.out")
self.runCmd("continue")
thread = process.GetThreadAtIndex(0)
found_handler = False
found_sigtramp = False
found_kill = False
found_main = False
for f in thread.frames:
if f.GetFunctionName() == "handler":
found_handler = True
if f.GetFunctionName() == "_sigtramp":
found_sigtramp = True
if f.GetFunctionName() == "__kill":
found_kill = True
if f.GetFunctionName() == "main":
found_main = True
if self.TraceOn():
print "Backtrace once we're stopped:"
for f in thread.frames:
print " %d %s" % (f.GetFrameID(), f.GetFunctionName())
if found_handler == False:
self.fail("Unable to find handler() in backtrace.")
if found_sigtramp == False:
self.fail("Unable to find _sigtramp() in backtrace.")
if found_kill == False:
self.fail("Unable to find kill() in backtrace.")
if found_main == False:
self.fail("Unable to find main() in backtrace.")
def fp_register_write(self):
exe = os.path.join(os.getcwd(), "a.out")
# Create a target by the debugger.
target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET)
lldbutil.run_break_set_by_symbol(self,
"main",
num_expected_locations=-1)
# Launch the process, and do not stop at the entry point.
process = target.LaunchSimple(None, None, os.getcwd())
process = target.GetProcess()
self.assertTrue(process.GetState() == lldb.eStateStopped,
PROCESS_STOPPED)
thread = process.GetThreadAtIndex(0)
self.assertTrue(thread.IsValid(), "current thread is valid")
currentFrame = thread.GetFrameAtIndex(0)
self.assertTrue(currentFrame.IsValid(), "current frame is valid")
self.write_and_restore(currentFrame, "fcw", False)
self.write_and_restore(currentFrame, "fsw", False)
self.write_and_restore(currentFrame, "ftw", False)
self.write_and_restore(currentFrame, "ip", False)
self.write_and_restore(currentFrame, "dp", False)
self.write_and_restore(currentFrame, "mxcsr", False)
self.write_and_restore(currentFrame, "mxcsrmask", False)
new_value = "{0x01 0x02 0x03 0x00 0x00 0x00 0x00 0x00 0x00 0x00}"
self.vector_write_and_read(currentFrame, "stmm0", new_value)
new_value = "{0x01 0x02 0x03 0x00 0x00 0x00 0x00 0x00 0x09 0x0a}"
self.vector_write_and_read(currentFrame, "stmm7", new_value)
new_value = "{0x01 0x02 0x03 0x00 0x00 0x00 0x00 0x00 0x09 0x0a 0x2f 0x2f 0x2f 0x2f 0x2f 0x2f}"
self.vector_write_and_read(currentFrame, "xmm0", new_value)
new_value = "{0x01 0x02 0x03 0x00 0x00 0x00 0x00 0x00 0x09 0x0a 0x2f 0x2f 0x2f 0x2f 0x0e 0x0f}"
self.vector_write_and_read(currentFrame, "xmm15", new_value, False)
has_avx = False
registerSets = currentFrame.GetRegisters() # Returns an SBValueList.
for registerSet in registerSets:
if 'advanced vector extensions' in registerSet.GetName().lower():
has_avx = True
break
if has_avx:
new_value = "{0x01 0x02 0x03 0x00 0x00 0x00 0x00 0x00 0x09 0x0a 0x2f 0x2f 0x2f 0x2f 0x0e 0x0f 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x0c 0x0d 0x0e 0x0f}"
self.vector_write_and_read(currentFrame, "ymm0", new_value)
self.vector_write_and_read(currentFrame, "ymm15", new_value)
self.expect("expr $ymm0", substrs=['vector_type'])
else:
self.runCmd("register read ymm0")
def breakpoint_conditions(self, inline=False):
"""Exercise breakpoint condition with 'breakpoint modify -c <expr> id'."""
exe = os.path.join(os.getcwd(), "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
if inline:
# Create a breakpoint by function name 'c' and set the condition.
lldbutil.run_break_set_by_symbol (self, "c", extra_options="-c 'val == 3'", num_expected_locations=1, sym_exact=True)
else:
# Create a breakpoint by function name 'c'.
lldbutil.run_break_set_by_symbol (self, "c", num_expected_locations=1, sym_exact=True)
# And set a condition on the breakpoint to stop on when 'val == 3'.
self.runCmd("breakpoint modify -c 'val == 3' 1")
# Now run the program.
self.runCmd("run", RUN_SUCCEEDED)
# The process should be stopped at this point.
self.expect("process status", PROCESS_STOPPED,
patterns = ['Process .* stopped'])
# 'frame variable --show-types val' should return 3 due to breakpoint condition.
self.expect("frame variable --show-types val", VARIABLES_DISPLAYED_CORRECTLY,
startstr = '(int) val = 3')
# Also check the hit count, which should be 3, by design.
self.expect("breakpoint list -f", BREAKPOINT_HIT_THRICE,
substrs = ["resolved = 1",
"Condition: val == 3",
"hit count = 3"])
# The frame #0 should correspond to main.c:36, the executable statement
# in function name 'c'. And the parent frame should point to main.c:24.
self.expect("thread backtrace", STOPPED_DUE_TO_BREAKPOINT_CONDITION,
#substrs = ["stop reason = breakpoint"],
patterns = ["frame #0.*main.c:%d" % self.line1,
"frame #1.*main.c:%d" % self.line2])
# Test that "breakpoint modify -c ''" clears the condition for the last
# created breakpoint, so that when the breakpoint hits, val == 1.
self.runCmd("process kill")
self.runCmd("breakpoint modify -c ''")
self.expect("breakpoint list -f", BREAKPOINT_STATE_CORRECT, matching=False,
substrs = ["Condition:"])
# Now run the program again.
self.runCmd("run", RUN_SUCCEEDED)
# The process should be stopped at this point.
self.expect("process status", PROCESS_STOPPED,
patterns = ['Process .* stopped'])
# 'frame variable --show-types val' should return 1 since it is the first breakpoint hit.
self.expect("frame variable --show-types val", VARIABLES_DISPLAYED_CORRECTLY,
startstr = '(int) val = 1')
def test_break(self):
"""Test setting objc breakpoints using '_regexp-break' and 'breakpoint set'."""
self.build()
exe = os.path.join(os.getcwd(), "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Stop at +[NSString stringWithFormat:].
break_results = lldbutil.run_break_set_command(self, "_regexp-break +[NSString stringWithFormat:]")
lldbutil.check_breakpoint_result (self, break_results, symbol_name='+[NSString stringWithFormat:]', num_locations=1)
# Stop at -[MyString initWithNSString:].
lldbutil.run_break_set_by_symbol (self, '-[MyString initWithNSString:]', num_expected_locations=1, sym_exact=True)
# Stop at the "description" selector.
lldbutil.run_break_set_by_selector (self, 'description', num_expected_locations=1, module_name='a.out')
# Stop at -[NSAutoreleasePool release].
break_results = lldbutil.run_break_set_command(self, "_regexp-break -[NSAutoreleasePool release]")
lldbutil.check_breakpoint_result (self, break_results, symbol_name='-[NSAutoreleasePool release]', num_locations=1)
self.runCmd("run", RUN_SUCCEEDED)
# First stop is +[NSString stringWithFormat:].
self.expect("thread backtrace", "Stop at +[NSString stringWithFormat:]",
substrs = ["Foundation`+[NSString stringWithFormat:]"])
self.runCmd("process continue")
# Second stop is still +[NSString stringWithFormat:].
self.expect("thread backtrace", "Stop at +[NSString stringWithFormat:]",
substrs = ["Foundation`+[NSString stringWithFormat:]"])
self.runCmd("process continue")
# Followed by a.out`-[MyString initWithNSString:].
self.expect("thread backtrace", "Stop at a.out`-[MyString initWithNSString:]",
substrs = ["a.out`-[MyString initWithNSString:]"])
self.runCmd("process continue")
# Followed by -[MyString description].
self.expect("thread backtrace", "Stop at -[MyString description]",
substrs = ["a.out`-[MyString description]"])
self.runCmd("process continue")
# Followed by the same -[MyString description].
self.expect("thread backtrace", "Stop at -[MyString description]",
substrs = ["a.out`-[MyString description]"])
self.runCmd("process continue")
# Followed by -[NSAutoreleasePool release].
self.expect("thread backtrace", "Stop at -[NSAutoreleasePool release]",
substrs = ["Foundation`-[NSAutoreleasePool release]"])
def test(self):
self.build()
exe = os.path.join(os.getcwd(), "a.out")
self.expect("file " + exe,
patterns=["Current executable set to .*a.out"])
bpno = lldbutil.run_break_set_by_symbol(self,
'product',
num_expected_locations=-1,
sym_exact=False)
self.assertTrue(bpno == 1, "First breakpoint number is 1.")
bpno = lldbutil.run_break_set_by_symbol(self,
'sum',
num_expected_locations=-1,
sym_exact=False)
self.assertTrue(bpno == 2, "Second breakpoint number is 2.")
bpno = lldbutil.run_break_set_by_symbol(self,
'junk',
num_expected_locations=0,
sym_exact=False)
self.assertTrue(bpno == 3, "Third breakpoint number is 3.")
self.expect(
"breakpoint disable 1.1 - 2.2 ",
COMMAND_FAILED_AS_EXPECTED,
error=True,
startstr=
"error: Invalid range: Ranges that specify particular breakpoint locations must be within the same major breakpoint; you specified two different major breakpoints, 1 and 2."
)
self.expect(
"breakpoint disable 2 - 2.2",
COMMAND_FAILED_AS_EXPECTED,
error=True,
startstr=
"error: Invalid breakpoint id range: Either both ends of range must specify a breakpoint location, or neither can specify a breakpoint location."
)
self.expect(
"breakpoint disable 2.1 - 2",
COMMAND_FAILED_AS_EXPECTED,
error=True,
startstr=
"error: Invalid breakpoint id range: Either both ends of range must specify a breakpoint location, or neither can specify a breakpoint location."
)
self.expect("breakpoint disable 2.1 - 2.2",
startstr="2 breakpoints disabled.")
self.expect("breakpoint enable 2.*",
patterns=[".* breakpoints enabled."])
def break_on_objc_methods(self):
"""Test setting objc breakpoints using '_regexp-break' and 'breakpoint set'."""
exe = os.path.join(os.getcwd(), "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Stop at +[NSString stringWithFormat:].
break_results = lldbutil.run_break_set_command(self, "_regexp-break +[NSString stringWithFormat:]")
lldbutil.check_breakpoint_result (self, break_results, symbol_name='+[NSString stringWithFormat:]', num_locations=1)
# Stop at -[MyString initWithNSString:].
lldbutil.run_break_set_by_symbol (self, '-[MyString initWithNSString:]', num_expected_locations=1, sym_exact=True)
# Stop at the "description" selector.
lldbutil.run_break_set_by_selector (self, 'description', num_expected_locations=1)
# Stop at -[NSAutoreleasePool release].
break_results = lldbutil.run_break_set_command(self, "_regexp-break -[NSAutoreleasePool release]")
lldbutil.check_breakpoint_result (self, break_results, symbol_name='-[NSAutoreleasePool release]', num_locations=1)
self.runCmd("run", RUN_SUCCEEDED)
# First stop is +[NSString stringWithFormat:].
self.expect("thread backtrace", "Stop at +[NSString stringWithFormat:]",
substrs = ["Foundation`+[NSString stringWithFormat:]"])
self.runCmd("process continue")
# Second stop is still +[NSString stringWithFormat:].
self.expect("thread backtrace", "Stop at +[NSString stringWithFormat:]",
substrs = ["Foundation`+[NSString stringWithFormat:]"])
self.runCmd("process continue")
# Followed by a.out`-[MyString initWithNSString:].
self.expect("thread backtrace", "Stop at a.out`-[MyString initWithNSString:]",
substrs = ["a.out`-[MyString initWithNSString:]"])
self.runCmd("process continue")
# Followed by -[MyString description].
self.expect("thread backtrace", "Stop at -[MyString description]",
substrs = ["a.out`-[MyString description]"])
self.runCmd("process continue")
# Followed by the same -[MyString description].
self.expect("thread backtrace", "Stop at -[MyString description]",
substrs = ["a.out`-[MyString description]"])
self.runCmd("process continue")
# Followed by -[NSAutoreleasePool release].
self.expect("thread backtrace", "Stop at -[NSAutoreleasePool release]",
substrs = ["Foundation`-[NSAutoreleasePool release]"])
def start_test(self, symbol):
exe = os.path.join(os.getcwd(), "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Break in main().
lldbutil.run_break_set_by_symbol(self, symbol, num_expected_locations=-1)
self.runCmd("run", RUN_SUCCEEDED)
# The stop reason of the thread should be breakpoint.
self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT, substrs=["stopped", "stop reason = breakpoint"])
def common_setup(self):
exe = os.path.join(os.getcwd(), "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Break in main().
lldbutil.run_break_set_by_symbol (self, "main", num_expected_locations=-1)
self.runCmd("run", RUN_FAILED)
# The stop reason of the thread should be breakpoint.
self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
substrs = ['stopped', 'stop reason = breakpoint'])
def common_setup(self):
exe = os.path.join(os.getcwd(), "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Break in main().
lldbutil.run_break_set_by_symbol (self, "main", num_expected_locations=-1)
self.runCmd("run", RUN_SUCCEEDED)
# The stop reason of the thread should be breakpoint.
self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
substrs = ['stopped', 'stop reason = breakpoint'])
def test_watched_var_should_only_hit_when_in_scope(self):
"""Test that a variable watchpoint should only hit when in scope."""
self.build(dictionary=self.d)
self.setTearDownCleanup(dictionary=self.d)
exe = os.path.join(os.getcwd(), self.exe_name)
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Add a breakpoint to set a watchpoint when stopped in main.
lldbutil.run_break_set_by_symbol(self,
"main",
num_expected_locations=-1)
# Run the program.
self.runCmd("run", RUN_SUCCEEDED)
# We should be stopped again due to the breakpoint.
# The stop reason of the thread should be breakpoint.
self.expect("thread list",
STOPPED_DUE_TO_BREAKPOINT,
substrs=['stopped', 'stop reason = breakpoint'])
# Now let's set a watchpoint for 'c.a'.
# There should be only one watchpoint hit (see main.c).
self.expect("watchpoint set variable c.a",
WATCHPOINT_CREATED,
substrs=['Watchpoint created', 'size = 4', 'type = w'])
# Use the '-v' option to do verbose listing of the watchpoint.
# The hit count should be 0 initially.
self.expect("watchpoint list -v", substrs=['hit_count = 0'])
self.runCmd("process continue")
# We should be stopped again due to the watchpoint (write type), but
# only once. The stop reason of the thread should be watchpoint.
self.expect("thread list",
STOPPED_DUE_TO_WATCHPOINT,
substrs=['stopped', 'stop reason = watchpoint'])
self.runCmd("process continue")
# Don't expect the read of 'global' to trigger a stop exception.
# The process status should be 'exited'.
self.expect("process status", substrs=['exited'])
# Use the '-v' option to do verbose listing of the watchpoint.
# The hit count should now be 1.
self.expect("watchpoint list -v", substrs=['hit_count = 1'])
def test_watched_var_should_only_hit_when_in_scope(self):
"""Test that a variable watchpoint should only hit when in scope."""
self.build(dictionary=self.d)
self.setTearDownCleanup(dictionary=self.d)
exe = os.path.join(os.getcwd(), self.exe_name)
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Add a breakpoint to set a watchpoint when stopped in main.
lldbutil.run_break_set_by_symbol (self, "main", num_expected_locations=-1)
# Run the program.
self.runCmd("run", RUN_SUCCEEDED)
# We should be stopped again due to the breakpoint.
# The stop reason of the thread should be breakpoint.
self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
substrs = ['stopped',
'stop reason = breakpoint'])
# Now let's set a watchpoint for 'c.a'.
# There should be only one watchpoint hit (see main.c).
self.expect("watchpoint set variable c.a", WATCHPOINT_CREATED,
substrs = ['Watchpoint created', 'size = 4', 'type = w'])
# Use the '-v' option to do verbose listing of the watchpoint.
# The hit count should be 0 initially.
self.expect("watchpoint list -v",
substrs = ['hit_count = 0'])
self.runCmd("process continue")
# We should be stopped again due to the watchpoint (write type), but
# only once. The stop reason of the thread should be watchpoint.
self.expect("thread list", STOPPED_DUE_TO_WATCHPOINT,
substrs = ['stopped',
'stop reason = watchpoint'])
self.runCmd("process continue")
# Don't expect the read of 'global' to trigger a stop exception.
# The process status should be 'exited'.
self.expect("process status",
substrs = ['exited'])
# Use the '-v' option to do verbose listing of the watchpoint.
# The hit count should now be 1.
self.expect("watchpoint list -v",
substrs = ['hit_count = 1'])
def function_types(self):
"""Test 'callback' has function ptr type, then break on the function."""
self.runToBreakpoint()
# Check that the 'callback' variable display properly.
self.expect("frame variable --show-types callback", VARIABLES_DISPLAYED_CORRECTLY,
startstr = '(int (*)(const char *)) callback =')
# And that we can break on the callback function.
lldbutil.run_break_set_by_symbol (self, "string_not_empty", num_expected_locations=1, sym_exact=True)
self.runCmd("continue")
# Check that we do indeed stop on the string_not_empty function.
self.expect("process status", STOPPED_DUE_TO_BREAKPOINT,
substrs = ['a.out`string_not_empty',
'stop reason = breakpoint'])
def function_types(self):
"""Test 'callback' has function ptr type, then break on the function."""
self.runToBreakpoint()
# Check that the 'callback' variable display properly.
self.expect("frame variable --show-types callback", VARIABLES_DISPLAYED_CORRECTLY,
startstr = '(int (*)(const char *)) callback =')
# And that we can break on the callback function.
lldbutil.run_break_set_by_symbol (self, "string_not_empty", num_expected_locations=1, sym_exact=True)
self.runCmd("continue")
# Check that we do indeed stop on the string_not_empty function.
self.expect("process status", STOPPED_DUE_TO_BREAKPOINT,
substrs = ['a.out`string_not_empty',
'stop reason = breakpoint'])
def test_load_unload(self):
"""Test breakpoint by name works correctly with dlopen'ing."""
# Invoke the default build rule.
self.buildDefault()
self.copy_shlibs_to_remote()
exe = os.path.join(os.getcwd(), "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Break by function name a_function (not yet loaded).
lldbutil.run_break_set_by_symbol(self,
"a_function",
num_expected_locations=0)
self.runCmd("run", RUN_SUCCEEDED)
# The stop reason of the thread should be breakpoint and at a_function.
self.expect(
"thread list",
STOPPED_DUE_TO_BREAKPOINT,
substrs=['stopped', 'a_function', 'stop reason = breakpoint'])
# The breakpoint should have a hit count of 1.
self.expect("breakpoint list -f",
BREAKPOINT_HIT_ONCE,
substrs=[' resolved, hit count = 1'])
# Issue the 'contnue' command. We should stop agaian at a_function.
# The stop reason of the thread should be breakpoint and at a_function.
self.runCmd("continue")
# rdar://problem/8508987
# The a_function breakpoint should be encountered twice.
self.expect(
"thread list",
STOPPED_DUE_TO_BREAKPOINT,
substrs=['stopped', 'a_function', 'stop reason = breakpoint'])
# The breakpoint should have a hit count of 2.
self.expect("breakpoint list -f",
BREAKPOINT_HIT_ONCE,
substrs=[' resolved, hit count = 2'])
def test_expression_lookups_objc(self):
"""Test running an expression detect spurious debug info lookups (DWARF)."""
self.build()
exe = os.path.join(os.getcwd(), "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Stop at -[MyString initWithNSString:].
lldbutil.run_break_set_by_symbol(self,
'-[MyString initWithNSString:]',
num_expected_locations=1,
sym_exact=True)
self.runCmd("run", RUN_SUCCEEDED)
global file_index
# Log any DWARF lookups
++file_index
logfile = os.path.join(
os.getcwd(), "dwarf-lookups-" + self.getArchitecture() + "-" +
str(file_index) + ".txt")
self.runCmd("log enable -f %s dwarf lookups" % (logfile))
self.runCmd("expr self")
self.runCmd("log disable dwarf lookups")
def cleanup():
if os.path.exists(logfile):
os.unlink(logfile)
self.addTearDownHook(cleanup)
if os.path.exists(logfile):
f = open(logfile)
lines = f.readlines()
num_errors = 0
for line in lines:
if string.find(line, "$__lldb") != -1:
if num_errors == 0:
print "error: found spurious name lookups when evaluating an expression:"
num_errors += 1
print line,
self.assertTrue(num_errors == 0, "Spurious lookups detected")
f.close()
def objc_optimized(self):
"""Test 'expr member' continues to work for optimized build."""
exe = os.path.join(os.getcwd(), "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_symbol (self, self.method_spec, num_expected_locations=1, sym_exact=True)
self.runCmd("run", RUN_SUCCEEDED)
self.expect("thread backtrace", STOPPED_DUE_TO_BREAKPOINT,
substrs = ["stop reason = breakpoint"],
patterns = ["frame.*0:.*%s %s" % (self.myclass, self.mymethod)])
self.expect('expression member',
startstr = "(int) $0 = 5")
self.expect('expression self',
startstr = "(%s *) $1 = " % self.myclass)
self.expect('expression self->non_member', error=True,
substrs = ["does not have a member named 'non_member'"])
def test_memory_read(self):
self.build()
exe = os.path.join(os.getcwd(), "a.out")
target = self.dbg.CreateTarget(exe)
lldbutil.run_break_set_by_symbol(self, "main")
process = target.LaunchSimple(None, None, self.get_process_working_directory())
self.assertTrue(process, PROCESS_IS_VALID)
self.assertEqual(process.GetState(), lldb.eStateStopped, "Process is stopped")
pc = process.GetSelectedThread().GetSelectedFrame().GetPC()
for size in [1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024]:
error = lldb.SBError()
memory = process.ReadMemory(pc, size, error)
self.assertTrue(error.Success())
self.match("process plugin packet send x%x,%x" % (pc, size), ["response:", memory])
self.match("process plugin packet send m%x,%x" % (pc, size), ["response:", binascii.hexlify(memory)])
process.Continue()
self.assertEqual(process.GetState(), lldb.eStateExited, "Process exited")
def breakpoint_options_language_test(self):
"""Test breakpoint command for language option."""
exe = os.path.join(os.getcwd(), "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# This should create a breakpoint with 1 locations.
lldbutil.run_break_set_by_symbol (self, 'ns::func', sym_exact=False, extra_options = "-L c++", num_expected_locations=1)
# This should create a breakpoint with 0 locations.
lldbutil.run_break_set_by_symbol (self, 'ns::func', sym_exact=False, extra_options = "-L c", num_expected_locations=0)
self.runCmd("settings set target.language c")
lldbutil.run_break_set_by_symbol (self, 'ns::func', sym_exact=False, num_expected_locations=0)
# Run the program.
self.runCmd("run", RUN_SUCCEEDED)
# Stopped once.
self.expect("thread backtrace", STOPPED_DUE_TO_BREAKPOINT,
substrs = ["stop reason = breakpoint 1."])
# Continue the program, we should exit.
self.runCmd("process continue")
# We should exit.
self.expect("process status", "Process exited successfully",
patterns = ["^Process [0-9]+ exited with status = 0"])
def test_load_unload(self):
"""Test breakpoint by name works correctly with dlopen'ing."""
# Invoke the default build rule.
self.buildDefault()
self.copy_shlibs_to_remote()
exe = os.path.join(os.getcwd(), "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Break by function name a_function (not yet loaded).
lldbutil.run_break_set_by_symbol (self, "a_function", num_expected_locations=0)
self.runCmd("run", RUN_SUCCEEDED)
# The stop reason of the thread should be breakpoint and at a_function.
self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
substrs = ['stopped',
'a_function',
'stop reason = breakpoint'])
# The breakpoint should have a hit count of 1.
self.expect("breakpoint list -f", BREAKPOINT_HIT_ONCE,
substrs = [' resolved, hit count = 1'])
# Issue the 'contnue' command. We should stop agaian at a_function.
# The stop reason of the thread should be breakpoint and at a_function.
self.runCmd("continue")
# rdar://problem/8508987
# The a_function breakpoint should be encountered twice.
self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
substrs = ['stopped',
'a_function',
'stop reason = breakpoint'])
# The breakpoint should have a hit count of 2.
self.expect("breakpoint list -f", BREAKPOINT_HIT_ONCE,
substrs = [' resolved, hit count = 2'])
def test_expression_lookups_objc(self):
"""Test running an expression detect spurious debug info lookups (DWARF)."""
self.build()
exe = os.path.join(os.getcwd(), "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Stop at -[MyString initWithNSString:].
lldbutil.run_break_set_by_symbol(
self, "-[MyString initWithNSString:]", num_expected_locations=1, sym_exact=True
)
self.runCmd("run", RUN_SUCCEEDED)
global file_index
# Log any DWARF lookups
++file_index
logfile = os.path.join(os.getcwd(), "dwarf-lookups-" + self.getArchitecture() + "-" + str(file_index) + ".txt")
self.runCmd("log enable -f %s dwarf lookups" % (logfile))
self.runCmd("expr self")
self.runCmd("log disable dwarf lookups")
def cleanup():
if os.path.exists(logfile):
os.unlink(logfile)
self.addTearDownHook(cleanup)
if os.path.exists(logfile):
f = open(logfile)
lines = f.readlines()
num_errors = 0
for line in lines:
if string.find(line, "$__lldb") != -1:
if num_errors == 0:
print("error: found spurious name lookups when evaluating an expression:")
num_errors += 1
print(line, end="")
self.assertTrue(num_errors == 0, "Spurious lookups detected")
f.close()
def test_expr_commands(self):
"""The evaluating printf(...) after break stop and then up a stack frame."""
self.buildDefault()
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_symbol (self, 'foo', sym_exact=True, num_expected_locations=1)
self.runCmd("run", RUN_SUCCEEDED)
self.runCmd("frame variable")
# This works fine.
self.runCmd('expression (int)printf("value is: %d.\\n", value);')
# rdar://problem/9531204
# "Error dematerializing struct" error when evaluating expressions "up" on the stack
self.runCmd('up') # frame select -r 1
self.runCmd("frame variable")
# This does not currently.
self.runCmd('expression (int)printf("argc is: %d.\\n", argc)')
def objc_optimized(self):
"""Test 'expr member' continues to work for optimized build."""
exe = os.path.join(os.getcwd(), "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_symbol(self,
self.method_spec,
num_expected_locations=1,
sym_exact=True)
self.runCmd("run", RUN_SUCCEEDED)
self.expect(
"thread backtrace",
STOPPED_DUE_TO_BREAKPOINT,
substrs=["stop reason = breakpoint"],
patterns=["frame.*0:.*%s %s" % (self.myclass, self.mymethod)])
self.expect('expression member', startstr="(int) $0 = 5")
self.expect('expression self', startstr="(%s *) $1 = " % self.myclass)
self.expect('expression self->non_member',
error=True,
substrs=["does not have a member named 'non_member'"])
def expression_lookups_objc(self):
"""Test running an expression and make sure we don't search all dwarf files for any internal names (anything that contains '__lldb')."""
exe = os.path.join(os.getcwd(), "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Stop at -[MyString initWithNSString:].
lldbutil.run_break_set_by_symbol(self,
'-[MyString initWithNSString:]',
num_expected_locations=1,
sym_exact=True)
self.runCmd("run", RUN_SUCCEEDED)
# Log any DWARF lookups
logfile = os.path.join(
os.getcwd(), "dwarf-lookups-" + self.getArchitecture() + ".txt")
self.runCmd("log enable -f %s dwarf lookups" % (logfile))
self.runCmd("expr self")
self.runCmd("log disable dwarf lookups")
def cleanup():
os.unlink(logfile)
self.addTearDownHook(cleanup)
f = open(logfile)
lines = f.readlines()
num_errors = 0
for line in lines:
if string.find(line, "$__lldb") != -1:
if num_errors == 0:
print "error: found spurious name lookups when evaluating an expression:"
num_errors += 1
print line,
self.assertTrue(num_errors == 0, "Spurious lookups detected")
f.close()
def test(self):
"""Test breakpoint works correctly with dead-code stripping."""
self.build()
exe = os.path.join(os.getcwd(), "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Break by function name f1 (live code).
lldbutil.run_break_set_by_symbol(self,
"f1",
num_expected_locations=1,
module_name="a.out")
# Break by function name f2 (dead code).
lldbutil.run_break_set_by_symbol(self,
"f2",
num_expected_locations=0,
module_name="a.out")
# Break by function name f3 (live code).
lldbutil.run_break_set_by_symbol(self,
"f3",
num_expected_locations=1,
module_name="a.out")
self.runCmd("run", RUN_SUCCEEDED)
# The stop reason of the thread should be breakpoint (breakpoint #1).
self.expect(
"thread list",
STOPPED_DUE_TO_BREAKPOINT,
substrs=['stopped', 'a.out`f1', 'stop reason = breakpoint'])
# The breakpoint should have a hit count of 1.
self.expect("breakpoint list -f 1",
BREAKPOINT_HIT_ONCE,
substrs=[' resolved, hit count = 1'])
self.runCmd("continue")
# The stop reason of the thread should be breakpoint (breakpoint #3).
self.expect(
"thread list",
STOPPED_DUE_TO_BREAKPOINT,
substrs=['stopped', 'a.out`f3', 'stop reason = breakpoint'])
# The breakpoint should have a hit count of 1.
self.expect("breakpoint list -f 3",
BREAKPOINT_HIT_ONCE,
substrs=[' resolved, hit count = 1'])
def breakpoint_options_language_test(self):
"""Test breakpoint command for language option."""
exe = os.path.join(os.getcwd(), "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# This should create a breakpoint with 1 locations.
lldbutil.run_break_set_by_symbol(self,
'ns::func',
sym_exact=False,
extra_options="-L c++",
num_expected_locations=1)
# This should create a breakpoint with 0 locations.
lldbutil.run_break_set_by_symbol(self,
'ns::func',
sym_exact=False,
extra_options="-L c",
num_expected_locations=0)
self.runCmd("settings set target.language c")
lldbutil.run_break_set_by_symbol(self,
'ns::func',
sym_exact=False,
num_expected_locations=0)
# Run the program.
self.runCmd("run", RUN_SUCCEEDED)
# Stopped once.
self.expect("thread backtrace",
STOPPED_DUE_TO_BREAKPOINT,
substrs=["stop reason = breakpoint 1."])
# Continue the program, we should exit.
self.runCmd("process continue")
# We should exit.
self.expect("process status",
"Process exited successfully",
patterns=["^Process [0-9]+ exited with status = 0"])
def test(self):
"""Test breakpoint works correctly with dead-code stripping."""
self.build()
exe = os.path.join(os.getcwd(), "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Break by function name f1 (live code).
lldbutil.run_break_set_by_symbol (self, "f1", num_expected_locations=1, module_name="a.out")
# Break by function name f2 (dead code).
lldbutil.run_break_set_by_symbol (self, "f2", num_expected_locations=0, module_name="a.out")
# Break by function name f3 (live code).
lldbutil.run_break_set_by_symbol (self, "f3", num_expected_locations=1, module_name="a.out")
self.runCmd("run", RUN_SUCCEEDED)
# The stop reason of the thread should be breakpoint (breakpoint #1).
self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
substrs = ['stopped',
'a.out`f1',
'stop reason = breakpoint'])
# The breakpoint should have a hit count of 1.
self.expect("breakpoint list -f 1", BREAKPOINT_HIT_ONCE,
substrs = [' resolved, hit count = 1'])
self.runCmd("continue")
# The stop reason of the thread should be breakpoint (breakpoint #3).
self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
substrs = ['stopped',
'a.out`f3',
'stop reason = breakpoint'])
# The breakpoint should have a hit count of 1.
self.expect("breakpoint list -f 3", BREAKPOINT_HIT_ONCE,
substrs = [' resolved, hit count = 1'])
def data_type_and_expr_objc(self):
"""Lookup objective-c data types and evaluate expressions."""
exe = os.path.join(os.getcwd(), "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Stop at -[MyString description].
lldbutil.run_break_set_by_symbol(self, "-[MyString description]", num_expected_locations=1, sym_exact=True)
# self.expect("breakpoint set -n '-[MyString description]", BREAKPOINT_CREATED,
# startstr = "Breakpoint created: 1: name = '-[MyString description]', locations = 1")
self.runCmd("run", RUN_SUCCEEDED)
# The backtrace should show we stop at -[MyString description].
self.expect("thread backtrace", "Stop at -[MyString description]", substrs=["a.out`-[MyString description]"])
# Lookup objc data type MyString and evaluate some expressions.
self.expect(
"image lookup -t NSString",
DATA_TYPES_DISPLAYED_CORRECTLY,
substrs=['name = "NSString"', 'clang_type = "@interface NSString'],
)
self.expect(
"image lookup -t MyString",
DATA_TYPES_DISPLAYED_CORRECTLY,
substrs=['name = "MyString"', 'clang_type = "@interface MyString', "NSString * str;", "NSDate * date;"],
)
self.expect(
"frame variable --show-types --scope",
VARIABLES_DISPLAYED_CORRECTLY,
substrs=["ARG: (MyString *) self"],
patterns=["ARG: \(.*\) _cmd", "(objc_selector *)|(SEL)"],
)
# rdar://problem/8651752
# don't crash trying to ask clang how many children an empty record has
self.runCmd("frame variable *_cmd")
# rdar://problem/8492646
# test/foundation fails after updating to tot r115023
# self->str displays nothing as output
self.expect(
"frame variable --show-types self->str", VARIABLES_DISPLAYED_CORRECTLY, startstr="(NSString *) self->str"
)
# rdar://problem/8447030
# 'frame variable self->date' displays the wrong data member
self.expect(
"frame variable --show-types self->date", VARIABLES_DISPLAYED_CORRECTLY, startstr="(NSDate *) self->date"
)
# This should display the str and date member fields as well.
self.expect(
"frame variable --show-types *self",
VARIABLES_DISPLAYED_CORRECTLY,
substrs=["(MyString) *self", "(NSString *) str", "(NSDate *) date"],
)
# isa should be accessible.
self.expect("expression self->isa", VARIABLES_DISPLAYED_CORRECTLY, substrs=["(Class)"])
# This should fail expectedly.
self.expect(
"expression self->non_existent_member",
COMMAND_FAILED_AS_EXPECTED,
error=True,
startstr="error: 'MyString' does not have a member named 'non_existent_member'",
)
# Use expression parser.
self.runCmd("expression self->str")
self.runCmd("expression self->date")
# (lldb) expression self->str
# error: instance variable 'str' is protected
# error: 1 errors parsing expression
#
# (lldb) expression self->date
# error: instance variable 'date' is protected
# error: 1 errors parsing expression
#
self.runCmd("breakpoint delete 1")
lldbutil.run_break_set_by_file_and_line(self, "main.m", self.line, num_expected_locations=1, loc_exact=True)
self.runCmd("process continue")
# rdar://problem/8542091
# test/foundation: expr -o -- my not working?
#
# Test new feature with r115115:
# Add "-o" option to "expression" which prints the object description if available.
self.expect(
"expression --object-description -- my",
"Object description displayed correctly",
patterns=["Hello from.*a.out.*with timestamp: "],
)
def test_data_type_and_expr(self):
"""Lookup objective-c data types and evaluate expressions."""
self.build()
exe = os.path.join(os.getcwd(), "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Stop at -[MyString description].
lldbutil.run_break_set_by_symbol(self,
'-[MyString description]',
num_expected_locations=1,
sym_exact=True)
# self.expect("breakpoint set -n '-[MyString description]", BREAKPOINT_CREATED,
# startstr = "Breakpoint created: 1: name = '-[MyString description]', locations = 1")
self.runCmd("run", RUN_SUCCEEDED)
# The backtrace should show we stop at -[MyString description].
self.expect("thread backtrace",
"Stop at -[MyString description]",
substrs=["a.out`-[MyString description]"])
# Lookup objc data type MyString and evaluate some expressions.
self.expect("image lookup -t NSString",
DATA_TYPES_DISPLAYED_CORRECTLY,
substrs=[
'name = "NSString"',
'compiler_type = "@interface NSString'
])
self.expect("image lookup -t MyString",
DATA_TYPES_DISPLAYED_CORRECTLY,
substrs=[
'name = "MyString"',
'compiler_type = "@interface MyString',
'NSString * str;', 'NSDate * date;'
])
self.expect("frame variable --show-types --scope",
VARIABLES_DISPLAYED_CORRECTLY,
substrs=["ARG: (MyString *) self"],
patterns=["ARG: \(.*\) _cmd", "(objc_selector *)|(SEL)"])
# rdar://problem/8651752
# don't crash trying to ask clang how many children an empty record has
self.runCmd("frame variable *_cmd")
# rdar://problem/8492646
# test/foundation fails after updating to tot r115023
# self->str displays nothing as output
self.expect("frame variable --show-types self->str",
VARIABLES_DISPLAYED_CORRECTLY,
startstr="(NSString *) self->str")
# rdar://problem/8447030
# 'frame variable self->date' displays the wrong data member
self.expect("frame variable --show-types self->date",
VARIABLES_DISPLAYED_CORRECTLY,
startstr="(NSDate *) self->date")
# This should display the str and date member fields as well.
self.expect("frame variable --show-types *self",
VARIABLES_DISPLAYED_CORRECTLY,
substrs=[
"(MyString) *self", "(NSString *) str",
"(NSDate *) date"
])
# isa should be accessible.
self.expect("expression self->isa",
VARIABLES_DISPLAYED_CORRECTLY,
substrs=["(Class)"])
# This should fail expectedly.
self.expect(
"expression self->non_existent_member",
COMMAND_FAILED_AS_EXPECTED,
error=True,
startstr=
"error: 'MyString' does not have a member named 'non_existent_member'"
)
# Use expression parser.
self.runCmd("expression self->str")
self.runCmd("expression self->date")
# (lldb) expression self->str
# error: instance variable 'str' is protected
# error: 1 errors parsing expression
#
# (lldb) expression self->date
# error: instance variable 'date' is protected
# error: 1 errors parsing expression
#
self.runCmd("breakpoint delete 1")
lldbutil.run_break_set_by_file_and_line(self,
"main.m",
self.line,
num_expected_locations=1,
loc_exact=True)
self.runCmd("process continue")
# rdar://problem/8542091
# test/foundation: expr -o -- my not working?
#
# Test new feature with r115115:
# Add "-o" option to "expression" which prints the object description if available.
self.expect("expression --object-description -- my",
"Object description displayed correctly",
patterns=["Hello from.*a.out.*with timestamp: "])
def do_simple_disasm(self):
"""Do a bunch of simple disassemble commands."""
# Create a target by the debugger.
target = self.dbg.CreateTarget("a.out")
self.assertTrue(target, VALID_TARGET)
print target
for module in target.modules:
print module
# Stop at +[NSString stringWithFormat:].
symbol_name = "+[NSString stringWithFormat:]"
break_results = lldbutil.run_break_set_command (self, "_regexp-break %s"%(symbol_name))
lldbutil.check_breakpoint_result (self, break_results, symbol_name=symbol_name, num_locations=1)
# Stop at -[MyString initWithNSString:].
lldbutil.run_break_set_by_symbol (self, '-[MyString initWithNSString:]', num_expected_locations=1, sym_exact=True)
# Stop at the "description" selector.
lldbutil.run_break_set_by_selector (self, 'description', num_expected_locations=1, module_name='a.out')
# Stop at -[NSAutoreleasePool release].
break_results = lldbutil.run_break_set_command (self, "_regexp-break -[NSAutoreleasePool release]")
lldbutil.check_breakpoint_result (self, break_results, symbol_name='-[NSAutoreleasePool release]', num_locations=1)
self.runCmd("run", RUN_SUCCEEDED)
# First stop is +[NSString stringWithFormat:].
self.expect("thread backtrace", "Stop at +[NSString stringWithFormat:]",
substrs = ["Foundation`+[NSString stringWithFormat:]"])
# Do the disassemble for the currently stopped function.
self.runCmd("disassemble -f")
self.runCmd("process continue")
# Skip another breakpoint for +[NSString stringWithFormat:].
self.runCmd("process continue")
# Followed by a.out`-[MyString initWithNSString:].
self.expect("thread backtrace", "Stop at a.out`-[MyString initWithNSString:]",
substrs = ["a.out`-[MyString initWithNSString:]"])
# Do the disassemble for the currently stopped function.
self.runCmd("disassemble -f")
self.runCmd("process continue")
# Followed by -[MyString description].
self.expect("thread backtrace", "Stop at -[MyString description]",
substrs = ["a.out`-[MyString description]"])
# Do the disassemble for the currently stopped function.
self.runCmd("disassemble -f")
self.runCmd("process continue")
# Skip another breakpoint for -[MyString description].
self.runCmd("process continue")
# Followed by -[NSAutoreleasePool release].
self.expect("thread backtrace", "Stop at -[NSAutoreleasePool release]",
substrs = ["Foundation`-[NSAutoreleasePool release]"])
# Do the disassemble for the currently stopped function.
self.runCmd("disassemble -f")
def do_simple_disasm(self):
"""Do a bunch of simple disassemble commands."""
exe = os.path.join(os.getcwd(), "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Stop at +[NSString stringWithFormat:].
symbol_name = "+[NSString stringWithFormat:]"
break_results = lldbutil.run_break_set_command(
self, "_regexp-break %s" % (symbol_name))
lldbutil.check_breakpoint_result(self,
break_results,
symbol_name=symbol_name,
num_locations=1)
# Stop at -[MyString initWithNSString:].
lldbutil.run_break_set_by_symbol(self,
'-[MyString initWithNSString:]',
num_expected_locations=1,
sym_exact=True)
# Stop at the "description" selector.
lldbutil.run_break_set_by_selector(self,
'description',
num_expected_locations=1,
module_name='a.out')
# Stop at -[NSAutoreleasePool release].
break_results = lldbutil.run_break_set_command(
self, "_regexp-break -[NSAutoreleasePool release]")
lldbutil.check_breakpoint_result(
self,
break_results,
symbol_name='-[NSAutoreleasePool release]',
num_locations=1)
self.runCmd("run", RUN_SUCCEEDED)
# First stop is +[NSString stringWithFormat:].
self.expect("thread backtrace",
"Stop at +[NSString stringWithFormat:]",
substrs=["Foundation`+[NSString stringWithFormat:]"])
# Do the disassemble for the currently stopped function.
self.runCmd("disassemble -f")
self.runCmd("process continue")
# Skip another breakpoint for +[NSString stringWithFormat:].
self.runCmd("process continue")
# Followed by a.out`-[MyString initWithNSString:].
self.expect("thread backtrace",
"Stop at a.out`-[MyString initWithNSString:]",
substrs=["a.out`-[MyString initWithNSString:]"])
# Do the disassemble for the currently stopped function.
self.runCmd("disassemble -f")
self.runCmd("process continue")
# Followed by -[MyString description].
self.expect("thread backtrace",
"Stop at -[MyString description]",
substrs=["a.out`-[MyString description]"])
# Do the disassemble for the currently stopped function.
self.runCmd("disassemble -f")
self.runCmd("process continue")
# Skip another breakpoint for -[MyString description].
self.runCmd("process continue")
# Followed by -[NSAutoreleasePool release].
self.expect("thread backtrace",
"Stop at -[NSAutoreleasePool release]",
substrs=["Foundation`-[NSAutoreleasePool release]"])
# Do the disassemble for the currently stopped function.
self.runCmd("disassemble -f")
def test_simple_disasm(self):
"""Test the lldb 'disassemble' command"""
self.build()
# Create a target by the debugger.
target = self.dbg.CreateTarget("a.out")
self.assertTrue(target, VALID_TARGET)
print target
for module in target.modules:
print module
# Stop at +[NSString stringWithFormat:].
symbol_name = "+[NSString stringWithFormat:]"
break_results = lldbutil.run_break_set_command (self, "_regexp-break %s"%(symbol_name))
lldbutil.check_breakpoint_result (self, break_results, symbol_name=symbol_name, num_locations=1)
# Stop at -[MyString initWithNSString:].
lldbutil.run_break_set_by_symbol (self, '-[MyString initWithNSString:]', num_expected_locations=1, sym_exact=True)
# Stop at the "description" selector.
lldbutil.run_break_set_by_selector (self, 'description', num_expected_locations=1, module_name='a.out')
# Stop at -[NSAutoreleasePool release].
break_results = lldbutil.run_break_set_command (self, "_regexp-break -[NSAutoreleasePool release]")
lldbutil.check_breakpoint_result (self, break_results, symbol_name='-[NSAutoreleasePool release]', num_locations=1)
self.runCmd("run", RUN_SUCCEEDED)
# First stop is +[NSString stringWithFormat:].
self.expect("thread backtrace", "Stop at +[NSString stringWithFormat:]",
substrs = ["Foundation`+[NSString stringWithFormat:]"])
# Do the disassemble for the currently stopped function.
self.runCmd("disassemble -f")
self.runCmd("process continue")
# Skip another breakpoint for +[NSString stringWithFormat:].
self.runCmd("process continue")
# Followed by a.out`-[MyString initWithNSString:].
self.expect("thread backtrace", "Stop at a.out`-[MyString initWithNSString:]",
substrs = ["a.out`-[MyString initWithNSString:]"])
# Do the disassemble for the currently stopped function.
self.runCmd("disassemble -f")
self.runCmd("process continue")
# Followed by -[MyString description].
self.expect("thread backtrace", "Stop at -[MyString description]",
substrs = ["a.out`-[MyString description]"])
# Do the disassemble for the currently stopped function.
self.runCmd("disassemble -f")
self.runCmd("process continue")
# Skip another breakpoint for -[MyString description].
self.runCmd("process continue")
# Followed by -[NSAutoreleasePool release].
self.expect("thread backtrace", "Stop at -[NSAutoreleasePool release]",
substrs = ["Foundation`-[NSAutoreleasePool release]"])
# Do the disassemble for the currently stopped function.
self.runCmd("disassemble -f")
def signal_test(self, signal, test_passing):
"""Test that we handle inferior raising signals"""
exe = os.path.join(os.getcwd(), "a.out")
# Create a target by the debugger.
target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET)
lldbutil.run_break_set_by_symbol(self, "main")
# launch
process = self.launch(target, signal)
signo = process.GetUnixSignals().GetSignalNumberFromName(signal)
# retrieve default signal disposition
return_obj = lldb.SBCommandReturnObject()
self.dbg.GetCommandInterpreter().HandleCommand(
"process handle %s " % signal, return_obj)
match = re.match(
'NAME *PASS *STOP *NOTIFY.*(false|true) *(false|true) *(false|true)',
return_obj.GetOutput(), re.IGNORECASE | re.DOTALL)
if not match:
self.fail('Unable to retrieve default signal disposition.')
default_pass = match.group(1)
default_stop = match.group(2)
default_notify = match.group(3)
# Make sure we stop at the signal
self.set_handle(signal, "false", "true", "true")
process.Continue()
self.assertEqual(process.GetState(), lldb.eStateStopped)
thread = lldbutil.get_stopped_thread(process, lldb.eStopReasonSignal)
self.assertTrue(thread.IsValid(),
"Thread should be stopped due to a signal")
self.assertTrue(thread.GetStopReasonDataCount() >= 1,
"There was data in the event.")
self.assertEqual(thread.GetStopReasonDataAtIndex(0), signo,
"The stop signal was %s" % signal)
# Continue until we exit.
process.Continue()
self.assertEqual(process.GetState(), lldb.eStateExited)
self.assertEqual(process.GetExitStatus(), 0)
# launch again
process = self.launch(target, signal)
# Make sure we do not stop at the signal. We should still get the notification.
self.set_handle(signal, "false", "false", "true")
self.expect("process continue",
substrs=["stopped and restarted", signal])
self.assertEqual(process.GetState(), lldb.eStateExited)
self.assertEqual(process.GetExitStatus(), 0)
# launch again
process = self.launch(target, signal)
# Make sure we do not stop at the signal, and we do not get the notification.
self.set_handle(signal, "false", "false", "false")
self.expect("process continue",
substrs=["stopped and restarted"],
matching=False)
self.assertEqual(process.GetState(), lldb.eStateExited)
self.assertEqual(process.GetExitStatus(), 0)
if not test_passing:
# reset signal handling to default
self.set_handle(signal, default_pass, default_stop, default_notify)
return
# launch again
process = self.launch(target, signal)
# Make sure we stop at the signal
self.set_handle(signal, "true", "true", "true")
process.Continue()
self.assertEqual(process.GetState(), lldb.eStateStopped)
thread = lldbutil.get_stopped_thread(process, lldb.eStopReasonSignal)
self.assertTrue(thread.IsValid(),
"Thread should be stopped due to a signal")
self.assertTrue(thread.GetStopReasonDataCount() >= 1,
"There was data in the event.")
self.assertEqual(
thread.GetStopReasonDataAtIndex(0),
process.GetUnixSignals().GetSignalNumberFromName(signal),
"The stop signal was %s" % signal)
# Continue until we exit. The process should receive the signal.
process.Continue()
self.assertEqual(process.GetState(), lldb.eStateExited)
self.assertEqual(process.GetExitStatus(), signo)
# launch again
process = self.launch(target, signal)
# Make sure we do not stop at the signal. We should still get the notification. Process
# should receive the signal.
self.set_handle(signal, "true", "false", "true")
self.expect("process continue",
substrs=["stopped and restarted", signal])
self.assertEqual(process.GetState(), lldb.eStateExited)
self.assertEqual(process.GetExitStatus(), signo)
# launch again
process = self.launch(target, signal)
# Make sure we do not stop at the signal, and we do not get the notification. Process
# should receive the signal.
self.set_handle(signal, "true", "false", "false")
self.expect("process continue",
substrs=["stopped and restarted"],
matching=False)
self.assertEqual(process.GetState(), lldb.eStateExited)
self.assertEqual(process.GetExitStatus(), signo)
# reset signal handling to default
self.set_handle(signal, default_pass, default_stop, default_notify)
def step_over_watchpoint(self):
"""Test stepping over watchpoints."""
exe = os.path.join(os.getcwd(), 'a.out')
target = self.dbg.CreateTarget(exe)
self.assertTrue(self.target, VALID_TARGET)
lldbutil.run_break_set_by_symbol(self, 'main')
process = target.LaunchSimple(None, None,
self.get_process_working_directory())
self.assertTrue(process.IsValid(), PROCESS_IS_VALID)
self.assertTrue(process.GetState() == lldb.eStateStopped,
PROCESS_STOPPED)
thread = lldbutil.get_stopped_thread(process,
lldb.eStopReasonBreakpoint)
self.assertTrue(thread.IsValid(), "Failed to get thread.")
frame = thread.GetFrameAtIndex(0)
self.assertTrue(frame.IsValid(), "Failed to get frame.")
read_value = frame.FindValue('g_watch_me_read',
lldb.eValueTypeVariableGlobal)
self.assertTrue(read_value.IsValid(), "Failed to find read value.")
error = lldb.SBError()
# resolve_location=True, read=True, write=False
read_watchpoint = read_value.Watch(True, True, False, error)
self.assertTrue(error.Success(),
"Error while setting watchpoint: %s" %
error.GetCString())
self.assertTrue(read_watchpoint, "Failed to set read watchpoint.")
write_value = frame.FindValue('g_watch_me_write',
lldb.eValueTypeVariableGlobal)
self.assertTrue(write_value, "Failed to find write value.")
# resolve_location=True, read=False, write=True
write_watchpoint = write_value.Watch(True, False, True, error)
self.assertTrue(read_watchpoint, "Failed to set write watchpoint.")
self.assertTrue(error.Success(),
"Error while setting watchpoint: %s" %
error.GetCString())
thread.StepOver()
self.assertTrue(thread.GetStopReason() == lldb.eStopReasonWatchpoint,
STOPPED_DUE_TO_WATCHPOINT)
self.assertTrue(thread.GetStopDescription(20) == 'watchpoint 1')
process.Continue()
self.assertTrue(process.GetState() == lldb.eStateStopped,
PROCESS_STOPPED)
self.assertTrue(thread.GetStopDescription(20) == 'step over')
self.step_inst_for_watchpoint(1)
thread.StepOver()
self.assertTrue(thread.GetStopReason() == lldb.eStopReasonWatchpoint,
STOPPED_DUE_TO_WATCHPOINT)
self.assertTrue(thread.GetStopDescription(20) == 'watchpoint 2')
process.Continue()
self.assertTrue(process.GetState() == lldb.eStateStopped,
PROCESS_STOPPED)
self.assertTrue(thread.GetStopDescription(20) == 'step over')
self.step_inst_for_watchpoint(2)
def sigtramp_unwind_tests(self):
exe = os.path.join(os.getcwd(), "a.out")
target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET)
lldbutil.run_break_set_by_file_and_line(self,
"main.c",
line_number(
'main.c',
'// Set breakpoint here'),
num_expected_locations=1)
process = target.LaunchSimple(None, None,
self.get_process_working_directory())
if not process:
self.fail("SBTarget.Launch() failed")
if process.GetState() != lldb.eStateStopped:
self.fail("Process should be in the 'stopped' state, "
"instead the actual state is: '%s'" %
lldbutil.state_type_to_str(process.GetState()))
self.expect("pro handle -n false -p true -s false SIGUSR1",
"Have lldb pass SIGUSR1 signals",
substrs=["SIGUSR1", "true", "false", "false"])
lldbutil.run_break_set_by_symbol(self,
"handler",
num_expected_locations=1,
module_name="a.out")
self.runCmd("continue")
thread = process.GetThreadAtIndex(0)
found_handler = False
found_sigtramp = False
found_kill = False
found_main = False
for f in thread.frames:
if f.GetFunctionName() == "handler":
found_handler = True
if f.GetFunctionName() == "_sigtramp":
found_sigtramp = True
if f.GetFunctionName() == "__kill":
found_kill = True
if f.GetFunctionName() == "main":
found_main = True
if self.TraceOn():
print "Backtrace once we're stopped:"
for f in thread.frames:
print " %d %s" % (f.GetFrameID(), f.GetFunctionName())
if found_handler == False:
self.fail("Unable to find handler() in backtrace.")
if found_sigtramp == False:
self.fail("Unable to find _sigtramp() in backtrace.")
if found_kill == False:
self.fail("Unable to find kill() in backtrace.")
if found_main == False:
self.fail("Unable to find main() in backtrace.")
def signal_test(self, signal, test_passing):
"""Test that we handle inferior raising signals"""
exe = os.path.join(os.getcwd(), "a.out")
# Create a target by the debugger.
target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET)
lldbutil.run_break_set_by_symbol(self, "main")
# launch
process = self.launch(target, signal)
signo = process.GetUnixSignals().GetSignalNumberFromName(signal)
# retrieve default signal disposition
return_obj = lldb.SBCommandReturnObject()
self.dbg.GetCommandInterpreter().HandleCommand("process handle %s " % signal, return_obj)
match = re.match('NAME *PASS *STOP *NOTIFY.*(false|true) *(false|true) *(false|true)',
return_obj.GetOutput(), re.IGNORECASE | re.DOTALL)
if not match:
self.fail('Unable to retrieve default signal disposition.')
default_pass = match.group(1)
default_stop = match.group(2)
default_notify = match.group(3)
# Make sure we stop at the signal
self.set_handle(signal, "false", "true", "true")
process.Continue()
self.assertEqual(process.GetState(), lldb.eStateStopped)
thread = lldbutil.get_stopped_thread(process, lldb.eStopReasonSignal)
self.assertTrue(thread.IsValid(), "Thread should be stopped due to a signal")
self.assertTrue(thread.GetStopReasonDataCount() >= 1, "There was data in the event.")
self.assertEqual(thread.GetStopReasonDataAtIndex(0), signo,
"The stop signal was %s" % signal)
# Continue until we exit.
process.Continue()
self.assertEqual(process.GetState(), lldb.eStateExited)
self.assertEqual(process.GetExitStatus(), 0)
# launch again
process = self.launch(target, signal)
# Make sure we do not stop at the signal. We should still get the notification.
self.set_handle(signal, "false", "false", "true")
self.expect("process continue", substrs=["stopped and restarted", signal])
self.assertEqual(process.GetState(), lldb.eStateExited)
self.assertEqual(process.GetExitStatus(), 0)
# launch again
process = self.launch(target, signal)
# Make sure we do not stop at the signal, and we do not get the notification.
self.set_handle(signal, "false", "false", "false")
self.expect("process continue", substrs=["stopped and restarted"], matching=False)
self.assertEqual(process.GetState(), lldb.eStateExited)
self.assertEqual(process.GetExitStatus(), 0)
if not test_passing:
# reset signal handling to default
self.set_handle(signal, default_pass, default_stop, default_notify)
return
# launch again
process = self.launch(target, signal)
# Make sure we stop at the signal
self.set_handle(signal, "true", "true", "true")
process.Continue()
self.assertEqual(process.GetState(), lldb.eStateStopped)
thread = lldbutil.get_stopped_thread(process, lldb.eStopReasonSignal)
self.assertTrue(thread.IsValid(), "Thread should be stopped due to a signal")
self.assertTrue(thread.GetStopReasonDataCount() >= 1, "There was data in the event.")
self.assertEqual(thread.GetStopReasonDataAtIndex(0),
process.GetUnixSignals().GetSignalNumberFromName(signal),
"The stop signal was %s" % signal)
# Continue until we exit. The process should receive the signal.
process.Continue()
self.assertEqual(process.GetState(), lldb.eStateExited)
self.assertEqual(process.GetExitStatus(), signo)
# launch again
process = self.launch(target, signal)
# Make sure we do not stop at the signal. We should still get the notification. Process
# should receive the signal.
self.set_handle(signal, "true", "false", "true")
self.expect("process continue", substrs=["stopped and restarted", signal])
self.assertEqual(process.GetState(), lldb.eStateExited)
self.assertEqual(process.GetExitStatus(), signo)
# launch again
process = self.launch(target, signal)
# Make sure we do not stop at the signal, and we do not get the notification. Process
# should receive the signal.
self.set_handle(signal, "true", "false", "false")
self.expect("process continue", substrs=["stopped and restarted"], matching=False)
self.assertEqual(process.GetState(), lldb.eStateExited)
self.assertEqual(process.GetExitStatus(), signo)
# reset signal handling to default
self.set_handle(signal, default_pass, default_stop, default_notify)
def breakpoint_conditions(self, inline=False):
"""Exercise breakpoint condition with 'breakpoint modify -c <expr> id'."""
exe = os.path.join(os.getcwd(), "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
if inline:
# Create a breakpoint by function name 'c' and set the condition.
lldbutil.run_break_set_by_symbol(self,
"c",
extra_options="-c 'val == 3'",
num_expected_locations=1,
sym_exact=True)
else:
# Create a breakpoint by function name 'c'.
lldbutil.run_break_set_by_symbol(self,
"c",
num_expected_locations=1,
sym_exact=True)
# And set a condition on the breakpoint to stop on when 'val == 3'.
self.runCmd("breakpoint modify -c 'val == 3' 1")
# Now run the program.
self.runCmd("run", RUN_SUCCEEDED)
# The process should be stopped at this point.
self.expect("process status",
PROCESS_STOPPED,
patterns=['Process .* stopped'])
# 'frame variable --show-types val' should return 3 due to breakpoint condition.
self.expect("frame variable --show-types val",
VARIABLES_DISPLAYED_CORRECTLY,
startstr='(int) val = 3')
# Also check the hit count, which should be 3, by design.
self.expect(
"breakpoint list -f",
BREAKPOINT_HIT_THRICE,
substrs=["resolved = 1", "Condition: val == 3", "hit count = 3"])
# The frame #0 should correspond to main.c:36, the executable statement
# in function name 'c'. And the parent frame should point to main.c:24.
self.expect(
"thread backtrace",
STOPPED_DUE_TO_BREAKPOINT_CONDITION,
#substrs = ["stop reason = breakpoint"],
patterns=[
"frame #0.*main.c:%d" % self.line1,
"frame #1.*main.c:%d" % self.line2
])
# Test that "breakpoint modify -c ''" clears the condition for the last
# created breakpoint, so that when the breakpoint hits, val == 1.
self.runCmd("process kill")
self.runCmd("breakpoint modify -c ''")
self.expect("breakpoint list -f",
BREAKPOINT_STATE_CORRECT,
matching=False,
substrs=["Condition:"])
# Now run the program again.
self.runCmd("run", RUN_SUCCEEDED)
# The process should be stopped at this point.
self.expect("process status",
PROCESS_STOPPED,
patterns=['Process .* stopped'])
# 'frame variable --show-types val' should return 1 since it is the first breakpoint hit.
self.expect("frame variable --show-types val",
VARIABLES_DISPLAYED_CORRECTLY,
startstr='(int) val = 1')
self.runCmd("process kill")
self.runCmd("breakpoint disable")
self.runCmd("breakpoint set -p Loop")
self.runCmd("breakpoint modify -c ($eax&&i)")
self.runCmd("run")
self.expect("process status",
PROCESS_STOPPED,
patterns=['Process .* stopped'])
self.runCmd("continue")
self.expect("process status",
PROCESS_EXITED,
patterns=['Process .* exited'])
