Move lldb/test to lldb/packages/Python/lldbsuite/test.

This is the conclusion of an effort to get LLDB's Python code
structured into a bona-fide Python package.  This has a number
of benefits, but most notably the ability to more easily share
Python code between different but related pieces of LLDB's Python
infrastructure (for example, `scripts` can now share code with
`test`).

llvm-svn: 251532

3 files changed, 126 insertions, 0 deletions

diff --git a/lldb/packages/Python/lldbsuite/test/linux/thread/create_during_instruction_step/Makefile b/lldb/packages/Python/lldbsuite/test/linux/thread/create_during_instruction_step/Makefile
new file mode 100644
index 00000000000..67aa16625bf
--- /dev/null
+++ b/lldb/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/lldb/packages/Python/lldbsuite/test/linux/thread/create_during_instruction_step/TestCreateDuringInstructionStep.py b/lldb/packages/Python/lldbsuite/test/linux/thread/create_during_instruction_step/TestCreateDuringInstructionStep.py
new file mode 100644
index 00000000000..130afa842f0
--- /dev/null
+++ b/lldb/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 use_lldb_suite
+
+import os
+import lldb
+from lldbtest import *
+import 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/lldb/packages/Python/lldbsuite/test/linux/thread/create_during_instruction_step/main.cpp b/lldb/packages/Python/lldbsuite/test/linux/thread/create_during_instruction_step/main.cpp
new file mode 100644
index 00000000000..079e8b13798
--- /dev/null
+++ b/lldb/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;
+}