diff options
Diffstat (limited to 'gnu/llvm/lldb/packages/Python/lldbsuite/test/linux/thread')
3 files changed, 140 insertions, 0 deletions
diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/linux/thread/create_during_instruction_step/Makefile b/gnu/llvm/lldb/packages/Python/lldbsuite/test/linux/thread/create_during_instruction_step/Makefile new file mode 100644 index 00000000000..566938ca0cc --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/linux/thread/create_during_instruction_step/Makefile @@ -0,0 +1,3 @@ +CXX_SOURCES := main.cpp +ENABLE_THREADS := YES +include Makefile.rules diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/linux/thread/create_during_instruction_step/TestCreateDuringInstructionStep.py b/gnu/llvm/lldb/packages/Python/lldbsuite/test/linux/thread/create_during_instruction_step/TestCreateDuringInstructionStep.py new file mode 100644 index 00000000000..c4d6461ddde --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/linux/thread/create_during_instruction_step/TestCreateDuringInstructionStep.py @@ -0,0 +1,83 @@ +""" +This tests that we do not lose control of the inferior, while doing an instruction-level step +over a thread creation instruction. +""" + + + +import lldb +from lldbsuite.test.decorators import * +from lldbsuite.test.lldbtest import * +from lldbsuite.test import lldbutil + + +class CreateDuringInstructionStepTestCase(TestBase): + + mydir = TestBase.compute_mydir(__file__) + NO_DEBUG_INFO_TESTCASE = True + + @skipUnlessPlatform(['linux']) + @expectedFailureAndroid('llvm.org/pr24737', archs=['arm']) + @expectedFailureAll( + oslist=["linux"], + archs=["arm"], + bugnumber="llvm.org/pr24737") + def test_step_inst(self): + self.build(dictionary=self.getBuildFlags()) + exe = self.getBuildArtifact("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/gnu/llvm/lldb/packages/Python/lldbsuite/test/linux/thread/create_during_instruction_step/main.cpp b/gnu/llvm/lldb/packages/Python/lldbsuite/test/linux/thread/create_during_instruction_step/main.cpp new file mode 100644 index 00000000000..4488f2310d5 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/linux/thread/create_during_instruction_step/main.cpp @@ -0,0 +1,54 @@ +//===-- main.cpp ------------------------------------------------*- C++ -*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +// 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; +} |