[API] Extend the `SBThreadPlan` interface

[aleksandr.urakov]

Summary

This patch extends the SBThreadPlan to allow retrieving of thread plans for scripted steps.

[jingham]

Presumably you are doing this so one scripted thread plan can use another one? This is the right way to do that, so this is great. Not sure why I didn't think of it.

BTW, looks like I added this without any tests. Totally my bad, this was a weekend experiment and was inert if not used, so I got the bits in and then wrote a bug on myself to write tests - demonstrating again why that's inadvisable...

If you are playing around with this and have a moment to formalize what you are doing into a test or two, I'd be grateful...

[jingham]

And tick the checkbox...

[aleksandr.urakov]

Thanks!

Yes, I've added this exactly to allow usage of a scripted plan from another scripted plan. Sure, I will add a test for this :) But I can't figure out how this part is tested, can you explain me this a little, please?

[jingham]

This should be easy to test with the python testsuite (lldbtest.) Start with the sample_test in packages/Python/lldbsuite/test - don't use the inline one, that won't be flexible enough. Then you can just make a scripted thread plan that just pushes a "step over" or "step in" plan, and step with it and make sure it landed where it should. Then to test your addition, make another scripted plan that calls your trivial stepping one, and make sure that stops where expected as well.

[aleksandr.urakov]

Ok, I'll do it, thanks!

[aleksandr.urakov]

I've added the test. Can you see, please, is it ok?

[jingham]

That looks right. Thanks for adding the test!

lldb/trunk/include/lldb/API/SBThreadPlan.h

public:
   SBThreadPlan QueueThreadPlanForStepInRange(SBAddress &start_address,
                                              lldb::addr_t range_size);
 
   SBThreadPlan QueueThreadPlanForStepOut(uint32_t frame_idx_to_step_to,
                                          bool first_insn = false);
 
   SBThreadPlan QueueThreadPlanForRunToAddress(SBAddress address);
 
+  SBThreadPlan QueueThreadPlanForStepScripted(const char *script_class_name);
+
 #ifndef SWIG
   lldb_private::ThreadPlan *get();
 #endif
 
 protected:
   friend class SBBreakpoint;
   friend class SBBreakpointLocation;
   friend class SBFrame;

lldb/trunk/packages/Python/lldbsuite/test/functionalities/step_scripted/Makefile

+LEVEL = ../../make
+
+C_SOURCES := main.c
+
+include $(LEVEL)/Makefile.rules

lldb/trunk/packages/Python/lldbsuite/test/functionalities/step_scripted/Steps.py

+import lldb
+
+class StepWithChild:
+    def __init__(self, thread_plan):
+        self.thread_plan = thread_plan
+        self.child_thread_plan = self.queue_child_thread_plan()
+
+    def explains_stop(self, event):
+        return False
+
+    def should_stop(self, event):
+        if not self.child_thread_plan.IsPlanComplete():
+            return False
+
+        self.thread_plan.SetPlanComplete(True)
+
+        return True
+
+    def should_step(self):
+        return False
+
+    def queue_child_thread_plan(self):
+        return None
+
+class StepOut(StepWithChild):
+    def __init__(self, thread_plan, dict):
+        StepWithChild.__init__(self, thread_plan)
+
+    def queue_child_thread_plan(self):
+        return self.thread_plan.QueueThreadPlanForStepOut(0)
+
+class StepScripted(StepWithChild):
+    def __init__(self, thread_plan, dict):
+        StepWithChild.__init__(self, thread_plan)
+
+    def queue_child_thread_plan(self):
+        return self.thread_plan.QueueThreadPlanForStepScripted("Steps.StepOut")

lldb/trunk/packages/Python/lldbsuite/test/functionalities/step_scripted/TestStepScripted.py

+"""
+Tests stepping with scripted thread plans.
+"""
+
+import lldb
+import lldbsuite.test.lldbutil as lldbutil
+from lldbsuite.test.lldbtest import *
+
+class StepScriptedTestCase(TestBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    NO_DEBUG_INFO_TESTCASE = True
+
+    def test_standard_step_out(self):
+        """Tests stepping with the scripted thread plan laying over a standard thread plan for stepping out."""
+        self.build()
+        self.main_source_file = lldb.SBFileSpec("main.c")
+        self.step_out_with_scripted_plan("Steps.StepOut")
+
+    def test_scripted_step_out(self):
+        """Tests stepping with the scripted thread plan laying over an another scripted thread plan for stepping out."""
+        self.build()
+        self.main_source_file = lldb.SBFileSpec("main.c")
+        self.step_out_with_scripted_plan("Steps.StepScripted")
+
+    def setUp(self):
+        TestBase.setUp(self)
+        self.runCmd("command script import Steps.py")
+
+    def step_out_with_scripted_plan(self, name):
+        (target, process, thread, bkpt) = lldbutil.run_to_source_breakpoint(self, "Set a breakpoint here", self.main_source_file)
+
+        frame = thread.GetFrameAtIndex(0)
+        self.assertEqual("foo", frame.GetFunctionName())
+
+        err = thread.StepUsingScriptedThreadPlan(name)
+        self.assertTrue(err.Success(), "Failed to step out")
+
+        frame = thread.GetFrameAtIndex(0)
+        self.assertEqual("main", frame.GetFunctionName())

lldb/trunk/packages/Python/lldbsuite/test/functionalities/step_scripted/main.c

+#include <stdio.h>
+
+void foo() {
+  printf("Set a breakpoint here.\n");
+}
+
+int main() {
+  foo();
+  return 0;
+}

lldb/trunk/scripts/interface/SBThreadPlan.i

QueueThreadPlanForStepInRange (SBAddress &start_address,
                                    lldb::addr_t range_size);
 
     SBThreadPlan
     QueueThreadPlanForStepOut (uint32_t frame_idx_to_step_to, bool first_insn = false);
     
     SBThreadPlan
     QueueThreadPlanForRunToAddress (SBAddress address);
 
+    SBThreadPlan
+    QueueThreadPlanForStepScripted(const char *script_class_name);
+
 
 protected:
     friend class SBBreakpoint;
     friend class SBBreakpointLocation;
     friend class SBFrame;
     friend class SBProcess;
     friend class SBDebugger;
     friend class SBValue;

lldb/trunk/source/API/SBThreadPlan.cpp

if (!address)
       return SBThreadPlan();
 
     return SBThreadPlan(m_opaque_sp->GetThread().QueueThreadPlanForRunToAddress(
         false, *address, false));
   } else {
     return SBThreadPlan();
   }
 }
+
+SBThreadPlan
+SBThreadPlan::QueueThreadPlanForStepScripted(const char *script_class_name) {
+  if (m_opaque_sp) {
+    return SBThreadPlan(m_opaque_sp->GetThread().QueueThreadPlanForStepScripted(
+        false, script_class_name, false));
+  } else {
+    return SBThreadPlan();
+  }
+}