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