contrib/llvm/tools/lldb/source/Target/ThreadPlanPython.cpp

   1 //===-- ThreadPlanPython.cpp ------------------------------------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #include "lldb/Target/ThreadPlan.h"
  11
  12 #include "lldb/Core/Debugger.h"
  13 #include "lldb/Interpreter/CommandInterpreter.h"
  14 #include "lldb/Interpreter/ScriptInterpreter.h"
  15 #include "lldb/Target/Process.h"
  16 #include "lldb/Target/RegisterContext.h"
  17 #include "lldb/Target/Target.h"
  18 #include "lldb/Target/Thread.h"
  19 #include "lldb/Target/ThreadPlan.h"
  20 #include "lldb/Target/ThreadPlanPython.h"
  21 #include "lldb/Utility/Log.h"
  22 #include "lldb/Utility/State.h"
  23
  24 using namespace lldb;
  25 using namespace lldb_private;
  26
  27 //----------------------------------------------------------------------
  28 // ThreadPlanPython
  29 //----------------------------------------------------------------------
  30
  31 ThreadPlanPython::ThreadPlanPython(Thread &thread, const char *class_name)
  32     : ThreadPlan(ThreadPlan::eKindPython, "Python based Thread Plan", thread,
  33                  eVoteNoOpinion, eVoteNoOpinion),
  34       m_class_name(class_name), m_did_push(false) {
  35   SetIsMasterPlan(true);
  36   SetOkayToDiscard(true);
  37   SetPrivate(false);
  38 }
  39
  40 ThreadPlanPython::~ThreadPlanPython() {
  41   // FIXME, do I need to decrement the ref count on this implementation object
  42   // to make it go away?
  43 }
  44
  45 bool ThreadPlanPython::ValidatePlan(Stream *error) {
  46   if (!m_did_push)
  47     return true;
  48
  49   if (!m_implementation_sp) {
  50     if (error)
  51       error->Printf("Python thread plan does not have an implementation");
  52     return false;
  53   }
  54
  55   return true;
  56 }
  57
  58 void ThreadPlanPython::DidPush() {
  59   // We set up the script side in DidPush, so that it can push other plans in
  60   // the constructor, and doesn't have to care about the details of DidPush.
  61   m_did_push = true;
  62   if (!m_class_name.empty()) {
  63     ScriptInterpreter *script_interp = m_thread.GetProcess()
  64                                            ->GetTarget()
  65                                            .GetDebugger()
  66                                            .GetCommandInterpreter()
  67                                            .GetScriptInterpreter();
  68     if (script_interp) {
  69       m_implementation_sp = script_interp->CreateScriptedThreadPlan(
  70           m_class_name.c_str(), this->shared_from_this());
  71     }
  72   }
  73 }
  74
  75 bool ThreadPlanPython::ShouldStop(Event *event_ptr) {
  76   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_THREAD));
  77   if (log)
  78     log->Printf("%s called on Python Thread Plan: %s )", LLVM_PRETTY_FUNCTION,
  79                 m_class_name.c_str());
  80
  81   bool should_stop = true;
  82   if (m_implementation_sp) {
  83     ScriptInterpreter *script_interp = m_thread.GetProcess()
  84                                            ->GetTarget()
  85                                            .GetDebugger()
  86                                            .GetCommandInterpreter()
  87                                            .GetScriptInterpreter();
  88     if (script_interp) {
  89       bool script_error;
  90       should_stop = script_interp->ScriptedThreadPlanShouldStop(
  91           m_implementation_sp, event_ptr, script_error);
  92       if (script_error)
  93         SetPlanComplete(false);
  94     }
  95   }
  96   return should_stop;
  97 }
  98
  99 bool ThreadPlanPython::IsPlanStale() {
 100   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_THREAD));
 101   if (log)
 102     log->Printf("%s called on Python Thread Plan: %s )", LLVM_PRETTY_FUNCTION,
 103                 m_class_name.c_str());
 104
 105   bool is_stale = true;
 106   if (m_implementation_sp) {
 107     ScriptInterpreter *script_interp = m_thread.GetProcess()
 108                                            ->GetTarget()
 109                                            .GetDebugger()
 110                                            .GetCommandInterpreter()
 111                                            .GetScriptInterpreter();
 112     if (script_interp) {
 113       bool script_error;
 114       is_stale = script_interp->ScriptedThreadPlanIsStale(m_implementation_sp,
 115                                                           script_error);
 116       if (script_error)
 117         SetPlanComplete(false);
 118     }
 119   }
 120   return is_stale;
 121 }
 122
 123 bool ThreadPlanPython::DoPlanExplainsStop(Event *event_ptr) {
 124   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_THREAD));
 125   if (log)
 126     log->Printf("%s called on Python Thread Plan: %s )", LLVM_PRETTY_FUNCTION,
 127                 m_class_name.c_str());
 128
 129   bool explains_stop = true;
 130   if (m_implementation_sp) {
 131     ScriptInterpreter *script_interp = m_thread.GetProcess()
 132                                            ->GetTarget()
 133                                            .GetDebugger()
 134                                            .GetCommandInterpreter()
 135                                            .GetScriptInterpreter();
 136     if (script_interp) {
 137       bool script_error;
 138       explains_stop = script_interp->ScriptedThreadPlanExplainsStop(
 139           m_implementation_sp, event_ptr, script_error);
 140       if (script_error)
 141         SetPlanComplete(false);
 142     }
 143   }
 144   return explains_stop;
 145 }
 146
 147 bool ThreadPlanPython::MischiefManaged() {
 148   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_THREAD));
 149   if (log)
 150     log->Printf("%s called on Python Thread Plan: %s )", LLVM_PRETTY_FUNCTION,
 151                 m_class_name.c_str());
 152   bool mischief_managed = true;
 153   if (m_implementation_sp) {
 154     // I don't really need mischief_managed, since it's simpler to just call
 155     // SetPlanComplete in should_stop.
 156     mischief_managed = IsPlanComplete();
 157     if (mischief_managed)
 158       m_implementation_sp.reset();
 159   }
 160   return mischief_managed;
 161 }
 162
 163 lldb::StateType ThreadPlanPython::GetPlanRunState() {
 164   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_THREAD));
 165   if (log)
 166     log->Printf("%s called on Python Thread Plan: %s )", LLVM_PRETTY_FUNCTION,
 167                 m_class_name.c_str());
 168   lldb::StateType run_state = eStateRunning;
 169   if (m_implementation_sp) {
 170     ScriptInterpreter *script_interp = m_thread.GetProcess()
 171                                            ->GetTarget()
 172                                            .GetDebugger()
 173                                            .GetCommandInterpreter()
 174                                            .GetScriptInterpreter();
 175     if (script_interp) {
 176       bool script_error;
 177       run_state = script_interp->ScriptedThreadPlanGetRunState(
 178           m_implementation_sp, script_error);
 179     }
 180   }
 181   return run_state;
 182 }
 183
 184 // The ones below are not currently exported to Python.
 185
 186 bool ThreadPlanPython::StopOthers() {
 187   // For now Python plans run all threads, but we should add some controls for
 188   // this.
 189   return false;
 190 }
 191
 192 void ThreadPlanPython::GetDescription(Stream *s, lldb::DescriptionLevel level) {
 193   s->Printf("Python thread plan implemented by class %s.",
 194             m_class_name.c_str());
 195 }
 196
 197 bool ThreadPlanPython::WillStop() {
 198   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_THREAD));
 199   if (log)
 200     log->Printf("%s called on Python Thread Plan: %s )", LLVM_PRETTY_FUNCTION,
 201                 m_class_name.c_str());
 202   return true;
 203 }