diff options
Diffstat (limited to 'packages/Python/lldbsuite/test/functionalities/inferior-assert')
3 files changed, 277 insertions, 0 deletions
diff --git a/packages/Python/lldbsuite/test/functionalities/inferior-assert/Makefile b/packages/Python/lldbsuite/test/functionalities/inferior-assert/Makefile new file mode 100644 index 000000000000..0d70f2595019 --- /dev/null +++ b/packages/Python/lldbsuite/test/functionalities/inferior-assert/Makefile @@ -0,0 +1,5 @@ +LEVEL = ../../make + +C_SOURCES := main.c + +include $(LEVEL)/Makefile.rules diff --git a/packages/Python/lldbsuite/test/functionalities/inferior-assert/TestInferiorAssert.py b/packages/Python/lldbsuite/test/functionalities/inferior-assert/TestInferiorAssert.py new file mode 100644 index 000000000000..69e977e6343f --- /dev/null +++ b/packages/Python/lldbsuite/test/functionalities/inferior-assert/TestInferiorAssert.py @@ -0,0 +1,253 @@ +"""Test that lldb functions correctly after the inferior has asserted.""" + +from __future__ import print_function + + + +import os, time +import lldb +import lldbsuite.test.lldbutil as lldbutil +import lldbsuite.test.lldbplatformutil as lldbplatformutil +from lldbsuite.test.lldbtest import * + +class AssertingInferiorTestCase(TestBase): + + mydir = TestBase.compute_mydir(__file__) + + @expectedFailureWindows("llvm.org/pr21793: need to implement support for detecting assertion / abort on Windows") + @expectedFailurei386("llvm.org/pr25338") + def test_inferior_asserting(self): + """Test that lldb reliably catches the inferior asserting (command).""" + self.build() + self.inferior_asserting() + + @expectedFailureWindows("llvm.org/pr21793: need to implement support for detecting assertion / abort on Windows") + @expectedFailureAndroid(api_levels=list(range(16 + 1))) # b.android.com/179836 + def test_inferior_asserting_register(self): + """Test that lldb reliably reads registers from the inferior after asserting (command).""" + self.build() + self.inferior_asserting_registers() + + @expectedFailureWindows("llvm.org/pr21793: need to implement support for detecting assertion / abort on Windows") + @expectedFailurei386("llvm.org/pr25338") + def test_inferior_asserting_disassemble(self): + """Test that lldb reliably disassembles frames after asserting (command).""" + self.build() + self.inferior_asserting_disassemble() + + @add_test_categories(['pyapi']) + @expectedFailureWindows("llvm.org/pr21793: need to implement support for detecting assertion / abort on Windows") + def test_inferior_asserting_python(self): + """Test that lldb reliably catches the inferior asserting (Python API).""" + self.build() + self.inferior_asserting_python() + + @expectedFailureWindows("llvm.org/pr21793: need to implement support for detecting assertion / abort on Windows") + @expectedFailurei386("llvm.org/pr25338") + def test_inferior_asserting_expr(self): + """Test that the lldb expression interpreter can read from the inferior after asserting (command).""" + self.build() + self.inferior_asserting_expr() + + @expectedFailureWindows("llvm.org/pr21793: need to implement support for detecting assertion / abort on Windows") + @expectedFailurei386("llvm.org/pr25338") + def test_inferior_asserting_step(self): + """Test that lldb functions correctly after stepping through a call to assert().""" + self.build() + self.inferior_asserting_step() + + def set_breakpoint(self, line): + lldbutil.run_break_set_by_file_and_line (self, "main.c", line, num_expected_locations=1, loc_exact=True) + + def check_stop_reason(self): + if matchAndroid(api_levels=list(range(1, 16+1)))(self): + # On android until API-16 the abort() call ended in a sigsegv instead of in a sigabrt + stop_reason = 'stop reason = signal SIGSEGV' + else: + stop_reason = 'stop reason = signal SIGABRT' + + # The stop reason of the thread should be an abort signal or exception. + self.expect("thread list", STOPPED_DUE_TO_ASSERT, + substrs = ['stopped', + stop_reason]) + + return stop_reason + + def setUp(self): + # Call super's setUp(). + TestBase.setUp(self) + # Find the line number of the call to assert. + self.line = line_number('main.c', '// Assert here.') + + def inferior_asserting(self): + """Inferior asserts upon launching; lldb should catch the event and stop.""" + exe = os.path.join(os.getcwd(), "a.out") + self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) + + self.runCmd("run", RUN_SUCCEEDED) + stop_reason = self.check_stop_reason() + + # And it should report a backtrace that includes the assert site. + self.expect("thread backtrace all", + substrs = [stop_reason, 'main', 'argc', 'argv']) + + # And it should report the correct line number. + self.expect("thread backtrace all", + substrs = [stop_reason, + 'main.c:%d' % self.line]) + + def inferior_asserting_python(self): + """Inferior asserts upon launching; lldb should catch the event and stop.""" + exe = os.path.join(os.getcwd(), "a.out") + + target = self.dbg.CreateTarget(exe) + self.assertTrue(target, VALID_TARGET) + + # Now launch the process, and do not stop at entry point. + # Both argv and envp are null. + process = target.LaunchSimple (None, None, self.get_process_working_directory()) + + 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())) + + thread = lldbutil.get_stopped_thread(process, lldb.eStopReasonSignal) + if not thread: + self.fail("Fail to stop the thread upon assert") + + if self.TraceOn(): + lldbutil.print_stacktrace(thread) + + def inferior_asserting_registers(self): + """Test that lldb can read registers after asserting.""" + exe = os.path.join(os.getcwd(), "a.out") + self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) + + self.runCmd("run", RUN_SUCCEEDED) + self.check_stop_reason() + + # lldb should be able to read from registers from the inferior after asserting. + lldbplatformutil.check_first_register_readable(self) + + def inferior_asserting_disassemble(self): + """Test that lldb can disassemble frames after asserting.""" + exe = os.path.join(os.getcwd(), "a.out") + + # Create a target by the debugger. + target = self.dbg.CreateTarget(exe) + self.assertTrue(target, VALID_TARGET) + + # Launch the process, and do not stop at the entry point. + target.LaunchSimple (None, None, self.get_process_working_directory()) + self.check_stop_reason() + + process = target.GetProcess() + self.assertTrue(process.IsValid(), "current process is valid") + + thread = process.GetThreadAtIndex(0) + self.assertTrue(thread.IsValid(), "current thread is valid") + + lastframeID = thread.GetFrameAtIndex(thread.GetNumFrames() - 1).GetFrameID() + + isi386Arch = False + if "i386" in self.getArchitecture(): + isi386Arch = True + + # lldb should be able to disassemble frames from the inferior after asserting. + for frame in thread: + self.assertTrue(frame.IsValid(), "current frame is valid") + + self.runCmd("frame select " + str(frame.GetFrameID()), RUN_SUCCEEDED) + + # Don't expect the function name to be in the disassembly as the assert + # function might be a no-return function where the PC is past the end + # of the function and in the next function. We also can't back the PC up + # because we don't know how much to back it up by on targets with opcodes + # that have differing sizes + pc_backup_offset = 1 + if frame.GetFrameID() == 0: + pc_backup_offset = 0 + if isi386Arch == True: + if lastframeID == frame.GetFrameID(): + pc_backup_offset = 0 + self.expect("disassemble -a %s" % (frame.GetPC() - pc_backup_offset), + substrs = ['<+0>: ']) + + def check_expr_in_main(self, thread): + depth = thread.GetNumFrames() + for i in range(depth): + frame = thread.GetFrameAtIndex(i) + self.assertTrue(frame.IsValid(), "current frame is valid") + if self.TraceOn(): + print("Checking if function %s is main" % frame.GetFunctionName()) + + if 'main' == frame.GetFunctionName(): + frame_id = frame.GetFrameID() + self.runCmd("frame select " + str(frame_id), RUN_SUCCEEDED) + self.expect("p argc", substrs = ['(int)', ' = 1']) + self.expect("p hello_world", substrs = ['Hello']) + self.expect("p argv[0]", substrs = ['a.out']) + self.expect("p null_ptr", substrs = ['= 0x0']) + return True + return False + + def inferior_asserting_expr(self): + """Test that the lldb expression interpreter can read symbols after asserting.""" + exe = os.path.join(os.getcwd(), "a.out") + + # Create a target by the debugger. + target = self.dbg.CreateTarget(exe) + self.assertTrue(target, VALID_TARGET) + + # Launch the process, and do not stop at the entry point. + target.LaunchSimple (None, None, self.get_process_working_directory()) + self.check_stop_reason() + + process = target.GetProcess() + self.assertTrue(process.IsValid(), "current process is valid") + + thread = process.GetThreadAtIndex(0) + self.assertTrue(thread.IsValid(), "current thread is valid") + + # The lldb expression interpreter should be able to read from addresses of the inferior after a call to assert(). + self.assertTrue(self.check_expr_in_main(thread), "cannot find 'main' in the backtrace") + + def inferior_asserting_step(self): + """Test that lldb functions correctly after stepping through a call to assert().""" + exe = os.path.join(os.getcwd(), "a.out") + + # Create a target by the debugger. + target = self.dbg.CreateTarget(exe) + self.assertTrue(target, VALID_TARGET) + + # Launch the process, and do not stop at the entry point. + self.set_breakpoint(self.line) + target.LaunchSimple (None, None, self.get_process_working_directory()) + + self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT, + substrs = ['main.c:%d' % self.line, + 'stop reason = breakpoint']) + + self.runCmd("next") + stop_reason = self.check_stop_reason() + + # lldb should be able to read from registers from the inferior after asserting. + if "x86_64" in self.getArchitecture(): + self.expect("register read rbp", substrs = ['rbp = 0x']) + if "i386" in self.getArchitecture(): + self.expect("register read ebp", substrs = ['ebp = 0x']) + + process = target.GetProcess() + self.assertTrue(process.IsValid(), "current process is valid") + + thread = process.GetThreadAtIndex(0) + self.assertTrue(thread.IsValid(), "current thread is valid") + + # The lldb expression interpreter should be able to read from addresses of the inferior after a call to assert(). + self.assertTrue(self.check_expr_in_main(thread), "cannot find 'main' in the backtrace") + + # And it should report the correct line number. + self.expect("thread backtrace all", + substrs = [stop_reason, + 'main.c:%d' % self.line]) diff --git a/packages/Python/lldbsuite/test/functionalities/inferior-assert/main.c b/packages/Python/lldbsuite/test/functionalities/inferior-assert/main.c new file mode 100644 index 000000000000..6aec4c1023a9 --- /dev/null +++ b/packages/Python/lldbsuite/test/functionalities/inferior-assert/main.c @@ -0,0 +1,19 @@ +//===-- main.c --------------------------------------------------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +#include <stdio.h> +#include <assert.h> + +const char *hello_world = "Hello, assertion!"; + +int main(int argc, const char* argv[]) +{ + int *null_ptr = 0; + printf("%s\n", hello_world); + assert(null_ptr); // Assert here. +} |