This checkin is the first step in making the lldb thread stepping mechanism more accessible from

the user level.  It adds the ability to invent new stepping modes implemented by python classes,
and to view the current thread plan stack and to some extent alter it.

I haven't gotten to documentation or tests yet.  But this should not cause any behavior changes
if you don't use it, so its safe to check it in now and work on it incrementally.

llvm-svn: 218642

lldb/source/API/SBCommandInterpreter.cpp

@@ -442,6 +442,17 @@ LLDBSwigPythonCreateSyntheticProvider (const char *python_class_name,
                                        const lldb::ValueObjectSP& valobj_sp);
 
 
+extern "C" void*
+LLDBSwigPythonCreateScriptedThreadPlan (const char *python_class_name,
+                                        const char *session_dictionary_name,
+                                        const lldb::ThreadPlanSP& thread_plan_sp);
+
+extern "C" bool
+LLDBSWIGPythonCallThreadPlan (void *implementor,
+                              const char *method_name,
+                              Event *event_sp,
+                              bool &got_error);
+
 extern "C" uint32_t
 LLDBSwigPython_CalculateNumChildren (void *implementor);
 
@@ -539,7 +550,9 @@ SBCommandInterpreter::InitializeSWIG ()
                                                   LLDBSWIGPythonRunScriptKeywordThread,
                                                   LLDBSWIGPythonRunScriptKeywordTarget,
                                                   LLDBSWIGPythonRunScriptKeywordFrame,
-                                                  LLDBSWIGPython_GetDynamicSetting);
+                                                  LLDBSWIGPython_GetDynamicSetting,
+                                                  LLDBSwigPythonCreateScriptedThreadPlan,
+                                                  LLDBSWIGPythonCallThreadPlan);
 #endif
     }
 }

lldb/source/API/SBEvent.cpp

@@ -43,6 +43,12 @@ SBEvent::SBEvent (EventSP &event_sp) :
 {
 }
 
+SBEvent::SBEvent (Event *event_ptr) :
+    m_event_sp (),
+    m_opaque_ptr (event_ptr)
+{
+}
+
 SBEvent::SBEvent (const SBEvent &rhs) :
     m_event_sp (rhs.m_event_sp),
     m_opaque_ptr (rhs.m_opaque_ptr)

lldb/source/API/SBThread.cpp

@@ -41,6 +41,7 @@
 #include "lldb/API/SBEvent.h"
 #include "lldb/API/SBFrame.h"
 #include "lldb/API/SBProcess.h"
+#include "lldb/API/SBThreadPlan.h"
 #include "lldb/API/SBValue.h"
 
 using namespace lldb;
@@ -918,7 +919,9 @@ SBThread::RunToAddress (lldb::addr_t addr)
 
         Thread *thread = exe_ctx.GetThreadPtr();
 
-        ThreadPlanSP new_plan_sp(thread->QueueThreadPlanForRunToAddress (abort_other_plans, target_addr, stop_other_threads));
+        ThreadPlanSP new_plan_sp(thread->QueueThreadPlanForRunToAddress (abort_other_plans,
+                                                                         target_addr,
+                                                                         stop_other_threads));
 
         // This returns an error, we should use it!
         ResumeNewPlan (exe_ctx, new_plan_sp.get());
@@ -1072,6 +1075,46 @@ SBThread::StepOverUntil (lldb::SBFrame &sb_frame,
     return sb_error;
 }
 
+SBError
+SBThread::StepUsingScriptedThreadPlan (const char *script_class_name)
+{
+    Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
+    SBError sb_error;
+
+    Mutex::Locker api_locker;
+    ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker);
+
+    if (log)
+    {
+        log->Printf ("SBThread(%p)::StepUsingScriptedThreadPlan: class name: %s",
+                     static_cast<void*>(exe_ctx.GetThreadPtr()),
+                     script_class_name);
+    }
+
+
+    if (!exe_ctx.HasThreadScope())
+    {
+        sb_error.SetErrorString("this SBThread object is invalid");
+        return sb_error;
+    }
+
+    Thread *thread = exe_ctx.GetThreadPtr();
+    ThreadPlanSP thread_plan_sp = thread->QueueThreadPlanForStepScripted(false, script_class_name, false);
+
+    if (thread_plan_sp)
+        sb_error = ResumeNewPlan(exe_ctx, thread_plan_sp.get());
+    else
+    {
+        sb_error.SetErrorStringWithFormat("Error queuing thread plan for class: %s.", script_class_name);
+        if (log)
+        log->Printf ("SBThread(%p)::StepUsingScriptedThreadPlan: Error queuing thread plan for class: %s",
+                     static_cast<void*>(exe_ctx.GetThreadPtr()),
+                     script_class_name);
+    }
+
+    return sb_error;
+}
+
 SBError
 SBThread::JumpToLine (lldb::SBFileSpec &file_spec, uint32_t line)
 {
@@ -1473,7 +1516,8 @@ SBThread::GetExtendedBacktraceThread (const char *type)
                                 const char *queue_name = new_thread_sp->GetQueueName();
                                 if (queue_name == NULL)
                                     queue_name = "";
-                                log->Printf ("SBThread(%p)::GetExtendedBacktraceThread() => new extended Thread created (%p) with queue_id 0x%" PRIx64 " queue name '%s'",
+                                log->Printf ("SBThread(%p)::GetExtendedBacktraceThread() => new extended Thread "
+                                             "created (%p) with queue_id 0x%" PRIx64 " queue name '%s'",
                                              static_cast<void*>(exe_ctx.GetThreadPtr()),
                                              static_cast<void*>(new_thread_sp.get()),
                                              new_thread_sp->GetQueueID(),
@@ -1515,3 +1559,24 @@ SBThread::SafeToCallFunctions ()
         return thread_sp->SafeToCallFunctions();
     return true;
 }
+
+lldb_private::Thread *
+SBThread::operator->()
+{
+    ThreadSP thread_sp(m_opaque_sp->GetThreadSP());
+    if (thread_sp)
+        return thread_sp.get();
+    else
+        return NULL;
+}
+
+lldb_private::Thread *
+SBThread::get()
+{
+    ThreadSP thread_sp(m_opaque_sp->GetThreadSP());
+    if (thread_sp)
+        return thread_sp.get();
+    else
+        return NULL;
+}
+

lldb/source/API/SBThreadPlan.cpp

@@ -0,0 +1,285 @@
+//===-- SBThread.cpp --------------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "lldb/lldb-python.h"
+
+#include "lldb/API/SBThread.h"
+
+#include "lldb/API/SBSymbolContext.h"
+#include "lldb/API/SBFileSpec.h"
+#include "lldb/API/SBStream.h"
+#include "lldb/Breakpoint/BreakpointLocation.h"
+#include "lldb/Core/Debugger.h"
+#include "lldb/Core/State.h"
+#include "lldb/Core/Stream.h"
+#include "lldb/Core/StreamFile.h"
+#include "lldb/Core/StructuredData.h"
+#include "lldb/Interpreter/CommandInterpreter.h"
+#include "lldb/Target/SystemRuntime.h"
+#include "lldb/Target/Thread.h"
+#include "lldb/Target/ThreadPlan.h"
+#include "lldb/Target/Process.h"
+#include "lldb/Target/Queue.h"
+#include "lldb/Symbol/SymbolContext.h"
+#include "lldb/Symbol/CompileUnit.h"
+#include "lldb/Target/StopInfo.h"
+#include "lldb/Target/Target.h"
+#include "lldb/Target/ThreadPlan.h"
+#include "lldb/Target/ThreadPlanPython.h"
+#include "lldb/Target/ThreadPlanStepInstruction.h"
+#include "lldb/Target/ThreadPlanStepOut.h"
+#include "lldb/Target/ThreadPlanStepRange.h"
+#include "lldb/Target/ThreadPlanStepInRange.h"
+
+
+#include "lldb/API/SBAddress.h"
+#include "lldb/API/SBDebugger.h"
+#include "lldb/API/SBEvent.h"
+#include "lldb/API/SBFrame.h"
+#include "lldb/API/SBProcess.h"
+#include "lldb/API/SBThreadPlan.h"
+#include "lldb/API/SBValue.h"
+
+using namespace lldb;
+using namespace lldb_private;
+
+//----------------------------------------------------------------------
+// Constructors
+//----------------------------------------------------------------------
+SBThreadPlan::SBThreadPlan ()
+{
+}
+
+SBThreadPlan::SBThreadPlan (const ThreadPlanSP& lldb_object_sp) :
+    m_opaque_sp (lldb_object_sp)
+{
+}
+
+SBThreadPlan::SBThreadPlan (const SBThreadPlan &rhs) :
+    m_opaque_sp (rhs.m_opaque_sp)
+{
+    
+}
+
+SBThreadPlan::SBThreadPlan (lldb::SBThread &sb_thread, const char *class_name)
+{
+    Thread *thread = sb_thread.get();
+    if (thread)
+        m_opaque_sp.reset(new ThreadPlanPython(*thread, class_name));
+}
+
+//----------------------------------------------------------------------
+// Assignment operator
+//----------------------------------------------------------------------
+
+const lldb::SBThreadPlan &
+SBThreadPlan::operator = (const SBThreadPlan &rhs)
+{
+    if (this != &rhs)
+        m_opaque_sp = rhs.m_opaque_sp;
+    return *this;
+}
+//----------------------------------------------------------------------
+// Destructor
+//----------------------------------------------------------------------
+SBThreadPlan::~SBThreadPlan()
+{
+}
+
+lldb_private::ThreadPlan *
+SBThreadPlan::get()
+{
+    return m_opaque_sp.get();
+}
+
+bool
+SBThreadPlan::IsValid() const
+{
+    return m_opaque_sp.get() != NULL;
+}
+
+void
+SBThreadPlan::Clear ()
+{
+    m_opaque_sp.reset();
+}
+
+lldb::StopReason
+SBThreadPlan::GetStopReason()
+{
+    return eStopReasonNone;
+}
+
+size_t
+SBThreadPlan::GetStopReasonDataCount()
+{
+    return 0;
+}
+
+uint64_t
+SBThreadPlan::GetStopReasonDataAtIndex(uint32_t idx)
+{
+    return 0;
+}
+
+SBThread
+SBThreadPlan::GetThread () const
+{
+    if (m_opaque_sp)
+    {
+        return SBThread(m_opaque_sp->GetThread().shared_from_this());
+    }
+    else
+        return SBThread();
+}
+
+bool
+SBThreadPlan::GetDescription (lldb::SBStream &description) const
+{
+    if (m_opaque_sp)
+    {
+        m_opaque_sp->GetDescription(description.get(), eDescriptionLevelFull);
+    }
+    else
+    {
+        description.Printf("Empty SBThreadPlan");
+    }
+    return true;
+}
+
+void
+SBThreadPlan::SetThreadPlan (const ThreadPlanSP& lldb_object_sp)
+{
+    m_opaque_sp = lldb_object_sp;
+}
+
+void
+SBThreadPlan::SetPlanComplete (bool success)
+{
+    if (m_opaque_sp)
+        m_opaque_sp->SetPlanComplete (success);
+}
+
+bool
+SBThreadPlan::IsPlanComplete()
+{
+    if (m_opaque_sp)
+        return m_opaque_sp->IsPlanComplete();
+    else
+        return true;
+}
+
+bool
+SBThreadPlan::IsValid()
+{
+    if (m_opaque_sp)
+        return m_opaque_sp->ValidatePlan(nullptr);
+    else
+        return false;
+}
+
+    // This section allows an SBThreadPlan to push another of the common types of plans...
+    //
+    // FIXME, you should only be able to queue thread plans from inside the methods of a
+    // Scripted Thread Plan.  Need a way to enforce that.
+
+SBThreadPlan
+SBThreadPlan::QueueThreadPlanForStepOverRange (SBAddress &sb_start_address,
+                                               lldb::addr_t size)
+{
+    if (m_opaque_sp)
+    {
+        Address *start_address = sb_start_address.get();
+        if (!start_address)
+        {
+            return SBThreadPlan();
+        }
+
+        AddressRange range (*start_address, size);
+        SymbolContext sc;
+        start_address->CalculateSymbolContext(&sc);
+        return SBThreadPlan (m_opaque_sp->GetThread().QueueThreadPlanForStepOverRange (false,
+                                                                                      range,
+                                                                                      sc,
+                                                                                      eAllThreads));
+    }
+    else
+    {
+        return SBThreadPlan();
+    }
+}
+
+SBThreadPlan
+SBThreadPlan::QueueThreadPlanForStepInRange (SBAddress &sb_start_address,
+                                               lldb::addr_t size)
+{
+    if (m_opaque_sp)
+    {
+        Address *start_address = sb_start_address.get();
+        if (!start_address)
+        {
+            return SBThreadPlan();
+        }
+
+        AddressRange range (*start_address, size);
+        SymbolContext sc;
+        start_address->CalculateSymbolContext(&sc);
+        return SBThreadPlan (m_opaque_sp->GetThread().QueueThreadPlanForStepInRange (false,
+                                                                                      range,
+                                                                                      sc,
+                                                                                      NULL,
+                                                                                      eAllThreads));
+    }
+    else
+    {
+        return SBThreadPlan();
+    }
+}
+
+SBThreadPlan
+SBThreadPlan::QueueThreadPlanForStepOut (uint32_t frame_idx_to_step_to, bool first_insn)
+{
+    if (m_opaque_sp)
+    {
+        SymbolContext sc;
+        sc = m_opaque_sp->GetThread().GetStackFrameAtIndex(0)->GetSymbolContext(lldb::eSymbolContextEverything);
+        return SBThreadPlan (m_opaque_sp->GetThread().QueueThreadPlanForStepOut (false,
+                                                                                 &sc,
+                                                                                 first_insn,
+                                                                                 false,
+                                                                                 eVoteYes,
+                                                                                 eVoteNoOpinion,
+                                                                                 frame_idx_to_step_to));
+    }
+    else
+    {
+        return SBThreadPlan();
+    }
+}
+
+SBThreadPlan
+SBThreadPlan::QueueThreadPlanForRunToAddress (SBAddress sb_address)
+{
+    if (m_opaque_sp)
+    {
+        Address *address = sb_address.get();
+        if (!address)
+            return SBThreadPlan();
+
+        return SBThreadPlan (m_opaque_sp->GetThread().QueueThreadPlanForRunToAddress (false,
+                                                                                      *address,
+                                                                                      false));
+    }
+    else
+    {
+        return SBThreadPlan();
+    }
+}
+
+