Vendor import of lldb trunk r256945:

https://llvm.org/svn/llvm-project/lldb/trunk@256945

2 files changed, 174 insertions, 0 deletions

diff --git a/packages/Python/lldbsuite/test/lang/go/goroutines/TestGoroutines.py b/packages/Python/lldbsuite/test/lang/go/goroutines/TestGoroutines.py
new file mode 100644
index 0000000..35961eb
--- /dev/null
+++ b/packages/Python/lldbsuite/test/lang/go/goroutines/TestGoroutines.py
@@ -0,0 +1,85 @@
+"""Test the Go OS Plugin."""
+
+from __future__ import print_function
+
+
+
+import os, time
+import lldb
+import lldbsuite.test.lldbutil as lldbutil
+from lldbsuite.test.lldbtest import *
+
+class TestGoASTContext(TestBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    @add_test_categories(['pyapi'])
+    @skipIfFreeBSD # llvm.org/pr24895 triggers assertion failure
+    @skipIfRemote # Not remote test suite ready
+    @no_debug_info_test
+    @skipUnlessGoInstalled
+    def test_goroutine_plugin(self):
+        """Test goroutine as threads support."""
+        self.buildGo()
+        self.launchProcess()
+        self.check_goroutines()
+
+    def setUp(self):
+        # Call super's setUp().
+        TestBase.setUp(self)
+        # Find the line numbers to break inside main().
+        self.main_source = "main.go"
+        self.break_line1 = line_number(self.main_source, '// stop1')
+        self.break_line2 = line_number(self.main_source, '// stop2')
+        self.break_line3 = line_number(self.main_source, '// stop3')
+
+    def launchProcess(self):
+        exe = os.path.join(os.getcwd(), "a.out")
+
+        target = self.dbg.CreateTarget(exe)
+        self.assertTrue(target, VALID_TARGET)
+
+        self.bpt1 = target.BreakpointCreateByLocation(self.main_source, self.break_line1)
+        self.assertTrue(self.bpt1, VALID_BREAKPOINT)
+        self.bpt2 = target.BreakpointCreateByLocation(self.main_source, self.break_line2)
+        self.assertTrue(self.bpt2, VALID_BREAKPOINT)
+        self.bpt3 = target.BreakpointCreateByLocation(self.main_source, self.break_line3)
+        self.assertTrue(self.bpt3, VALID_BREAKPOINT)
+
+        # Now launch the process, and do not stop at entry point.
+        process = target.LaunchSimple (None, None, self.get_process_working_directory())
+
+        self.assertTrue(process, PROCESS_IS_VALID)
+
+        # The stop reason of the thread should be breakpoint.
+        thread_list = lldbutil.get_threads_stopped_at_breakpoint (process, self.bpt1)
+
+        # Make sure we stopped at the first breakpoint.
+        self.assertTrue (len(thread_list) != 0, "No thread stopped at our breakpoint.")
+        self.assertTrue (len(thread_list) == 1, "More than one thread stopped at our breakpoint.")
+
+        frame = thread_list[0].GetFrameAtIndex(0)
+        self.assertTrue (frame, "Got a valid frame 0 frame.")
+
+    def check_goroutines(self):
+        self.assertLess(len(self.process().threads), 20)
+        self.process().Continue()
+
+        # Make sure we stopped at the 2nd breakpoint
+        thread_list = lldbutil.get_threads_stopped_at_breakpoint (self.process(), self.bpt2)
+        self.assertTrue (len(thread_list) != 0, "No thread stopped at our breakpoint.")
+        self.assertTrue (len(thread_list) == 1, "More than one thread stopped at our breakpoint.")
+        
+        # There's (at least) 21 goroutines.
+        self.assertGreater(len(self.process().threads), 20)
+        # self.dbg.HandleCommand("log enable lldb os")
+
+        # Now test that stepping works if the memory thread moves to a different backing thread.
+        for i in list(range(11)):
+            self.thread().StepOver()
+            self.assertEqual(lldb.eStopReasonPlanComplete, self.thread().GetStopReason(), self.thread().GetStopDescription(100))
+        
+        # Disable the plugin and make sure the goroutines disappear
+        self.dbg.HandleCommand("settings set plugin.os.goroutines.enable false")
+        self.thread().StepInstruction(False)
+        self.assertLess(len(self.process().threads), 20)
diff --git a/packages/Python/lldbsuite/test/lang/go/goroutines/main.go b/packages/Python/lldbsuite/test/lang/go/goroutines/main.go
new file mode 100644
index 0000000..bb44f7b
--- /dev/null
+++ b/packages/Python/lldbsuite/test/lang/go/goroutines/main.go
@@ -0,0 +1,89 @@
+package main
+
+import (
+	"fmt"
+	"runtime"
+)
+
+type philosopher struct {
+	i int
+	forks [2]chan bool
+	eating chan int
+	done  chan struct{}
+}
+
+func (p philosopher) run() {
+	for {
+		select {
+		case <-p.done:
+			return
+		case <-p.forks[0]:
+			p.eat()
+		}
+	}
+}
+
+func (p philosopher) eat() {
+	select {
+	case <-p.done:
+		return
+	case <-p.forks[1]:
+		p.eating <- p.i
+		p.forks[0] <- true
+		p.forks[1] <- true
+		runtime.Gosched()
+	}
+}
+
+func startPhilosophers(n int) (chan struct{}, chan int) {
+	philosophers := make([]*philosopher, n)
+	chans := make([]chan bool, n)
+	for i := range chans {
+		chans[i] = make(chan bool, 1)
+		chans[i] <- true
+	}
+	eating := make(chan int, n)
+	done := make(chan struct{})
+	for i := range philosophers {
+		var min, max int
+		if i == n - 1 {
+			min = 0
+			max = i
+		} else {
+			min = i
+			max = i + 1
+		}
+		philosophers[i] = &philosopher{i: i, forks: [2]chan bool{chans[min], chans[max]}, eating: eating, done: done}
+		go philosophers[i].run()
+	}
+	return done, eating
+}
+
+func wait(c chan int) {
+	fmt.Println(<- c)
+	runtime.Gosched()
+}
+
+func main() {
+	// Restrict go to 1 real thread so we can be sure we're seeing goroutines
+	// and not threads.
+	runtime.GOMAXPROCS(1)
+	// Create a bunch of goroutines
+	done, eating := startPhilosophers(20) // stop1
+	// Now turn up the number of threads so this goroutine is likely to get
+	// scheduled on a different thread.
+	runtime.GOMAXPROCS(runtime.NumCPU()) // stop2
+	// Now let things run. Hopefully we'll bounce around
+	wait(eating)
+	wait(eating)
+	wait(eating)
+	wait(eating)
+	wait(eating)
+	wait(eating)
+	wait(eating)
+	wait(eating)
+	wait(eating)
+	wait(eating)
+	close(done)
+	fmt.Println("done") // stop3
+}