diff options
Diffstat (limited to 'packages/Python/lldbsuite/test/linux')
6 files changed, 199 insertions, 0 deletions
diff --git a/packages/Python/lldbsuite/test/linux/builtin_trap/Makefile b/packages/Python/lldbsuite/test/linux/builtin_trap/Makefile new file mode 100644 index 000000000000..8a7102e347af --- /dev/null +++ b/packages/Python/lldbsuite/test/linux/builtin_trap/Makefile @@ -0,0 +1,5 @@ +LEVEL = ../../make + +CXX_SOURCES := main.cpp + +include $(LEVEL)/Makefile.rules diff --git a/packages/Python/lldbsuite/test/linux/builtin_trap/TestBuiltinTrap.py b/packages/Python/lldbsuite/test/linux/builtin_trap/TestBuiltinTrap.py new file mode 100644 index 000000000000..ea742341512c --- /dev/null +++ b/packages/Python/lldbsuite/test/linux/builtin_trap/TestBuiltinTrap.py @@ -0,0 +1,51 @@ +""" +Test lldb ability to unwind a stack with a function containing a call to the +'__builtin_trap' intrinsic, which GCC (4.6) encodes to an illegal opcode. +""" + +from __future__ import print_function + + + +import os +import lldb +from lldbsuite.test.lldbtest import * +import lldbsuite.test.lldbutil as lldbutil + +class BuiltinTrapTestCase(TestBase): + + mydir = TestBase.compute_mydir(__file__) + + def setUp(self): + # Call super's setUp(). + TestBase.setUp(self) + # Find the line number to break at. + self.line = line_number('main.cpp', '// Set break point at this line.') + + @expectedFailureAll("llvm.org/pr15936", compiler="gcc", compiler_version=["<=","4.6"]) + @expectedFailureAll(archs="arm", compiler="gcc", triple=".*-android") # gcc generates incorrect linetable + @skipIfWindows + def test_with_run_command(self): + """Test that LLDB handles a function with __builtin_trap correctly.""" + self.build() + self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) + + lldbutil.run_break_set_by_file_and_line (self, "main.cpp", 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']) + + # print backtrace, expect both 'bar' and 'main' functions to be listed + self.expect('bt', substrs = ['bar', 'main']) + + # go up one frame + self.runCmd("up", RUN_SUCCEEDED) + + # evaluate a local + self.expect('p foo', substrs = ['= 5']) diff --git a/packages/Python/lldbsuite/test/linux/builtin_trap/main.cpp b/packages/Python/lldbsuite/test/linux/builtin_trap/main.cpp new file mode 100644 index 000000000000..84156ef2ac4f --- /dev/null +++ b/packages/Python/lldbsuite/test/linux/builtin_trap/main.cpp @@ -0,0 +1,17 @@ +//===-- main.cpp ------------------------------------------------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +void bar(int const *foo) { + __builtin_trap(); // Set break point at this line. +} + +int main() { + int foo = 5; + bar(&foo); +} diff --git a/packages/Python/lldbsuite/test/linux/thread/create_during_instruction_step/Makefile b/packages/Python/lldbsuite/test/linux/thread/create_during_instruction_step/Makefile new file mode 100644 index 000000000000..67aa16625bff --- /dev/null +++ b/packages/Python/lldbsuite/test/linux/thread/create_during_instruction_step/Makefile @@ -0,0 +1,5 @@ +LEVEL = ../../../make + +CXX_SOURCES := main.cpp +ENABLE_THREADS := YES +include $(LEVEL)/Makefile.rules diff --git a/packages/Python/lldbsuite/test/linux/thread/create_during_instruction_step/TestCreateDuringInstructionStep.py b/packages/Python/lldbsuite/test/linux/thread/create_during_instruction_step/TestCreateDuringInstructionStep.py new file mode 100644 index 000000000000..c6d9afb02003 --- /dev/null +++ b/packages/Python/lldbsuite/test/linux/thread/create_during_instruction_step/TestCreateDuringInstructionStep.py @@ -0,0 +1,66 @@ +""" +This tests that we do not lose control of the inferior, while doing an instruction-level step +over a thread creation instruction. +""" + +from __future__ import print_function + + + +import os +import lldb +from lldbsuite.test.lldbtest import * +import lldbsuite.test.lldbutil as lldbutil + +class CreateDuringInstructionStepTestCase(TestBase): + + mydir = TestBase.compute_mydir(__file__) + + def setUp(self): + # Call super's setUp(). + TestBase.setUp(self) + + @skipUnlessPlatform(['linux']) + @expectedFailureAndroid('llvm.org/pr24737', archs=['arm']) + def test_step_inst(self): + self.build(dictionary=self.getBuildFlags()) + exe = os.path.join(os.getcwd(), "a.out") + target = self.dbg.CreateTarget(exe) + self.assertTrue(target and target.IsValid(), "Target is valid") + + # This should create a breakpoint in the stepping thread. + breakpoint = target.BreakpointCreateByName("main") + self.assertTrue(breakpoint and breakpoint.IsValid(), "Breakpoint is valid") + + # Run the program. + process = target.LaunchSimple(None, None, self.get_process_working_directory()) + self.assertTrue(process and process.IsValid(), PROCESS_IS_VALID) + + # The stop reason of the thread should be breakpoint. + self.assertEqual(process.GetState(), lldb.eStateStopped, PROCESS_STOPPED) + + threads = lldbutil.get_threads_stopped_at_breakpoint(process, breakpoint) + self.assertEqual(len(threads), 1, STOPPED_DUE_TO_BREAKPOINT) + + thread = threads[0] + self.assertTrue(thread and thread.IsValid(), "Thread is valid") + + # Make sure we see only one threads + self.assertEqual(process.GetNumThreads(), 1, 'Number of expected threads and actual threads do not match.') + + # Keep stepping until we see the thread creation + while process.GetNumThreads() < 2: + thread.StepInstruction(False) + self.assertEqual(process.GetState(), lldb.eStateStopped, PROCESS_STOPPED) + self.assertEqual(thread.GetStopReason(), lldb.eStopReasonPlanComplete, "Step operation succeeded") + if self.TraceOn(): + self.runCmd("disassemble --pc") + + if self.TraceOn(): + self.runCmd("thread list") + + # We have successfully caught thread creation. Now just run to completion + process.Continue() + + # At this point, the inferior process should have exited. + self.assertEqual(process.GetState(), lldb.eStateExited, PROCESS_EXITED) diff --git a/packages/Python/lldbsuite/test/linux/thread/create_during_instruction_step/main.cpp b/packages/Python/lldbsuite/test/linux/thread/create_during_instruction_step/main.cpp new file mode 100644 index 000000000000..079e8b13798c --- /dev/null +++ b/packages/Python/lldbsuite/test/linux/thread/create_during_instruction_step/main.cpp @@ -0,0 +1,55 @@ +//===-- main.cpp ------------------------------------------------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// This file deliberately uses low level linux-specific API for thread creation because: +// - instruction-stepping over thread creation using higher-level functions was very slow +// - it was also unreliable due to single-stepping bugs unrelated to this test +// - some threading libraries do not create or destroy threads when we would expect them to + +#include <sched.h> + +#include <atomic> +#include <cstdio> + +enum { STACK_SIZE = 0x2000 }; + +static uint8_t child_stack[STACK_SIZE]; + +pid_t child_tid; + +std::atomic<bool> flag(false); + +int thread_main(void *) +{ + while (! flag) // Make sure the thread does not exit prematurely + ; + + return 0; +} + +int main () +{ + int ret = clone(thread_main, + child_stack + STACK_SIZE/2, // Don't care whether the stack grows up or down, + // just point to the middle + CLONE_CHILD_CLEARTID | CLONE_FILES | CLONE_FS | CLONE_PARENT_SETTID | + CLONE_SIGHAND | CLONE_SYSVSEM | CLONE_THREAD | CLONE_VM, + nullptr, // thread_main argument + &child_tid); + + if (ret == -1) + { + perror("clone"); + return 1; + } + + flag = true; + + return 0; +} |