LLDB  mainline
ThreadPlanPython.cpp
Go to the documentation of this file.
1 //===-- ThreadPlanPython.cpp ----------------------------------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 
10 
11 #include "lldb/Core/Debugger.h"
14 #include "lldb/Target/Process.h"
16 #include "lldb/Target/Target.h"
17 #include "lldb/Target/Thread.h"
18 #include "lldb/Target/ThreadPlan.h"
20 #include "lldb/Utility/LLDBLog.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 // ThreadPlanPython
28 
29 ThreadPlanPython::ThreadPlanPython(Thread &thread, const char *class_name,
30  const StructuredDataImpl &args_data)
31  : ThreadPlan(ThreadPlan::eKindPython, "Python based Thread Plan", thread,
33  m_class_name(class_name), m_args_data(args_data), m_did_push(false),
34  m_stop_others(false) {
36  SetOkayToDiscard(true);
37  SetPrivate(false);
38 }
39 
41  if (!m_did_push)
42  return true;
43 
44  if (!m_implementation_sp) {
45  if (error)
46  error->Printf("Error constructing Python ThreadPlan: %s",
47  m_error_str.empty() ? "<unknown error>"
48  : m_error_str.c_str());
49  return false;
50  }
51 
52  return true;
53 }
54 
57 }
58 
60  // We set up the script side in DidPush, so that it can push other plans in
61  // the constructor, and doesn't have to care about the details of DidPush.
62  m_did_push = true;
63  if (!m_class_name.empty()) {
64  ScriptInterpreter *script_interp = GetScriptInterpreter();
65  if (script_interp) {
68  this->shared_from_this());
69  }
70  }
71 }
72 
74  Log *log = GetLog(LLDBLog::Thread);
75  LLDB_LOGF(log, "%s called on Python Thread Plan: %s )", LLVM_PRETTY_FUNCTION,
76  m_class_name.c_str());
77 
78  bool should_stop = true;
79  if (m_implementation_sp) {
80  ScriptInterpreter *script_interp = GetScriptInterpreter();
81  if (script_interp) {
82  bool script_error;
83  should_stop = script_interp->ScriptedThreadPlanShouldStop(
84  m_implementation_sp, event_ptr, script_error);
85  if (script_error)
86  SetPlanComplete(false);
87  }
88  }
89  return should_stop;
90 }
91 
93  Log *log = GetLog(LLDBLog::Thread);
94  LLDB_LOGF(log, "%s called on Python Thread Plan: %s )", LLVM_PRETTY_FUNCTION,
95  m_class_name.c_str());
96 
97  bool is_stale = true;
98  if (m_implementation_sp) {
99  ScriptInterpreter *script_interp = GetScriptInterpreter();
100  if (script_interp) {
101  bool script_error;
102  is_stale = script_interp->ScriptedThreadPlanIsStale(m_implementation_sp,
103  script_error);
104  if (script_error)
105  SetPlanComplete(false);
106  }
107  }
108  return is_stale;
109 }
110 
112  Log *log = GetLog(LLDBLog::Thread);
113  LLDB_LOGF(log, "%s called on Python Thread Plan: %s )", LLVM_PRETTY_FUNCTION,
114  m_class_name.c_str());
115 
116  bool explains_stop = true;
117  if (m_implementation_sp) {
118  ScriptInterpreter *script_interp = GetScriptInterpreter();
119  if (script_interp) {
120  bool script_error;
121  explains_stop = script_interp->ScriptedThreadPlanExplainsStop(
122  m_implementation_sp, event_ptr, script_error);
123  if (script_error)
124  SetPlanComplete(false);
125  }
126  }
127  return explains_stop;
128 }
129 
131  Log *log = GetLog(LLDBLog::Thread);
132  LLDB_LOGF(log, "%s called on Python Thread Plan: %s )", LLVM_PRETTY_FUNCTION,
133  m_class_name.c_str());
134  bool mischief_managed = true;
135  if (m_implementation_sp) {
136  // I don't really need mischief_managed, since it's simpler to just call
137  // SetPlanComplete in should_stop.
138  mischief_managed = IsPlanComplete();
139  if (mischief_managed)
140  m_implementation_sp.reset();
141  }
142  return mischief_managed;
143 }
144 
146  Log *log = GetLog(LLDBLog::Thread);
147  LLDB_LOGF(log, "%s called on Python Thread Plan: %s )", LLVM_PRETTY_FUNCTION,
148  m_class_name.c_str());
149  lldb::StateType run_state = eStateRunning;
150  if (m_implementation_sp) {
151  ScriptInterpreter *script_interp = GetScriptInterpreter();
152  if (script_interp) {
153  bool script_error;
154  run_state = script_interp->ScriptedThreadPlanGetRunState(
155  m_implementation_sp, script_error);
156  }
157  }
158  return run_state;
159 }
160 
161 // The ones below are not currently exported to Python.
163  s->Printf("Python thread plan implemented by class %s.",
164  m_class_name.c_str());
165 }
166 
168  Log *log = GetLog(LLDBLog::Thread);
169  LLDB_LOGF(log, "%s called on Python Thread Plan: %s )", LLVM_PRETTY_FUNCTION,
170  m_class_name.c_str());
171  return true;
172 }
lldb_private::ThreadPlanPython::GetPlanRunState
lldb::StateType GetPlanRunState() override
Definition: ThreadPlanPython.cpp:145
lldb_private::ThreadPlanPython::ShouldStop
bool ShouldStop(Event *event_ptr) override
Definition: ThreadPlanPython.cpp:73
lldb_private::Event
Definition: Event.h:182
lldb_private::ThreadPlan::IsPlanComplete
bool IsPlanComplete()
Definition: ThreadPlan.cpp:61
lldb_private::ScriptInterpreter::CreateScriptedThreadPlan
virtual StructuredData::ObjectSP CreateScriptedThreadPlan(const char *class_name, const StructuredDataImpl &args_data, std::string &error_str, lldb::ThreadPlanSP thread_plan_sp)
Definition: ScriptInterpreter.h:276
lldb_private::ThreadPlan::SetOkayToDiscard
void SetOkayToDiscard(bool value)
Definition: ThreadPlan.h:404
lldb_private::ThreadPlanPython::DidPush
void DidPush() override
Definition: ThreadPlanPython.cpp:59
lldb_private::ThreadPlanPython::WillStop
bool WillStop() override
Definition: ThreadPlanPython.cpp:167
LLDB_LOGF
#define LLDB_LOGF(log,...)
Definition: Log.h:343
lldb_private::Process::GetTarget
Target & GetTarget()
Get the target object pointer for this module.
Definition: Process.h:1206
lldb_private::eVoteNoOpinion
@ eVoteNoOpinion
Definition: lldb-private-enumerations.h:59
lldb_private::Stream
Definition: Stream.h:28
ThreadPlanPython.h
lldb_private::Target::GetDebugger
Debugger & GetDebugger()
Definition: Target.h:1019
Debugger.h
lldb_private::Debugger::GetScriptInterpreter
ScriptInterpreter * GetScriptInterpreter(bool can_create=true, llvm::Optional< lldb::ScriptLanguage > language={})
Definition: Debugger.cpp:1476
Process.h
lldb_private::ThreadPlan::SetIsControllingPlan
bool SetIsControllingPlan(bool value)
Definition: ThreadPlan.h:396
lldb_private::ScriptInterpreter::ScriptedThreadPlanGetRunState
virtual lldb::StateType ScriptedThreadPlanGetRunState(StructuredData::ObjectSP implementor_sp, bool &script_error)
Definition: ScriptInterpreter.h:305
Target.h
error
static llvm::raw_ostream & error(Stream &strm)
Definition: CommandReturnObject.cpp:17
lldb_private::ThreadPlan
Definition: ThreadPlan.h:287
lldb_private::ThreadPlanPython::MischiefManaged
bool MischiefManaged() override
Definition: ThreadPlanPython.cpp:130
lldb_private::ThreadPlanPython::ValidatePlan
bool ValidatePlan(Stream *error) override
Returns whether this plan could be successfully created.
Definition: ThreadPlanPython.cpp:40
lldb_private::ThreadPlanPython::m_error_str
std::string m_error_str
Definition: ThreadPlanPython.h:65
Log.h
lldb_private::ThreadPlanPython::GetDescription
void GetDescription(Stream *s, lldb::DescriptionLevel level) override
Print a description of this thread to the stream s.
Definition: ThreadPlanPython.cpp:162
lldb_private::Thread
Definition: Thread.h:61
lldb_private::LLDBLog::Thread
@ Thread
lldb_private::ThreadPlanPython::m_args_data
StructuredDataImpl m_args_data
Definition: ThreadPlanPython.h:64
lldb_private::ThreadPlanPython::DoPlanExplainsStop
bool DoPlanExplainsStop(Event *event_ptr) override
Definition: ThreadPlanPython.cpp:111
lldb_private::ThreadPlanPython::m_did_push
bool m_did_push
Definition: ThreadPlanPython.h:67
lldb_private::ThreadPlanPython::GetScriptInterpreter
ScriptInterpreter * GetScriptInterpreter()
Definition: ThreadPlanPython.cpp:55
lldb_private::StructuredDataImpl
Definition: StructuredDataImpl.h:26
Thread.h
lldb_private::ThreadPlan::SetPrivate
void SetPrivate(bool input)
Definition: ThreadPlan.h:417
ThreadPlan.h
lldb_private::ThreadPlan::SetPlanComplete
void SetPlanComplete(bool success=true)
Definition: ThreadPlan.cpp:66
lldb_private::ThreadPlanPython::IsPlanStale
bool IsPlanStale() override
Definition: ThreadPlanPython.cpp:92
lldb_private::ScriptInterpreter::ScriptedThreadPlanIsStale
virtual bool ScriptedThreadPlanIsStale(StructuredData::ObjectSP implementor_sp, bool &script_error)
Definition: ScriptInterpreter.h:298
lldb_private::ThreadPlanPython::m_class_name
std::string m_class_name
Definition: ThreadPlanPython.h:63
lldb_private::ScriptInterpreter
Definition: ScriptInterpreter.h:126
lldb_private::Stream::Printf
size_t Printf(const char *format,...) __attribute__((format(printf
Output printf formatted output to the stream.
Definition: Stream.cpp:107
lldb_private::ThreadPlanPython::m_implementation_sp
StructuredData::ObjectSP m_implementation_sp
Definition: ThreadPlanPython.h:66
lldb_private
A class that represents a running process on the host machine.
Definition: SBCommandInterpreterRunOptions.h:16
lldb_private::ScriptInterpreter::ScriptedThreadPlanExplainsStop
virtual bool ScriptedThreadPlanExplainsStop(StructuredData::ObjectSP implementor_sp, Event *event, bool &script_error)
Definition: ScriptInterpreter.h:284
CommandInterpreter.h
State.h
lldb::StateType
StateType
Process and Thread States.
Definition: lldb-enumerations.h:73
lldb_private::Log
Definition: Log.h:115
lldb_private::GetLog
Log * GetLog(Cat mask)
Retrieve the Log object for the channel associated with the given log enum.
Definition: Log.h:308
lldb_private::ThreadPlan::m_process
Process & m_process
Definition: ThreadPlan.h:528
ScriptInterpreter.h
lldb
Definition: SBAddress.h:15
lldb::eStateRunning
@ eStateRunning
Process or thread is running and can't be examined.
Definition: lldb-enumerations.h:85
RegisterContext.h
LLDBLog.h
lldb::DescriptionLevel
DescriptionLevel
Description levels for "void GetDescription(Stream *, DescriptionLevel)" calls.
Definition: lldb-enumerations.h:207
lldb_private::ScriptInterpreter::ScriptedThreadPlanShouldStop
virtual bool ScriptedThreadPlanShouldStop(StructuredData::ObjectSP implementor_sp, Event *event, bool &script_error)
Definition: ScriptInterpreter.h:291