diff options
Diffstat (limited to 'packages/Python/lldbsuite/test/functionalities/stop-hook')
7 files changed, 385 insertions, 0 deletions
diff --git a/packages/Python/lldbsuite/test/functionalities/stop-hook/Makefile b/packages/Python/lldbsuite/test/functionalities/stop-hook/Makefile new file mode 100644 index 0000000..8a7102e --- /dev/null +++ b/packages/Python/lldbsuite/test/functionalities/stop-hook/Makefile @@ -0,0 +1,5 @@ +LEVEL = ../../make + +CXX_SOURCES := main.cpp + +include $(LEVEL)/Makefile.rules diff --git a/packages/Python/lldbsuite/test/functionalities/stop-hook/TestStopHookCmd.py b/packages/Python/lldbsuite/test/functionalities/stop-hook/TestStopHookCmd.py new file mode 100644 index 0000000..7534913 --- /dev/null +++ b/packages/Python/lldbsuite/test/functionalities/stop-hook/TestStopHookCmd.py @@ -0,0 +1,65 @@ +""" +Test lldb target stop-hook command. +""" + +from __future__ import print_function + + + +import os +import lldb +from lldbsuite.test.lldbtest import * +import lldbsuite.test.lldbutil as lldbutil + +class StopHookCmdTestCase(TestBase): + + mydir = TestBase.compute_mydir(__file__) + + def setUp(self): + # Call super's setUp(). + TestBase.setUp(self) + # Find the line numbers inside main.cpp. + self.begl = line_number('main.cpp', '// Set breakpoint here to test target stop-hook.') + self.endl = line_number('main.cpp', '// End of the line range for which stop-hook is to be run.') + self.line = line_number('main.cpp', '// Another breakpoint which is outside of the stop-hook range.') + + @no_debug_info_test + def test_not_crashing_if_no_target(self): + """target stop-hook list should not crash if no target has been set.""" + self.runCmd("target stop-hook list", check=False) + + def test(self): + """Test a sequence of target stop-hook commands.""" + self.build() + exe = os.path.join(os.getcwd(), "a.out") + self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) + + lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.begl, num_expected_locations=1, loc_exact=True) + + lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=1, loc_exact=True) + + self.runCmd("target stop-hook add -f main.cpp -l %d -e %d -o 'expr ptr'" % (self.begl, self.endl)) + + self.expect('target stop-hook list', 'Stop Hook added successfully', + substrs = ['State: enabled', + 'expr ptr']) + + self.runCmd('target stop-hook disable') + + self.expect('target stop-hook list', 'Stop Hook disabled successfully', + substrs = ['State: disabled', + 'expr ptr']) + + self.runCmd('target stop-hook enable') + + self.expect('target stop-hook list', 'Stop Hook enabled successfully', + substrs = ['State: enabled', + 'expr ptr']) + + self.runCmd("settings set auto-confirm true") + self.addTearDownHook(lambda: self.runCmd("settings clear auto-confirm")) + + self.runCmd('target stop-hook delete') + + self.expect('target stop-hook list', 'Stop Hook deleted successfully', + substrs = ['No stop hooks.']) diff --git a/packages/Python/lldbsuite/test/functionalities/stop-hook/TestStopHookMechanism.py b/packages/Python/lldbsuite/test/functionalities/stop-hook/TestStopHookMechanism.py new file mode 100644 index 0000000..7785d85 --- /dev/null +++ b/packages/Python/lldbsuite/test/functionalities/stop-hook/TestStopHookMechanism.py @@ -0,0 +1,101 @@ +""" +Test lldb target stop-hook mechanism to see whether it fires off correctly . +""" + +from __future__ import print_function + + + +import os +import lldb +from lldbsuite.test import configuration +from lldbsuite.test.lldbtest import * + +class StopHookMechanismTestCase(TestBase): + + mydir = TestBase.compute_mydir(__file__) + + def setUp(self): + # Call super's setUp(). + TestBase.setUp(self) + # Find the line numbers inside main.cpp. + self.begl = line_number('main.cpp', '// Set breakpoint here to test target stop-hook.') + self.endl = line_number('main.cpp', '// End of the line range for which stop-hook is to be run.') + self.correct_step_line = line_number ('main.cpp', '// We should stop here after stepping.') + self.line = line_number('main.cpp', '// Another breakpoint which is outside of the stop-hook range.') + + @skipIfFreeBSD # llvm.org/pr15037 + @expectedFlakeyLinux('llvm.org/pr15037') # stop-hooks sometimes fail to fire on Linux + @expectedFailureHostWindows("llvm.org/pr22274: need a pexpect replacement for windows") + def test(self): + """Test the stop-hook mechanism.""" + self.build() + + import pexpect + exe = os.path.join(os.getcwd(), "a.out") + prompt = "(lldb) " + add_prompt = "Enter your stop hook command(s). Type 'DONE' to end." + add_prompt1 = "> " + + # So that the child gets torn down after the test. + self.child = pexpect.spawn('%s %s' % (lldbtest_config.lldbExec, self.lldbOption)) + child = self.child + # Turn on logging for what the child sends back. + if self.TraceOn(): + child.logfile_read = sys.stdout + + if lldb.remote_platform: + child.expect_exact(prompt) + child.sendline('platform select %s' % lldb.remote_platform.GetName()) + child.expect_exact(prompt) + child.sendline('platform connect %s' % configuration.lldb_platform_url) + child.expect_exact(prompt) + child.sendline('platform settings -w %s' % configuration.lldb_platform_working_dir) + + child.expect_exact(prompt) + child.sendline('target create %s' % exe) + + # Set the breakpoint, followed by the target stop-hook commands. + child.expect_exact(prompt) + child.sendline('breakpoint set -f main.cpp -l %d' % self.begl) + child.expect_exact(prompt) + child.sendline('breakpoint set -f main.cpp -l %d' % self.line) + child.expect_exact(prompt) + child.sendline('target stop-hook add -f main.cpp -l %d -e %d' % (self.begl, self.endl)) + child.expect_exact(add_prompt) + child.expect_exact(add_prompt1) + child.sendline('expr ptr') + child.expect_exact(add_prompt1) + child.sendline('DONE') + child.expect_exact(prompt) + child.sendline('target stop-hook list') + + # Now run the program, expect to stop at the first breakpoint which is within the stop-hook range. + child.expect_exact(prompt) + child.sendline('run') + # Make sure we see the stop hook text from the stop of the process from the run hitting the first breakpoint + child.expect_exact('(void *) $') + child.expect_exact(prompt) + child.sendline('thread step-over') + # Expecting to find the output emitted by the firing of our stop hook. + child.expect_exact('(void *) $') + # This is orthogonal to the main stop hook test, but this example shows a bug in + # CLANG where the line table entry for the "return -1" actually includes some code + # from the other branch of the if/else, so we incorrectly stop at the "return -1" line. + # I fixed that in lldb and I'm sticking in a test here because I don't want to have to + # make up a whole nother test case for it. + child.sendline('frame info') + at_line = 'at main.cpp:%d' % (self.correct_step_line) + print('expecting "%s"' % at_line) + child.expect_exact(at_line) + + # Now continue the inferior, we'll stop at another breakpoint which is outside the stop-hook range. + child.sendline('process continue') + child.expect_exact('// Another breakpoint which is outside of the stop-hook range.') + #self.DebugPExpect(child) + child.sendline('thread step-over') + child.expect_exact('// Another breakpoint which is outside of the stop-hook range.') + #self.DebugPExpect(child) + # Verify that the 'Stop Hooks' mechanism is NOT BEING fired off. + self.expect(child.before, exe=False, matching=False, + substrs = ['(void *) $']) diff --git a/packages/Python/lldbsuite/test/functionalities/stop-hook/main.cpp b/packages/Python/lldbsuite/test/functionalities/stop-hook/main.cpp new file mode 100644 index 0000000..c10c1e5 --- /dev/null +++ b/packages/Python/lldbsuite/test/functionalities/stop-hook/main.cpp @@ -0,0 +1,54 @@ +//===-- 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 <stdlib.h> + +int a(int); +int b(int); +int c(int); + +int a(int val) +{ + if (val <= 1) + return b(val); + else if (val >= 3) + return c(val); + + return val; +} + +int b(int val) +{ + int rc = c(val); + void *ptr = malloc(1024); + if (!ptr) // Set breakpoint here to test target stop-hook. + return -1; + else + printf("ptr=%p\n", ptr); // We should stop here after stepping. + return rc; // End of the line range for which stop-hook is to be run. +} + +int c(int val) +{ + return val + 3; +} + +int main (int argc, char const *argv[]) +{ + int A1 = a(1); + printf("a(1) returns %d\n", A1); + + int C2 = c(2); // Another breakpoint which is outside of the stop-hook range. + printf("c(2) returns %d\n", C2); + + int A3 = a(3); + printf("a(3) returns %d\n", A3); + + return 0; +} diff --git a/packages/Python/lldbsuite/test/functionalities/stop-hook/multiple_threads/Makefile b/packages/Python/lldbsuite/test/functionalities/stop-hook/multiple_threads/Makefile new file mode 100644 index 0000000..035413f --- /dev/null +++ b/packages/Python/lldbsuite/test/functionalities/stop-hook/multiple_threads/Makefile @@ -0,0 +1,6 @@ +LEVEL = ../../../make + +CXX_SOURCES := main.cpp +ENABLE_THREADS := YES + +include $(LEVEL)/Makefile.rules diff --git a/packages/Python/lldbsuite/test/functionalities/stop-hook/multiple_threads/TestStopHookMultipleThreads.py b/packages/Python/lldbsuite/test/functionalities/stop-hook/multiple_threads/TestStopHookMultipleThreads.py new file mode 100644 index 0000000..c7fb53d --- /dev/null +++ b/packages/Python/lldbsuite/test/functionalities/stop-hook/multiple_threads/TestStopHookMultipleThreads.py @@ -0,0 +1,77 @@ +""" +Test that lldb stop-hook works for multiple threads. +""" + +from __future__ import print_function + + + +import os, time +import lldb +from lldbsuite.test import configuration +from lldbsuite.test.lldbtest import * + +class StopHookForMultipleThreadsTestCase(TestBase): + + mydir = TestBase.compute_mydir(__file__) + + def setUp(self): + # Call super's setUp(). + TestBase.setUp(self) + # Our simple source filename. + self.source = 'main.cpp' + # Find the line number to break inside main(). + self.first_stop = line_number(self.source, '// Set break point at this line, and add a stop-hook.') + self.thread_function = line_number(self.source, '// Break here to test that the stop-hook mechanism works for multiple threads.') + # Build dictionary to have unique executable names for each test method. + self.exe_name = self.testMethodName + self.d = {'CXX_SOURCES': self.source, 'EXE': self.exe_name} + + @expectedFlakeyFreeBSD("llvm.org/pr15037") + @expectedFlakeyLinux("llvm.org/pr15037") # stop hooks sometimes fail to fire on Linux + @expectedFailureHostWindows("llvm.org/pr22274: need a pexpect replacement for windows") + def test_stop_hook_multiple_threads(self): + """Test that lldb stop-hook works for multiple threads.""" + self.build(dictionary=self.d) + self.setTearDownCleanup(dictionary=self.d) + + import pexpect + exe = os.path.join(os.getcwd(), self.exe_name) + prompt = "(lldb) " + + # So that the child gets torn down after the test. + self.child = pexpect.spawn('%s %s' % (lldbtest_config.lldbExec, self.lldbOption)) + child = self.child + # Turn on logging for what the child sends back. + if self.TraceOn(): + child.logfile_read = sys.stdout + + if lldb.remote_platform: + child.expect_exact(prompt) + child.sendline('platform select %s' % lldb.remote_platform.GetName()) + child.expect_exact(prompt) + child.sendline('platform connect %s' % configuration.lldb_platform_url) + child.expect_exact(prompt) + child.sendline('platform settings -w %s' % configuration.lldb_platform_working_dir) + + child.expect_exact(prompt) + child.sendline('target create %s' % exe) + + # Set the breakpoint, followed by the target stop-hook commands. + child.expect_exact(prompt) + child.sendline('breakpoint set -f main.cpp -l %d' % self.first_stop) + child.expect_exact(prompt) + child.sendline('breakpoint set -f main.cpp -l %d' % self.thread_function) + child.expect_exact(prompt) + + # Now run the program, expect to stop at the first breakpoint which is within the stop-hook range. + child.sendline('run') + child.expect_exact("Process") # 'Process 2415 launched', 'Process 2415 stopped' + child.expect_exact(prompt) + child.sendline('target stop-hook add -o "frame variable --show-globals g_val"') + child.expect_exact("Stop hook") # 'Stop hook #1 added.' + child.expect_exact(prompt) + + # Continue and expect to find the output emitted by the firing of our stop hook. + child.sendline('continue') + child.expect_exact('(uint32_t) ::g_val = ') diff --git a/packages/Python/lldbsuite/test/functionalities/stop-hook/multiple_threads/main.cpp b/packages/Python/lldbsuite/test/functionalities/stop-hook/multiple_threads/main.cpp new file mode 100644 index 0000000..e193ae1 --- /dev/null +++ b/packages/Python/lldbsuite/test/functionalities/stop-hook/multiple_threads/main.cpp @@ -0,0 +1,77 @@ +//===-- main.cpp ------------------------------------------------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#include <chrono> +#include <cstdio> +#include <mutex> +#include <random> +#include <thread> + +std::default_random_engine g_random_engine{std::random_device{}()}; +std::uniform_int_distribution<> g_distribution{0, 3000000}; + +uint32_t g_val = 0; + +uint32_t +access_pool (bool flag = false) +{ + static std::mutex g_access_mutex; + if (!flag) + g_access_mutex.lock(); + + uint32_t old_val = g_val; + if (flag) + g_val = old_val + 1; + + if (!flag) + g_access_mutex.unlock(); + return g_val; +} + +void +thread_func (uint32_t thread_index) +{ + // Break here to test that the stop-hook mechanism works for multiple threads. + printf ("%s (thread index = %u) startng...\n", __FUNCTION__, thread_index); + + uint32_t count = 0; + uint32_t val; + while (count++ < 15) + { + // random micro second sleep from zero to 3 seconds + int usec = g_distribution(g_random_engine); + printf ("%s (thread = %u) doing a usleep (%d)...\n", __FUNCTION__, thread_index, usec); + std::this_thread::sleep_for(std::chrono::microseconds{usec}); + + if (count < 7) + val = access_pool (); + else + val = access_pool (true); + + printf ("%s (thread = %u) after usleep access_pool returns %d (count=%d)...\n", __FUNCTION__, thread_index, val, count); + } + printf ("%s (thread index = %u) exiting...\n", __FUNCTION__, thread_index); +} + + +int main (int argc, char const *argv[]) +{ + std::thread threads[3]; + + printf ("Before turning all three threads loose...\n"); // Set break point at this line, and add a stop-hook. + // Create 3 threads + for (auto &thread : threads) + thread = std::thread{thread_func, std::distance(threads, &thread)}; + + // Join all of our threads + for (auto &thread : threads) + thread.join(); + + return 0; +} |
