1 //===-- ScriptInterpreterPython.cpp -----------------------------*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 #ifdef LLDB_DISABLE_PYTHON
12 // Python is disabled in this build
16 // LLDB Python header must be included first
17 #include "lldb-python.h"
19 #include "PythonDataObjects.h"
20 #include "PythonExceptionState.h"
21 #include "ScriptInterpreterPython.h"
29 #include "lldb/API/SBValue.h"
30 #include "lldb/Breakpoint/BreakpointLocation.h"
31 #include "lldb/Breakpoint/StoppointCallbackContext.h"
32 #include "lldb/Breakpoint/WatchpointOptions.h"
33 #include "lldb/Core/Communication.h"
34 #include "lldb/Core/Debugger.h"
35 #include "lldb/Core/PluginManager.h"
36 #include "lldb/Core/ValueObject.h"
37 #include "lldb/DataFormatters/TypeSummary.h"
38 #include "lldb/Host/ConnectionFileDescriptor.h"
39 #include "lldb/Host/FileSystem.h"
40 #include "lldb/Host/HostInfo.h"
41 #include "lldb/Host/Pipe.h"
42 #include "lldb/Interpreter/CommandInterpreter.h"
43 #include "lldb/Interpreter/CommandReturnObject.h"
44 #include "lldb/Target/Thread.h"
45 #include "lldb/Target/ThreadPlan.h"
46 #include "lldb/Utility/Timer.h"
49 #include "lldb/Host/windows/ConnectionGenericFileWindows.h"
52 #include "llvm/ADT/STLExtras.h"
53 #include "llvm/ADT/StringRef.h"
54 #include "llvm/Support/FileSystem.h"
57 using namespace lldb_private;
59 static ScriptInterpreterPython::SWIGInitCallback g_swig_init_callback = nullptr;
60 static ScriptInterpreterPython::SWIGBreakpointCallbackFunction
61 g_swig_breakpoint_callback = nullptr;
62 static ScriptInterpreterPython::SWIGWatchpointCallbackFunction
63 g_swig_watchpoint_callback = nullptr;
64 static ScriptInterpreterPython::SWIGPythonTypeScriptCallbackFunction
65 g_swig_typescript_callback = nullptr;
66 static ScriptInterpreterPython::SWIGPythonCreateSyntheticProvider
67 g_swig_synthetic_script = nullptr;
68 static ScriptInterpreterPython::SWIGPythonCreateCommandObject
69 g_swig_create_cmd = nullptr;
70 static ScriptInterpreterPython::SWIGPythonCalculateNumChildren
71 g_swig_calc_children = nullptr;
72 static ScriptInterpreterPython::SWIGPythonGetChildAtIndex
73 g_swig_get_child_index = nullptr;
74 static ScriptInterpreterPython::SWIGPythonGetIndexOfChildWithName
75 g_swig_get_index_child = nullptr;
76 static ScriptInterpreterPython::SWIGPythonCastPyObjectToSBValue
77 g_swig_cast_to_sbvalue = nullptr;
78 static ScriptInterpreterPython::SWIGPythonGetValueObjectSPFromSBValue
79 g_swig_get_valobj_sp_from_sbvalue = nullptr;
80 static ScriptInterpreterPython::SWIGPythonUpdateSynthProviderInstance
81 g_swig_update_provider = nullptr;
82 static ScriptInterpreterPython::SWIGPythonMightHaveChildrenSynthProviderInstance
83 g_swig_mighthavechildren_provider = nullptr;
84 static ScriptInterpreterPython::SWIGPythonGetValueSynthProviderInstance
85 g_swig_getvalue_provider = nullptr;
86 static ScriptInterpreterPython::SWIGPythonCallCommand g_swig_call_command =
88 static ScriptInterpreterPython::SWIGPythonCallCommandObject
89 g_swig_call_command_object = nullptr;
90 static ScriptInterpreterPython::SWIGPythonCallModuleInit
91 g_swig_call_module_init = nullptr;
92 static ScriptInterpreterPython::SWIGPythonCreateOSPlugin
93 g_swig_create_os_plugin = nullptr;
94 static ScriptInterpreterPython::SWIGPythonScriptKeyword_Process
95 g_swig_run_script_keyword_process = nullptr;
96 static ScriptInterpreterPython::SWIGPythonScriptKeyword_Thread
97 g_swig_run_script_keyword_thread = nullptr;
98 static ScriptInterpreterPython::SWIGPythonScriptKeyword_Target
99 g_swig_run_script_keyword_target = nullptr;
100 static ScriptInterpreterPython::SWIGPythonScriptKeyword_Frame
101 g_swig_run_script_keyword_frame = nullptr;
102 static ScriptInterpreterPython::SWIGPythonScriptKeyword_Value
103 g_swig_run_script_keyword_value = nullptr;
104 static ScriptInterpreterPython::SWIGPython_GetDynamicSetting g_swig_plugin_get =
106 static ScriptInterpreterPython::SWIGPythonCreateScriptedThreadPlan
107 g_swig_thread_plan_script = nullptr;
108 static ScriptInterpreterPython::SWIGPythonCallThreadPlan
109 g_swig_call_thread_plan = nullptr;
111 static bool g_initialized = false;
115 // Initializing Python is not a straightforward process. We cannot control what
116 // external code may have done before getting to this point in LLDB, including
117 // potentially having already initialized Python, so we need to do a lot of work
118 // to ensure that the existing state of the system is maintained across our
119 // initialization. We do this by using an RAII pattern where we save off
121 // state at the beginning, and restore it at the end
122 struct InitializePythonRAII {
124 InitializePythonRAII()
125 : m_gil_state(PyGILState_UNLOCKED), m_was_already_initialized(false) {
126 // Python will muck with STDIN terminal state, so save off any current TTY
127 // settings so we can restore them.
128 m_stdin_tty_state.Save(STDIN_FILENO, false);
130 InitializePythonHome();
132 // Python < 3.2 and Python >= 3.2 reversed the ordering requirements for
133 // calling `Py_Initialize` and `PyEval_InitThreads`. < 3.2 requires that you
134 // call `PyEval_InitThreads` first, and >= 3.2 requires that you call it last.
135 #if (PY_MAJOR_VERSION == 3 && PY_MINOR_VERSION >= 2) || (PY_MAJOR_VERSION > 3)
137 InitializeThreadsPrivate();
139 InitializeThreadsPrivate();
144 ~InitializePythonRAII() {
145 if (m_was_already_initialized) {
146 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_SCRIPT));
147 LLDB_LOGV(log, "Releasing PyGILState. Returning to state = {0}locked",
148 m_was_already_initialized == PyGILState_UNLOCKED ? "un" : "");
149 PyGILState_Release(m_gil_state);
151 // We initialized the threads in this function, just unlock the GIL.
155 m_stdin_tty_state.Restore();
159 void InitializePythonHome() {
160 #if defined(LLDB_PYTHON_HOME)
161 #if PY_MAJOR_VERSION >= 3
163 static wchar_t *g_python_home = Py_DecodeLocale(LLDB_PYTHON_HOME, &size);
165 static char g_python_home[] = LLDB_PYTHON_HOME;
167 Py_SetPythonHome(g_python_home);
171 void InitializeThreadsPrivate() {
172 if (PyEval_ThreadsInitialized()) {
173 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_SCRIPT));
175 m_was_already_initialized = true;
176 m_gil_state = PyGILState_Ensure();
177 LLDB_LOGV(log, "Ensured PyGILState. Previous state = {0}locked\n",
178 m_gil_state == PyGILState_UNLOCKED ? "un" : "");
182 // InitThreads acquires the GIL if it hasn't been called before.
183 PyEval_InitThreads();
186 TerminalState m_stdin_tty_state;
187 PyGILState_STATE m_gil_state;
188 bool m_was_already_initialized;
192 ScriptInterpreterPython::Locker::Locker(ScriptInterpreterPython *py_interpreter,
193 uint16_t on_entry, uint16_t on_leave,
194 FILE *in, FILE *out, FILE *err)
195 : ScriptInterpreterLocker(),
196 m_teardown_session((on_leave & TearDownSession) == TearDownSession),
197 m_python_interpreter(py_interpreter) {
199 if ((on_entry & InitSession) == InitSession) {
200 if (DoInitSession(on_entry, in, out, err) == false) {
201 // Don't teardown the session if we didn't init it.
202 m_teardown_session = false;
207 bool ScriptInterpreterPython::Locker::DoAcquireLock() {
208 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_SCRIPT));
209 m_GILState = PyGILState_Ensure();
210 LLDB_LOGV(log, "Ensured PyGILState. Previous state = {0}locked",
211 m_GILState == PyGILState_UNLOCKED ? "un" : "");
213 // we need to save the thread state when we first start the command
214 // because we might decide to interrupt it while some action is taking
215 // place outside of Python (e.g. printing to screen, waiting for the network,
217 // in that case, _PyThreadState_Current will be NULL - and we would be unable
218 // to set the asynchronous exception - not a desirable situation
219 m_python_interpreter->SetThreadState(PyThreadState_Get());
220 m_python_interpreter->IncrementLockCount();
224 bool ScriptInterpreterPython::Locker::DoInitSession(uint16_t on_entry_flags,
227 if (!m_python_interpreter)
229 return m_python_interpreter->EnterSession(on_entry_flags, in, out, err);
232 bool ScriptInterpreterPython::Locker::DoFreeLock() {
233 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_SCRIPT));
234 LLDB_LOGV(log, "Releasing PyGILState. Returning to state = {0}locked",
235 m_GILState == PyGILState_UNLOCKED ? "un" : "");
236 PyGILState_Release(m_GILState);
237 m_python_interpreter->DecrementLockCount();
241 bool ScriptInterpreterPython::Locker::DoTearDownSession() {
242 if (!m_python_interpreter)
244 m_python_interpreter->LeaveSession();
248 ScriptInterpreterPython::Locker::~Locker() {
249 if (m_teardown_session)
254 ScriptInterpreterPython::ScriptInterpreterPython(
255 CommandInterpreter &interpreter)
256 : ScriptInterpreter(interpreter, eScriptLanguagePython),
257 IOHandlerDelegateMultiline("DONE"), m_saved_stdin(), m_saved_stdout(),
258 m_saved_stderr(), m_main_module(), m_lldb_module(),
259 m_session_dict(PyInitialValue::Invalid),
260 m_sys_module_dict(PyInitialValue::Invalid), m_run_one_line_function(),
261 m_run_one_line_str_global(),
263 interpreter.GetDebugger().GetInstanceName().AsCString()),
264 m_terminal_state(), m_active_io_handler(eIOHandlerNone),
265 m_session_is_active(false), m_pty_slave_is_open(false),
266 m_valid_session(true), m_lock_count(0), m_command_thread_state(nullptr) {
269 m_dictionary_name.append("_dict");
270 StreamString run_string;
271 run_string.Printf("%s = dict()", m_dictionary_name.c_str());
273 Locker locker(this, ScriptInterpreterPython::Locker::AcquireLock,
274 ScriptInterpreterPython::Locker::FreeAcquiredLock);
275 PyRun_SimpleString(run_string.GetData());
279 "run_one_line (%s, 'import copy, keyword, os, re, sys, uuid, lldb')",
280 m_dictionary_name.c_str());
281 PyRun_SimpleString(run_string.GetData());
283 // Reloading modules requires a different syntax in Python 2 and Python 3.
285 // a consistent syntax no matter what version of Python.
287 run_string.Printf("run_one_line (%s, 'from six.moves import reload_module')",
288 m_dictionary_name.c_str());
289 PyRun_SimpleString(run_string.GetData());
291 // WARNING: temporary code that loads Cocoa formatters - this should be done
292 // on a per-platform basis rather than loading the whole set
293 // and letting the individual formatter classes exploit APIs to check whether
294 // they can/cannot do their task
297 "run_one_line (%s, 'import lldb.formatters, lldb.formatters.cpp, pydoc')",
298 m_dictionary_name.c_str());
299 PyRun_SimpleString(run_string.GetData());
302 run_string.Printf("run_one_line (%s, 'import lldb.embedded_interpreter; from "
303 "lldb.embedded_interpreter import run_python_interpreter; "
304 "from lldb.embedded_interpreter import run_one_line')",
305 m_dictionary_name.c_str());
306 PyRun_SimpleString(run_string.GetData());
309 run_string.Printf("run_one_line (%s, 'lldb.debugger_unique_id = %" PRIu64
310 "; pydoc.pager = pydoc.plainpager')",
311 m_dictionary_name.c_str(),
312 interpreter.GetDebugger().GetID());
313 PyRun_SimpleString(run_string.GetData());
316 ScriptInterpreterPython::~ScriptInterpreterPython() {
317 // the session dictionary may hold objects with complex state
318 // which means that they may need to be torn down with some level of smarts
319 // and that, in turn, requires a valid thread state
320 // force Python to procure itself such a thread state, nuke the session
322 // and then release it for others to use and proceed with the rest of the
324 auto gil_state = PyGILState_Ensure();
325 m_session_dict.Reset();
326 PyGILState_Release(gil_state);
329 void ScriptInterpreterPython::Initialize() {
330 static llvm::once_flag g_once_flag;
332 llvm::call_once(g_once_flag, []() {
333 PluginManager::RegisterPlugin(GetPluginNameStatic(),
334 GetPluginDescriptionStatic(),
335 lldb::eScriptLanguagePython, CreateInstance);
339 void ScriptInterpreterPython::Terminate() {}
341 lldb::ScriptInterpreterSP
342 ScriptInterpreterPython::CreateInstance(CommandInterpreter &interpreter) {
343 return std::make_shared<ScriptInterpreterPython>(interpreter);
346 lldb_private::ConstString ScriptInterpreterPython::GetPluginNameStatic() {
347 static ConstString g_name("script-python");
351 const char *ScriptInterpreterPython::GetPluginDescriptionStatic() {
352 return "Embedded Python interpreter";
355 lldb_private::ConstString ScriptInterpreterPython::GetPluginName() {
356 return GetPluginNameStatic();
359 uint32_t ScriptInterpreterPython::GetPluginVersion() { return 1; }
361 void ScriptInterpreterPython::IOHandlerActivated(IOHandler &io_handler) {
362 const char *instructions = nullptr;
364 switch (m_active_io_handler) {
367 case eIOHandlerBreakpoint:
368 instructions = R"(Enter your Python command(s). Type 'DONE' to end.
369 def function (frame, bp_loc, internal_dict):
370 """frame: the lldb.SBFrame for the location at which you stopped
371 bp_loc: an lldb.SBBreakpointLocation for the breakpoint location information
372 internal_dict: an LLDB support object not to be used"""
375 case eIOHandlerWatchpoint:
376 instructions = "Enter your Python command(s). Type 'DONE' to end.\n";
381 StreamFileSP output_sp(io_handler.GetOutputStreamFile());
383 output_sp->PutCString(instructions);
389 void ScriptInterpreterPython::IOHandlerInputComplete(IOHandler &io_handler,
391 io_handler.SetIsDone(true);
392 bool batch_mode = m_interpreter.GetBatchCommandMode();
394 switch (m_active_io_handler) {
397 case eIOHandlerBreakpoint: {
398 std::vector<BreakpointOptions *> *bp_options_vec =
399 (std::vector<BreakpointOptions *> *)io_handler.GetUserData();
400 for (auto bp_options : *bp_options_vec) {
404 auto data_ap = llvm::make_unique<CommandDataPython>();
407 data_ap->user_source.SplitIntoLines(data);
409 if (GenerateBreakpointCommandCallbackData(data_ap->user_source,
410 data_ap->script_source)
412 auto baton_sp = std::make_shared<BreakpointOptions::CommandBaton>(
414 bp_options->SetCallback(
415 ScriptInterpreterPython::BreakpointCallbackFunction, baton_sp);
416 } else if (!batch_mode) {
417 StreamFileSP error_sp = io_handler.GetErrorStreamFile();
419 error_sp->Printf("Warning: No command attached to breakpoint.\n");
424 m_active_io_handler = eIOHandlerNone;
426 case eIOHandlerWatchpoint: {
427 WatchpointOptions *wp_options =
428 (WatchpointOptions *)io_handler.GetUserData();
429 auto data_ap = llvm::make_unique<WatchpointOptions::CommandData>();
430 data_ap->user_source.SplitIntoLines(data);
432 if (GenerateWatchpointCommandCallbackData(data_ap->user_source,
433 data_ap->script_source)) {
435 std::make_shared<WatchpointOptions::CommandBaton>(std::move(data_ap));
436 wp_options->SetCallback(
437 ScriptInterpreterPython::WatchpointCallbackFunction, baton_sp);
438 } else if (!batch_mode) {
439 StreamFileSP error_sp = io_handler.GetErrorStreamFile();
441 error_sp->Printf("Warning: No command attached to breakpoint.\n");
445 m_active_io_handler = eIOHandlerNone;
450 void ScriptInterpreterPython::ResetOutputFileHandle(FILE *fh) {}
452 void ScriptInterpreterPython::SaveTerminalState(int fd) {
453 // Python mucks with the terminal state of STDIN. If we can possibly avoid
454 // this by setting the file handles up correctly prior to entering the
455 // interpreter we should. For now we save and restore the terminal state
456 // on the input file handle.
457 m_terminal_state.Save(fd, false);
460 void ScriptInterpreterPython::RestoreTerminalState() {
461 // Python mucks with the terminal state of STDIN. If we can possibly avoid
462 // this by setting the file handles up correctly prior to entering the
463 // interpreter we should. For now we save and restore the terminal state
464 // on the input file handle.
465 m_terminal_state.Restore();
468 void ScriptInterpreterPython::LeaveSession() {
469 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_SCRIPT));
471 log->PutCString("ScriptInterpreterPython::LeaveSession()");
473 // checking that we have a valid thread state - since we use our own threading
475 // in some (rare) cases during cleanup Python may end up believing we have no
477 // and PyImport_AddModule will crash if that is the case - since that seems to
479 // when destroying the SBDebugger, we can make do without clearing up stdout
482 // rdar://problem/11292882
483 // When the current thread state is NULL, PyThreadState_Get() issues a fatal
485 if (PyThreadState_GetDict()) {
486 PythonDictionary &sys_module_dict = GetSysModuleDictionary();
487 if (sys_module_dict.IsValid()) {
488 if (m_saved_stdin.IsValid()) {
489 sys_module_dict.SetItemForKey(PythonString("stdin"), m_saved_stdin);
490 m_saved_stdin.Reset();
492 if (m_saved_stdout.IsValid()) {
493 sys_module_dict.SetItemForKey(PythonString("stdout"), m_saved_stdout);
494 m_saved_stdout.Reset();
496 if (m_saved_stderr.IsValid()) {
497 sys_module_dict.SetItemForKey(PythonString("stderr"), m_saved_stderr);
498 m_saved_stderr.Reset();
503 m_session_is_active = false;
506 bool ScriptInterpreterPython::SetStdHandle(File &file, const char *py_name,
507 PythonFile &save_file,
509 if (file.IsValid()) {
510 // Flush the file before giving it to python to avoid interleaved output.
513 PythonDictionary &sys_module_dict = GetSysModuleDictionary();
515 save_file = sys_module_dict.GetItemForKey(PythonString(py_name))
516 .AsType<PythonFile>();
518 PythonFile new_file(file, mode);
519 sys_module_dict.SetItemForKey(PythonString(py_name), new_file);
526 bool ScriptInterpreterPython::EnterSession(uint16_t on_entry_flags, FILE *in,
527 FILE *out, FILE *err) {
528 // If we have already entered the session, without having officially 'left'
529 // it, then there is no need to
531 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_SCRIPT));
532 if (m_session_is_active) {
535 "ScriptInterpreterPython::EnterSession(on_entry_flags=0x%" PRIx16
536 ") session is already active, returning without doing anything",
543 "ScriptInterpreterPython::EnterSession(on_entry_flags=0x%" PRIx16 ")",
546 m_session_is_active = true;
548 StreamString run_string;
550 if (on_entry_flags & Locker::InitGlobals) {
551 run_string.Printf("run_one_line (%s, 'lldb.debugger_unique_id = %" PRIu64,
552 m_dictionary_name.c_str(),
553 GetCommandInterpreter().GetDebugger().GetID());
555 "; lldb.debugger = lldb.SBDebugger.FindDebuggerWithID (%" PRIu64 ")",
556 GetCommandInterpreter().GetDebugger().GetID());
557 run_string.PutCString("; lldb.target = lldb.debugger.GetSelectedTarget()");
558 run_string.PutCString("; lldb.process = lldb.target.GetProcess()");
559 run_string.PutCString("; lldb.thread = lldb.process.GetSelectedThread ()");
560 run_string.PutCString("; lldb.frame = lldb.thread.GetSelectedFrame ()");
561 run_string.PutCString("')");
563 // If we aren't initing the globals, we should still always set the debugger
564 // (since that is always unique.)
565 run_string.Printf("run_one_line (%s, 'lldb.debugger_unique_id = %" PRIu64,
566 m_dictionary_name.c_str(),
567 GetCommandInterpreter().GetDebugger().GetID());
569 "; lldb.debugger = lldb.SBDebugger.FindDebuggerWithID (%" PRIu64 ")",
570 GetCommandInterpreter().GetDebugger().GetID());
571 run_string.PutCString("')");
574 PyRun_SimpleString(run_string.GetData());
577 PythonDictionary &sys_module_dict = GetSysModuleDictionary();
578 if (sys_module_dict.IsValid()) {
579 File in_file(in, false);
580 File out_file(out, false);
581 File err_file(err, false);
583 lldb::StreamFileSP in_sp;
584 lldb::StreamFileSP out_sp;
585 lldb::StreamFileSP err_sp;
586 if (!in_file.IsValid() || !out_file.IsValid() || !err_file.IsValid())
587 m_interpreter.GetDebugger().AdoptTopIOHandlerFilesIfInvalid(in_sp, out_sp,
590 if (on_entry_flags & Locker::NoSTDIN) {
591 m_saved_stdin.Reset();
593 if (!SetStdHandle(in_file, "stdin", m_saved_stdin, "r")) {
595 SetStdHandle(in_sp->GetFile(), "stdin", m_saved_stdin, "r");
599 if (!SetStdHandle(out_file, "stdout", m_saved_stdout, "w")) {
601 SetStdHandle(out_sp->GetFile(), "stdout", m_saved_stdout, "w");
604 if (!SetStdHandle(err_file, "stderr", m_saved_stderr, "w")) {
606 SetStdHandle(err_sp->GetFile(), "stderr", m_saved_stderr, "w");
610 if (PyErr_Occurred())
616 PythonObject &ScriptInterpreterPython::GetMainModule() {
617 if (!m_main_module.IsValid())
618 m_main_module.Reset(PyRefType::Borrowed, PyImport_AddModule("__main__"));
619 return m_main_module;
622 PythonDictionary &ScriptInterpreterPython::GetSessionDictionary() {
623 if (m_session_dict.IsValid())
624 return m_session_dict;
626 PythonObject &main_module = GetMainModule();
627 if (!main_module.IsValid())
628 return m_session_dict;
630 PythonDictionary main_dict(PyRefType::Borrowed,
631 PyModule_GetDict(main_module.get()));
632 if (!main_dict.IsValid())
633 return m_session_dict;
635 PythonObject item = main_dict.GetItemForKey(PythonString(m_dictionary_name));
636 m_session_dict.Reset(PyRefType::Borrowed, item.get());
637 return m_session_dict;
640 PythonDictionary &ScriptInterpreterPython::GetSysModuleDictionary() {
641 if (m_sys_module_dict.IsValid())
642 return m_sys_module_dict;
644 PythonObject sys_module(PyRefType::Borrowed, PyImport_AddModule("sys"));
645 if (sys_module.IsValid())
646 m_sys_module_dict.Reset(PyRefType::Borrowed,
647 PyModule_GetDict(sys_module.get()));
648 return m_sys_module_dict;
651 static std::string GenerateUniqueName(const char *base_name_wanted,
652 uint32_t &functions_counter,
653 const void *name_token = nullptr) {
656 if (!base_name_wanted)
657 return std::string();
660 sstr.Printf("%s_%d", base_name_wanted, functions_counter++);
662 sstr.Printf("%s_%p", base_name_wanted, name_token);
664 return sstr.GetString();
667 bool ScriptInterpreterPython::GetEmbeddedInterpreterModuleObjects() {
668 if (m_run_one_line_function.IsValid())
671 PythonObject module(PyRefType::Borrowed,
672 PyImport_AddModule("lldb.embedded_interpreter"));
673 if (!module.IsValid())
676 PythonDictionary module_dict(PyRefType::Borrowed,
677 PyModule_GetDict(module.get()));
678 if (!module_dict.IsValid())
681 m_run_one_line_function =
682 module_dict.GetItemForKey(PythonString("run_one_line"));
683 m_run_one_line_str_global =
684 module_dict.GetItemForKey(PythonString("g_run_one_line_str"));
685 return m_run_one_line_function.IsValid();
688 static void ReadThreadBytesReceived(void *baton, const void *src,
690 if (src && src_len) {
691 Stream *strm = (Stream *)baton;
692 strm->Write(src, src_len);
697 bool ScriptInterpreterPython::ExecuteOneLine(
698 const char *command, CommandReturnObject *result,
699 const ExecuteScriptOptions &options) {
700 if (!m_valid_session)
703 if (command && command[0]) {
704 // We want to call run_one_line, passing in the dictionary and the command
705 // string. We cannot do this through
706 // PyRun_SimpleString here because the command string may contain escaped
707 // characters, and putting it inside
708 // another string to pass to PyRun_SimpleString messes up the escaping. So
709 // we use the following more complicated
710 // method to pass the command string directly down to Python.
711 Debugger &debugger = m_interpreter.GetDebugger();
713 StreamFileSP input_file_sp;
714 StreamFileSP output_file_sp;
715 StreamFileSP error_file_sp;
716 Communication output_comm(
717 "lldb.ScriptInterpreterPython.ExecuteOneLine.comm");
718 bool join_read_thread = false;
719 if (options.GetEnableIO()) {
721 input_file_sp = debugger.GetInputFile();
722 // Set output to a temporary file so we can forward the results on to
726 Status pipe_result = pipe.CreateNew(false);
727 if (pipe_result.Success()) {
729 lldb::file_t read_file = pipe.GetReadNativeHandle();
730 pipe.ReleaseReadFileDescriptor();
731 std::unique_ptr<ConnectionGenericFile> conn_ap(
732 new ConnectionGenericFile(read_file, true));
734 std::unique_ptr<ConnectionFileDescriptor> conn_ap(
735 new ConnectionFileDescriptor(pipe.ReleaseReadFileDescriptor(),
738 if (conn_ap->IsConnected()) {
739 output_comm.SetConnection(conn_ap.release());
740 output_comm.SetReadThreadBytesReceivedCallback(
741 ReadThreadBytesReceived, &result->GetOutputStream());
742 output_comm.StartReadThread();
743 join_read_thread = true;
744 FILE *outfile_handle =
745 fdopen(pipe.ReleaseWriteFileDescriptor(), "w");
746 output_file_sp.reset(new StreamFile(outfile_handle, true));
747 error_file_sp = output_file_sp;
749 ::setbuf(outfile_handle, nullptr);
751 result->SetImmediateOutputFile(
752 debugger.GetOutputFile()->GetFile().GetStream());
753 result->SetImmediateErrorFile(
754 debugger.GetErrorFile()->GetFile().GetStream());
758 if (!input_file_sp || !output_file_sp || !error_file_sp)
759 debugger.AdoptTopIOHandlerFilesIfInvalid(input_file_sp, output_file_sp,
762 input_file_sp.reset(new StreamFile());
763 input_file_sp->GetFile().Open(FileSystem::DEV_NULL,
764 File::eOpenOptionRead);
765 output_file_sp.reset(new StreamFile());
766 output_file_sp->GetFile().Open(FileSystem::DEV_NULL,
767 File::eOpenOptionWrite);
768 error_file_sp = output_file_sp;
771 FILE *in_file = input_file_sp->GetFile().GetStream();
772 FILE *out_file = output_file_sp->GetFile().GetStream();
773 FILE *err_file = error_file_sp->GetFile().GetStream();
774 bool success = false;
776 // WARNING! It's imperative that this RAII scope be as tight as possible.
777 // In particular, the
778 // scope must end *before* we try to join the read thread. The reason for
780 // pre-requisite for joining the read thread is that we close the write
781 // handle (to break the
782 // pipe and cause it to wake up and exit). But acquiring the GIL as below
783 // will redirect Python's
784 // stdio to use this same handle. If we close the handle while Python is
785 // still using it, bad
786 // things will happen.
789 ScriptInterpreterPython::Locker::AcquireLock |
790 ScriptInterpreterPython::Locker::InitSession |
791 (options.GetSetLLDBGlobals()
792 ? ScriptInterpreterPython::Locker::InitGlobals
794 ((result && result->GetInteractive()) ? 0 : Locker::NoSTDIN),
795 ScriptInterpreterPython::Locker::FreeAcquiredLock |
796 ScriptInterpreterPython::Locker::TearDownSession,
797 in_file, out_file, err_file);
799 // Find the correct script interpreter dictionary in the main module.
800 PythonDictionary &session_dict = GetSessionDictionary();
801 if (session_dict.IsValid()) {
802 if (GetEmbeddedInterpreterModuleObjects()) {
803 if (PyCallable_Check(m_run_one_line_function.get())) {
806 Py_BuildValue("(Os)", session_dict.get(), command));
807 if (pargs.IsValid()) {
808 PythonObject return_value(
810 PyObject_CallObject(m_run_one_line_function.get(),
812 if (return_value.IsValid())
814 else if (options.GetMaskoutErrors() && PyErr_Occurred()) {
823 // Flush our output and error file handles
825 if (out_file != err_file)
829 if (join_read_thread) {
830 // Close the write end of the pipe since we are done with our
831 // one line script. This should cause the read thread that
832 // output_comm is using to exit
833 output_file_sp->GetFile().Close();
834 // The close above should cause this thread to exit when it gets
835 // to the end of file, so let it get all its data
836 output_comm.JoinReadThread();
837 // Now we can close the read end of the pipe
838 output_comm.Disconnect();
844 // The one-liner failed. Append the error message.
846 result->AppendErrorWithFormat(
847 "python failed attempting to evaluate '%s'\n", command);
852 result->AppendError("empty command passed to python\n");
856 class IOHandlerPythonInterpreter : public IOHandler {
858 IOHandlerPythonInterpreter(Debugger &debugger,
859 ScriptInterpreterPython *python)
860 : IOHandler(debugger, IOHandler::Type::PythonInterpreter),
863 ~IOHandlerPythonInterpreter() override {}
865 ConstString GetControlSequence(char ch) override {
867 return ConstString("quit()\n");
868 return ConstString();
871 void Run() override {
873 int stdin_fd = GetInputFD();
875 Terminal terminal(stdin_fd);
876 TerminalState terminal_state;
877 const bool is_a_tty = terminal.IsATerminal();
880 terminal_state.Save(stdin_fd, false);
881 terminal.SetCanonical(false);
882 terminal.SetEcho(true);
885 ScriptInterpreterPython::Locker locker(
886 m_python, ScriptInterpreterPython::Locker::AcquireLock |
887 ScriptInterpreterPython::Locker::InitSession |
888 ScriptInterpreterPython::Locker::InitGlobals,
889 ScriptInterpreterPython::Locker::FreeAcquiredLock |
890 ScriptInterpreterPython::Locker::TearDownSession);
892 // The following call drops into the embedded interpreter loop and stays
894 // user chooses to exit from the Python interpreter.
895 // This embedded interpreter will, as any Python code that performs I/O,
896 // unlock the GIL before
897 // a system call that can hang, and lock it when the syscall has
900 // We need to surround the call to the embedded interpreter with calls
901 // to PyGILState_Ensure and
902 // PyGILState_Release (using the Locker above). This is because Python
903 // has a global lock which must be held whenever we want
904 // to touch any Python objects. Otherwise, if the user calls Python
905 // code, the interpreter state will be off,
906 // and things could hang (it's happened before).
908 StreamString run_string;
909 run_string.Printf("run_python_interpreter (%s)",
910 m_python->GetDictionaryName());
911 PyRun_SimpleString(run_string.GetData());
914 terminal_state.Restore();
920 void Cancel() override {}
922 bool Interrupt() override { return m_python->Interrupt(); }
924 void GotEOF() override {}
927 ScriptInterpreterPython *m_python;
930 void ScriptInterpreterPython::ExecuteInterpreterLoop() {
931 static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
932 Timer scoped_timer(func_cat, LLVM_PRETTY_FUNCTION);
934 Debugger &debugger = GetCommandInterpreter().GetDebugger();
936 // At the moment, the only time the debugger does not have an input file
937 // handle is when this is called
938 // directly from Python, in which case it is both dangerous and unnecessary
939 // (not to mention confusing) to
940 // try to embed a running interpreter loop inside the already running Python
941 // interpreter loop, so we won't
944 if (!debugger.GetInputFile()->GetFile().IsValid())
947 IOHandlerSP io_handler_sp(new IOHandlerPythonInterpreter(debugger, this));
949 debugger.PushIOHandler(io_handler_sp);
953 bool ScriptInterpreterPython::Interrupt() {
954 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_SCRIPT));
956 if (IsExecutingPython()) {
957 PyThreadState *state = PyThreadState_GET();
959 state = GetThreadState();
961 long tid = state->thread_id;
962 PyThreadState_Swap(state);
963 int num_threads = PyThreadState_SetAsyncExc(tid, PyExc_KeyboardInterrupt);
965 log->Printf("ScriptInterpreterPython::Interrupt() sending "
966 "PyExc_KeyboardInterrupt (tid = %li, num_threads = %i)...",
972 log->Printf("ScriptInterpreterPython::Interrupt() python code not running, "
976 bool ScriptInterpreterPython::ExecuteOneLineWithReturn(
977 const char *in_string, ScriptInterpreter::ScriptReturnType return_type,
978 void *ret_value, const ExecuteScriptOptions &options) {
980 Locker locker(this, ScriptInterpreterPython::Locker::AcquireLock |
981 ScriptInterpreterPython::Locker::InitSession |
982 (options.GetSetLLDBGlobals()
983 ? ScriptInterpreterPython::Locker::InitGlobals
986 ScriptInterpreterPython::Locker::FreeAcquiredLock |
987 ScriptInterpreterPython::Locker::TearDownSession);
989 PythonObject py_return;
990 PythonObject &main_module = GetMainModule();
991 PythonDictionary globals(PyRefType::Borrowed,
992 PyModule_GetDict(main_module.get()));
993 PythonObject py_error;
994 bool ret_success = false;
997 PythonDictionary locals = GetSessionDictionary();
999 if (!locals.IsValid()) {
1002 PyObject_GetAttrString(globals.get(), m_dictionary_name.c_str()));
1005 if (!locals.IsValid())
1008 py_error.Reset(PyRefType::Borrowed, PyErr_Occurred());
1009 if (py_error.IsValid())
1012 if (in_string != nullptr) {
1013 { // scope for PythonInputReaderManager
1014 // PythonInputReaderManager py_input(options.GetEnableIO() ? this : NULL);
1017 PyRun_String(in_string, Py_eval_input, globals.get(), locals.get()));
1018 if (!py_return.IsValid()) {
1019 py_error.Reset(PyRefType::Borrowed, PyErr_Occurred());
1020 if (py_error.IsValid())
1023 py_return.Reset(PyRefType::Owned,
1024 PyRun_String(in_string, Py_single_input, globals.get(),
1029 if (py_return.IsValid()) {
1030 switch (return_type) {
1031 case eScriptReturnTypeCharPtr: // "char *"
1033 const char format[3] = "s#";
1034 success = PyArg_Parse(py_return.get(), format, (char **)ret_value);
1037 case eScriptReturnTypeCharStrOrNone: // char* or NULL if py_return ==
1040 const char format[3] = "z";
1041 success = PyArg_Parse(py_return.get(), format, (char **)ret_value);
1044 case eScriptReturnTypeBool: {
1045 const char format[2] = "b";
1046 success = PyArg_Parse(py_return.get(), format, (bool *)ret_value);
1049 case eScriptReturnTypeShortInt: {
1050 const char format[2] = "h";
1051 success = PyArg_Parse(py_return.get(), format, (short *)ret_value);
1054 case eScriptReturnTypeShortIntUnsigned: {
1055 const char format[2] = "H";
1057 PyArg_Parse(py_return.get(), format, (unsigned short *)ret_value);
1060 case eScriptReturnTypeInt: {
1061 const char format[2] = "i";
1062 success = PyArg_Parse(py_return.get(), format, (int *)ret_value);
1065 case eScriptReturnTypeIntUnsigned: {
1066 const char format[2] = "I";
1068 PyArg_Parse(py_return.get(), format, (unsigned int *)ret_value);
1071 case eScriptReturnTypeLongInt: {
1072 const char format[2] = "l";
1073 success = PyArg_Parse(py_return.get(), format, (long *)ret_value);
1076 case eScriptReturnTypeLongIntUnsigned: {
1077 const char format[2] = "k";
1079 PyArg_Parse(py_return.get(), format, (unsigned long *)ret_value);
1082 case eScriptReturnTypeLongLong: {
1083 const char format[2] = "L";
1084 success = PyArg_Parse(py_return.get(), format, (long long *)ret_value);
1087 case eScriptReturnTypeLongLongUnsigned: {
1088 const char format[2] = "K";
1089 success = PyArg_Parse(py_return.get(), format,
1090 (unsigned long long *)ret_value);
1093 case eScriptReturnTypeFloat: {
1094 const char format[2] = "f";
1095 success = PyArg_Parse(py_return.get(), format, (float *)ret_value);
1098 case eScriptReturnTypeDouble: {
1099 const char format[2] = "d";
1100 success = PyArg_Parse(py_return.get(), format, (double *)ret_value);
1103 case eScriptReturnTypeChar: {
1104 const char format[2] = "c";
1105 success = PyArg_Parse(py_return.get(), format, (char *)ret_value);
1108 case eScriptReturnTypeOpaqueObject: {
1110 PyObject *saved_value = py_return.get();
1111 Py_XINCREF(saved_value);
1112 *((PyObject **)ret_value) = saved_value;
1120 ret_success = false;
1124 py_error.Reset(PyRefType::Borrowed, PyErr_Occurred());
1125 if (py_error.IsValid()) {
1126 ret_success = false;
1127 if (options.GetMaskoutErrors()) {
1128 if (PyErr_GivenExceptionMatches(py_error.get(), PyExc_SyntaxError))
1137 Status ScriptInterpreterPython::ExecuteMultipleLines(
1138 const char *in_string, const ExecuteScriptOptions &options) {
1141 Locker locker(this, ScriptInterpreterPython::Locker::AcquireLock |
1142 ScriptInterpreterPython::Locker::InitSession |
1143 (options.GetSetLLDBGlobals()
1144 ? ScriptInterpreterPython::Locker::InitGlobals
1147 ScriptInterpreterPython::Locker::FreeAcquiredLock |
1148 ScriptInterpreterPython::Locker::TearDownSession);
1150 PythonObject return_value;
1151 PythonObject &main_module = GetMainModule();
1152 PythonDictionary globals(PyRefType::Borrowed,
1153 PyModule_GetDict(main_module.get()));
1154 PythonObject py_error;
1156 PythonDictionary locals = GetSessionDictionary();
1158 if (!locals.IsValid())
1161 PyObject_GetAttrString(globals.get(), m_dictionary_name.c_str()));
1163 if (!locals.IsValid())
1166 py_error.Reset(PyRefType::Borrowed, PyErr_Occurred());
1167 if (py_error.IsValid())
1170 if (in_string != nullptr) {
1171 PythonObject code_object;
1172 code_object.Reset(PyRefType::Owned,
1173 Py_CompileString(in_string, "temp.py", Py_file_input));
1175 if (code_object.IsValid()) {
1176 // In Python 2.x, PyEval_EvalCode takes a PyCodeObject, but in Python 3.x, it
1178 // a PyObject. They are convertible (hence the function
1179 // PyCode_Check(PyObject*), so
1180 // we have to do the cast for Python 2.x
1181 #if PY_MAJOR_VERSION >= 3
1182 PyObject *py_code_obj = code_object.get();
1184 PyCodeObject *py_code_obj =
1185 reinterpret_cast<PyCodeObject *>(code_object.get());
1189 PyEval_EvalCode(py_code_obj, globals.get(), locals.get()));
1193 PythonExceptionState exception_state(!options.GetMaskoutErrors());
1194 if (exception_state.IsError())
1195 error.SetErrorString(exception_state.Format().c_str());
1200 void ScriptInterpreterPython::CollectDataForBreakpointCommandCallback(
1201 std::vector<BreakpointOptions *> &bp_options_vec,
1202 CommandReturnObject &result) {
1203 m_active_io_handler = eIOHandlerBreakpoint;
1204 m_interpreter.GetPythonCommandsFromIOHandler(" ", *this, true,
1208 void ScriptInterpreterPython::CollectDataForWatchpointCommandCallback(
1209 WatchpointOptions *wp_options, CommandReturnObject &result) {
1210 m_active_io_handler = eIOHandlerWatchpoint;
1211 m_interpreter.GetPythonCommandsFromIOHandler(" ", *this, true, wp_options);
1214 void ScriptInterpreterPython::SetBreakpointCommandCallbackFunction(
1215 BreakpointOptions *bp_options, const char *function_name) {
1216 // For now just cons up a oneliner that calls the provided function.
1217 std::string oneliner("return ");
1218 oneliner += function_name;
1219 oneliner += "(frame, bp_loc, internal_dict)";
1220 m_interpreter.GetScriptInterpreter()->SetBreakpointCommandCallback(
1221 bp_options, oneliner.c_str());
1224 Status ScriptInterpreterPython::SetBreakpointCommandCallback(
1225 BreakpointOptions *bp_options,
1226 std::unique_ptr<BreakpointOptions::CommandData> &cmd_data_up) {
1228 error = GenerateBreakpointCommandCallbackData(cmd_data_up->user_source,
1229 cmd_data_up->script_source);
1234 std::make_shared<BreakpointOptions::CommandBaton>(std::move(cmd_data_up));
1235 bp_options->SetCallback(ScriptInterpreterPython::BreakpointCallbackFunction,
1240 // Set a Python one-liner as the callback for the breakpoint.
1241 Status ScriptInterpreterPython::SetBreakpointCommandCallback(
1242 BreakpointOptions *bp_options, const char *command_body_text) {
1243 auto data_ap = llvm::make_unique<CommandDataPython>();
1245 // Split the command_body_text into lines, and pass that to
1246 // GenerateBreakpointCommandCallbackData. That will
1247 // wrap the body in an auto-generated function, and return the function name
1248 // in script_source. That is what
1249 // the callback will actually invoke.
1251 data_ap->user_source.SplitIntoLines(command_body_text);
1252 Status error = GenerateBreakpointCommandCallbackData(data_ap->user_source,
1253 data_ap->script_source);
1254 if (error.Success()) {
1256 std::make_shared<BreakpointOptions::CommandBaton>(std::move(data_ap));
1257 bp_options->SetCallback(ScriptInterpreterPython::BreakpointCallbackFunction,
1264 // Set a Python one-liner as the callback for the watchpoint.
1265 void ScriptInterpreterPython::SetWatchpointCommandCallback(
1266 WatchpointOptions *wp_options, const char *oneliner) {
1267 auto data_ap = llvm::make_unique<WatchpointOptions::CommandData>();
1269 // It's necessary to set both user_source and script_source to the oneliner.
1270 // The former is used to generate callback description (as in watchpoint
1272 // while the latter is used for Python to interpret during the actual
1275 data_ap->user_source.AppendString(oneliner);
1276 data_ap->script_source.assign(oneliner);
1278 if (GenerateWatchpointCommandCallbackData(data_ap->user_source,
1279 data_ap->script_source)) {
1281 std::make_shared<WatchpointOptions::CommandBaton>(std::move(data_ap));
1282 wp_options->SetCallback(ScriptInterpreterPython::WatchpointCallbackFunction,
1289 Status ScriptInterpreterPython::ExportFunctionDefinitionToInterpreter(
1290 StringList &function_def) {
1291 // Convert StringList to one long, newline delimited, const char *.
1292 std::string function_def_string(function_def.CopyList());
1294 Status error = ExecuteMultipleLines(
1295 function_def_string.c_str(),
1296 ScriptInterpreter::ExecuteScriptOptions().SetEnableIO(false));
1300 Status ScriptInterpreterPython::GenerateFunction(const char *signature,
1301 const StringList &input) {
1303 int num_lines = input.GetSize();
1304 if (num_lines == 0) {
1305 error.SetErrorString("No input data.");
1309 if (!signature || *signature == 0) {
1310 error.SetErrorString("No output function name.");
1315 StringList auto_generated_function;
1316 auto_generated_function.AppendString(signature);
1317 auto_generated_function.AppendString(
1318 " global_dict = globals()"); // Grab the global dictionary
1319 auto_generated_function.AppendString(
1320 " new_keys = internal_dict.keys()"); // Make a list of keys in the
1322 auto_generated_function.AppendString(
1323 " old_keys = global_dict.keys()"); // Save list of keys in global dict
1324 auto_generated_function.AppendString(
1325 " global_dict.update (internal_dict)"); // Add the session dictionary
1327 // global dictionary.
1329 // Wrap everything up inside the function, increasing the indentation.
1331 auto_generated_function.AppendString(" if True:");
1332 for (int i = 0; i < num_lines; ++i) {
1334 sstr.Printf(" %s", input.GetStringAtIndex(i));
1335 auto_generated_function.AppendString(sstr.GetData());
1337 auto_generated_function.AppendString(
1338 " for key in new_keys:"); // Iterate over all the keys from session
1340 auto_generated_function.AppendString(
1341 " internal_dict[key] = global_dict[key]"); // Update session dict
1343 auto_generated_function.AppendString(
1344 " if key not in old_keys:"); // If key was not originally in
1346 auto_generated_function.AppendString(
1347 " del global_dict[key]"); // ...then remove key/value from
1350 // Verify that the results are valid Python.
1352 error = ExportFunctionDefinitionToInterpreter(auto_generated_function);
1357 bool ScriptInterpreterPython::GenerateTypeScriptFunction(
1358 StringList &user_input, std::string &output, const void *name_token) {
1359 static uint32_t num_created_functions = 0;
1360 user_input.RemoveBlankLines();
1363 // Check to see if we have any data; if not, just return.
1364 if (user_input.GetSize() == 0)
1367 // Take what the user wrote, wrap it all up inside one big auto-generated
1368 // Python function, passing in the
1369 // ValueObject as parameter to the function.
1371 std::string auto_generated_function_name(
1372 GenerateUniqueName("lldb_autogen_python_type_print_func",
1373 num_created_functions, name_token));
1374 sstr.Printf("def %s (valobj, internal_dict):",
1375 auto_generated_function_name.c_str());
1377 if (!GenerateFunction(sstr.GetData(), user_input).Success())
1380 // Store the name of the auto-generated function to be called.
1381 output.assign(auto_generated_function_name);
1385 bool ScriptInterpreterPython::GenerateScriptAliasFunction(
1386 StringList &user_input, std::string &output) {
1387 static uint32_t num_created_functions = 0;
1388 user_input.RemoveBlankLines();
1391 // Check to see if we have any data; if not, just return.
1392 if (user_input.GetSize() == 0)
1395 std::string auto_generated_function_name(GenerateUniqueName(
1396 "lldb_autogen_python_cmd_alias_func", num_created_functions));
1398 sstr.Printf("def %s (debugger, args, result, internal_dict):",
1399 auto_generated_function_name.c_str());
1401 if (!GenerateFunction(sstr.GetData(), user_input).Success())
1404 // Store the name of the auto-generated function to be called.
1405 output.assign(auto_generated_function_name);
1409 bool ScriptInterpreterPython::GenerateTypeSynthClass(StringList &user_input,
1410 std::string &output,
1411 const void *name_token) {
1412 static uint32_t num_created_classes = 0;
1413 user_input.RemoveBlankLines();
1414 int num_lines = user_input.GetSize();
1417 // Check to see if we have any data; if not, just return.
1418 if (user_input.GetSize() == 0)
1421 // Wrap all user input into a Python class
1423 std::string auto_generated_class_name(GenerateUniqueName(
1424 "lldb_autogen_python_type_synth_class", num_created_classes, name_token));
1426 StringList auto_generated_class;
1428 // Create the function name & definition string.
1430 sstr.Printf("class %s:", auto_generated_class_name.c_str());
1431 auto_generated_class.AppendString(sstr.GetString());
1433 // Wrap everything up inside the class, increasing the indentation.
1434 // we don't need to play any fancy indentation tricks here because there is no
1435 // surrounding code whose indentation we need to honor
1436 for (int i = 0; i < num_lines; ++i) {
1438 sstr.Printf(" %s", user_input.GetStringAtIndex(i));
1439 auto_generated_class.AppendString(sstr.GetString());
1442 // Verify that the results are valid Python.
1443 // (even though the method is ExportFunctionDefinitionToInterpreter, a class
1444 // will actually be exported)
1445 // (TODO: rename that method to ExportDefinitionToInterpreter)
1446 if (!ExportFunctionDefinitionToInterpreter(auto_generated_class).Success())
1449 // Store the name of the auto-generated class
1451 output.assign(auto_generated_class_name);
1455 StructuredData::GenericSP ScriptInterpreterPython::OSPlugin_CreatePluginObject(
1456 const char *class_name, lldb::ProcessSP process_sp) {
1457 if (class_name == nullptr || class_name[0] == '\0')
1458 return StructuredData::GenericSP();
1461 return StructuredData::GenericSP();
1466 Locker py_lock(this, Locker::AcquireLock | Locker::NoSTDIN,
1468 ret_val = g_swig_create_os_plugin(class_name, m_dictionary_name.c_str(),
1472 return StructuredData::GenericSP(new StructuredPythonObject(ret_val));
1475 StructuredData::DictionarySP ScriptInterpreterPython::OSPlugin_RegisterInfo(
1476 StructuredData::ObjectSP os_plugin_object_sp) {
1477 Locker py_lock(this, Locker::AcquireLock | Locker::NoSTDIN, Locker::FreeLock);
1479 static char callee_name[] = "get_register_info";
1481 if (!os_plugin_object_sp)
1482 return StructuredData::DictionarySP();
1484 StructuredData::Generic *generic = os_plugin_object_sp->GetAsGeneric();
1488 PythonObject implementor(PyRefType::Borrowed,
1489 (PyObject *)generic->GetValue());
1491 if (!implementor.IsAllocated())
1492 return StructuredData::DictionarySP();
1494 PythonObject pmeth(PyRefType::Owned,
1495 PyObject_GetAttrString(implementor.get(), callee_name));
1497 if (PyErr_Occurred())
1500 if (!pmeth.IsAllocated())
1501 return StructuredData::DictionarySP();
1503 if (PyCallable_Check(pmeth.get()) == 0) {
1504 if (PyErr_Occurred())
1507 return StructuredData::DictionarySP();
1510 if (PyErr_Occurred())
1513 // right now we know this function exists and is callable..
1514 PythonObject py_return(
1516 PyObject_CallMethod(implementor.get(), callee_name, nullptr));
1518 // if it fails, print the error but otherwise go on
1519 if (PyErr_Occurred()) {
1523 if (py_return.get()) {
1524 PythonDictionary result_dict(PyRefType::Borrowed, py_return.get());
1525 return result_dict.CreateStructuredDictionary();
1527 return StructuredData::DictionarySP();
1530 StructuredData::ArraySP ScriptInterpreterPython::OSPlugin_ThreadsInfo(
1531 StructuredData::ObjectSP os_plugin_object_sp) {
1532 Locker py_lock(this, Locker::AcquireLock | Locker::NoSTDIN, Locker::FreeLock);
1534 static char callee_name[] = "get_thread_info";
1536 if (!os_plugin_object_sp)
1537 return StructuredData::ArraySP();
1539 StructuredData::Generic *generic = os_plugin_object_sp->GetAsGeneric();
1543 PythonObject implementor(PyRefType::Borrowed,
1544 (PyObject *)generic->GetValue());
1546 if (!implementor.IsAllocated())
1547 return StructuredData::ArraySP();
1549 PythonObject pmeth(PyRefType::Owned,
1550 PyObject_GetAttrString(implementor.get(), callee_name));
1552 if (PyErr_Occurred())
1555 if (!pmeth.IsAllocated())
1556 return StructuredData::ArraySP();
1558 if (PyCallable_Check(pmeth.get()) == 0) {
1559 if (PyErr_Occurred())
1562 return StructuredData::ArraySP();
1565 if (PyErr_Occurred())
1568 // right now we know this function exists and is callable..
1569 PythonObject py_return(
1571 PyObject_CallMethod(implementor.get(), callee_name, nullptr));
1573 // if it fails, print the error but otherwise go on
1574 if (PyErr_Occurred()) {
1579 if (py_return.get()) {
1580 PythonList result_list(PyRefType::Borrowed, py_return.get());
1581 return result_list.CreateStructuredArray();
1583 return StructuredData::ArraySP();
1586 // GetPythonValueFormatString provides a system independent type safe way to
1587 // convert a variable's type into a python value format. Python value formats
1588 // are defined in terms of builtin C types and could change from system to
1589 // as the underlying typedef for uint* types, size_t, off_t and other values
1592 template <typename T> const char *GetPythonValueFormatString(T t);
1593 template <> const char *GetPythonValueFormatString(char *) { return "s"; }
1594 template <> const char *GetPythonValueFormatString(char) { return "b"; }
1595 template <> const char *GetPythonValueFormatString(unsigned char) {
1598 template <> const char *GetPythonValueFormatString(short) { return "h"; }
1599 template <> const char *GetPythonValueFormatString(unsigned short) {
1602 template <> const char *GetPythonValueFormatString(int) { return "i"; }
1603 template <> const char *GetPythonValueFormatString(unsigned int) { return "I"; }
1604 template <> const char *GetPythonValueFormatString(long) { return "l"; }
1605 template <> const char *GetPythonValueFormatString(unsigned long) {
1608 template <> const char *GetPythonValueFormatString(long long) { return "L"; }
1609 template <> const char *GetPythonValueFormatString(unsigned long long) {
1612 template <> const char *GetPythonValueFormatString(float t) { return "f"; }
1613 template <> const char *GetPythonValueFormatString(double t) { return "d"; }
1615 StructuredData::StringSP ScriptInterpreterPython::OSPlugin_RegisterContextData(
1616 StructuredData::ObjectSP os_plugin_object_sp, lldb::tid_t tid) {
1617 Locker py_lock(this, Locker::AcquireLock | Locker::NoSTDIN, Locker::FreeLock);
1619 static char callee_name[] = "get_register_data";
1620 static char *param_format =
1621 const_cast<char *>(GetPythonValueFormatString(tid));
1623 if (!os_plugin_object_sp)
1624 return StructuredData::StringSP();
1626 StructuredData::Generic *generic = os_plugin_object_sp->GetAsGeneric();
1629 PythonObject implementor(PyRefType::Borrowed,
1630 (PyObject *)generic->GetValue());
1632 if (!implementor.IsAllocated())
1633 return StructuredData::StringSP();
1635 PythonObject pmeth(PyRefType::Owned,
1636 PyObject_GetAttrString(implementor.get(), callee_name));
1638 if (PyErr_Occurred())
1641 if (!pmeth.IsAllocated())
1642 return StructuredData::StringSP();
1644 if (PyCallable_Check(pmeth.get()) == 0) {
1645 if (PyErr_Occurred())
1647 return StructuredData::StringSP();
1650 if (PyErr_Occurred())
1653 // right now we know this function exists and is callable..
1654 PythonObject py_return(
1656 PyObject_CallMethod(implementor.get(), callee_name, param_format, tid));
1658 // if it fails, print the error but otherwise go on
1659 if (PyErr_Occurred()) {
1664 if (py_return.get()) {
1665 PythonBytes result(PyRefType::Borrowed, py_return.get());
1666 return result.CreateStructuredString();
1668 return StructuredData::StringSP();
1671 StructuredData::DictionarySP ScriptInterpreterPython::OSPlugin_CreateThread(
1672 StructuredData::ObjectSP os_plugin_object_sp, lldb::tid_t tid,
1673 lldb::addr_t context) {
1674 Locker py_lock(this, Locker::AcquireLock | Locker::NoSTDIN, Locker::FreeLock);
1676 static char callee_name[] = "create_thread";
1677 std::string param_format;
1678 param_format += GetPythonValueFormatString(tid);
1679 param_format += GetPythonValueFormatString(context);
1681 if (!os_plugin_object_sp)
1682 return StructuredData::DictionarySP();
1684 StructuredData::Generic *generic = os_plugin_object_sp->GetAsGeneric();
1688 PythonObject implementor(PyRefType::Borrowed,
1689 (PyObject *)generic->GetValue());
1691 if (!implementor.IsAllocated())
1692 return StructuredData::DictionarySP();
1694 PythonObject pmeth(PyRefType::Owned,
1695 PyObject_GetAttrString(implementor.get(), callee_name));
1697 if (PyErr_Occurred())
1700 if (!pmeth.IsAllocated())
1701 return StructuredData::DictionarySP();
1703 if (PyCallable_Check(pmeth.get()) == 0) {
1704 if (PyErr_Occurred())
1706 return StructuredData::DictionarySP();
1709 if (PyErr_Occurred())
1712 // right now we know this function exists and is callable..
1713 PythonObject py_return(PyRefType::Owned,
1714 PyObject_CallMethod(implementor.get(), callee_name,
1715 ¶m_format[0], tid, context));
1717 // if it fails, print the error but otherwise go on
1718 if (PyErr_Occurred()) {
1723 if (py_return.get()) {
1724 PythonDictionary result_dict(PyRefType::Borrowed, py_return.get());
1725 return result_dict.CreateStructuredDictionary();
1727 return StructuredData::DictionarySP();
1730 StructuredData::ObjectSP ScriptInterpreterPython::CreateScriptedThreadPlan(
1731 const char *class_name, lldb::ThreadPlanSP thread_plan_sp) {
1732 if (class_name == nullptr || class_name[0] == '\0')
1733 return StructuredData::ObjectSP();
1735 if (!thread_plan_sp.get())
1736 return StructuredData::ObjectSP();
1738 Debugger &debugger = thread_plan_sp->GetTarget().GetDebugger();
1739 ScriptInterpreter *script_interpreter =
1740 debugger.GetCommandInterpreter().GetScriptInterpreter();
1741 ScriptInterpreterPython *python_interpreter =
1742 static_cast<ScriptInterpreterPython *>(script_interpreter);
1744 if (!script_interpreter)
1745 return StructuredData::ObjectSP();
1750 Locker py_lock(this,
1751 Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
1753 ret_val = g_swig_thread_plan_script(
1754 class_name, python_interpreter->m_dictionary_name.c_str(),
1758 return StructuredData::ObjectSP(new StructuredPythonObject(ret_val));
1761 bool ScriptInterpreterPython::ScriptedThreadPlanExplainsStop(
1762 StructuredData::ObjectSP implementor_sp, Event *event, bool &script_error) {
1763 bool explains_stop = true;
1764 StructuredData::Generic *generic = nullptr;
1766 generic = implementor_sp->GetAsGeneric();
1768 Locker py_lock(this,
1769 Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
1770 explains_stop = g_swig_call_thread_plan(
1771 generic->GetValue(), "explains_stop", event, script_error);
1775 return explains_stop;
1778 bool ScriptInterpreterPython::ScriptedThreadPlanShouldStop(
1779 StructuredData::ObjectSP implementor_sp, Event *event, bool &script_error) {
1780 bool should_stop = true;
1781 StructuredData::Generic *generic = nullptr;
1783 generic = implementor_sp->GetAsGeneric();
1785 Locker py_lock(this,
1786 Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
1787 should_stop = g_swig_call_thread_plan(generic->GetValue(), "should_stop",
1788 event, script_error);
1795 bool ScriptInterpreterPython::ScriptedThreadPlanIsStale(
1796 StructuredData::ObjectSP implementor_sp, bool &script_error) {
1797 bool is_stale = true;
1798 StructuredData::Generic *generic = nullptr;
1800 generic = implementor_sp->GetAsGeneric();
1802 Locker py_lock(this,
1803 Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
1804 is_stale = g_swig_call_thread_plan(generic->GetValue(), "is_stale", nullptr,
1812 lldb::StateType ScriptInterpreterPython::ScriptedThreadPlanGetRunState(
1813 StructuredData::ObjectSP implementor_sp, bool &script_error) {
1814 bool should_step = false;
1815 StructuredData::Generic *generic = nullptr;
1817 generic = implementor_sp->GetAsGeneric();
1819 Locker py_lock(this,
1820 Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
1821 should_step = g_swig_call_thread_plan(generic->GetValue(), "should_step",
1822 NULL, script_error);
1827 return lldb::eStateStepping;
1829 return lldb::eStateRunning;
1832 StructuredData::ObjectSP
1833 ScriptInterpreterPython::LoadPluginModule(const FileSpec &file_spec,
1834 lldb_private::Status &error) {
1835 if (!file_spec.Exists()) {
1836 error.SetErrorString("no such file");
1837 return StructuredData::ObjectSP();
1840 StructuredData::ObjectSP module_sp;
1842 if (LoadScriptingModule(file_spec.GetPath().c_str(), true, true, error,
1846 return StructuredData::ObjectSP();
1849 StructuredData::DictionarySP ScriptInterpreterPython::GetDynamicSettings(
1850 StructuredData::ObjectSP plugin_module_sp, Target *target,
1851 const char *setting_name, lldb_private::Status &error) {
1852 if (!plugin_module_sp || !target || !setting_name || !setting_name[0] ||
1854 return StructuredData::DictionarySP();
1855 StructuredData::Generic *generic = plugin_module_sp->GetAsGeneric();
1857 return StructuredData::DictionarySP();
1859 PythonObject reply_pyobj;
1860 Locker py_lock(this,
1861 Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
1862 TargetSP target_sp(target->shared_from_this());
1863 reply_pyobj.Reset(PyRefType::Owned,
1864 (PyObject *)g_swig_plugin_get(generic->GetValue(),
1865 setting_name, target_sp));
1867 PythonDictionary py_dict(PyRefType::Borrowed, reply_pyobj.get());
1868 return py_dict.CreateStructuredDictionary();
1871 StructuredData::ObjectSP
1872 ScriptInterpreterPython::CreateSyntheticScriptedProvider(
1873 const char *class_name, lldb::ValueObjectSP valobj) {
1874 if (class_name == nullptr || class_name[0] == '\0')
1875 return StructuredData::ObjectSP();
1878 return StructuredData::ObjectSP();
1880 ExecutionContext exe_ctx(valobj->GetExecutionContextRef());
1881 Target *target = exe_ctx.GetTargetPtr();
1884 return StructuredData::ObjectSP();
1886 Debugger &debugger = target->GetDebugger();
1887 ScriptInterpreter *script_interpreter =
1888 debugger.GetCommandInterpreter().GetScriptInterpreter();
1889 ScriptInterpreterPython *python_interpreter =
1890 (ScriptInterpreterPython *)script_interpreter;
1892 if (!script_interpreter)
1893 return StructuredData::ObjectSP();
1895 void *ret_val = nullptr;
1898 Locker py_lock(this,
1899 Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
1900 ret_val = g_swig_synthetic_script(
1901 class_name, python_interpreter->m_dictionary_name.c_str(), valobj);
1904 return StructuredData::ObjectSP(new StructuredPythonObject(ret_val));
1907 StructuredData::GenericSP
1908 ScriptInterpreterPython::CreateScriptCommandObject(const char *class_name) {
1909 DebuggerSP debugger_sp(
1910 GetCommandInterpreter().GetDebugger().shared_from_this());
1912 if (class_name == nullptr || class_name[0] == '\0')
1913 return StructuredData::GenericSP();
1915 if (!debugger_sp.get())
1916 return StructuredData::GenericSP();
1921 Locker py_lock(this,
1922 Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
1924 g_swig_create_cmd(class_name, m_dictionary_name.c_str(), debugger_sp);
1927 return StructuredData::GenericSP(new StructuredPythonObject(ret_val));
1930 bool ScriptInterpreterPython::GenerateTypeScriptFunction(
1931 const char *oneliner, std::string &output, const void *name_token) {
1933 input.SplitIntoLines(oneliner, strlen(oneliner));
1934 return GenerateTypeScriptFunction(input, output, name_token);
1937 bool ScriptInterpreterPython::GenerateTypeSynthClass(const char *oneliner,
1938 std::string &output,
1939 const void *name_token) {
1941 input.SplitIntoLines(oneliner, strlen(oneliner));
1942 return GenerateTypeSynthClass(input, output, name_token);
1945 Status ScriptInterpreterPython::GenerateBreakpointCommandCallbackData(
1946 StringList &user_input, std::string &output) {
1947 static uint32_t num_created_functions = 0;
1948 user_input.RemoveBlankLines();
1951 if (user_input.GetSize() == 0) {
1952 error.SetErrorString("No input data.");
1956 std::string auto_generated_function_name(GenerateUniqueName(
1957 "lldb_autogen_python_bp_callback_func_", num_created_functions));
1958 sstr.Printf("def %s (frame, bp_loc, internal_dict):",
1959 auto_generated_function_name.c_str());
1961 error = GenerateFunction(sstr.GetData(), user_input);
1962 if (!error.Success())
1965 // Store the name of the auto-generated function to be called.
1966 output.assign(auto_generated_function_name);
1970 bool ScriptInterpreterPython::GenerateWatchpointCommandCallbackData(
1971 StringList &user_input, std::string &output) {
1972 static uint32_t num_created_functions = 0;
1973 user_input.RemoveBlankLines();
1976 if (user_input.GetSize() == 0)
1979 std::string auto_generated_function_name(GenerateUniqueName(
1980 "lldb_autogen_python_wp_callback_func_", num_created_functions));
1981 sstr.Printf("def %s (frame, wp, internal_dict):",
1982 auto_generated_function_name.c_str());
1984 if (!GenerateFunction(sstr.GetData(), user_input).Success())
1987 // Store the name of the auto-generated function to be called.
1988 output.assign(auto_generated_function_name);
1992 bool ScriptInterpreterPython::GetScriptedSummary(
1993 const char *python_function_name, lldb::ValueObjectSP valobj,
1994 StructuredData::ObjectSP &callee_wrapper_sp,
1995 const TypeSummaryOptions &options, std::string &retval) {
1997 static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
1998 Timer scoped_timer(func_cat, LLVM_PRETTY_FUNCTION);
2000 if (!valobj.get()) {
2001 retval.assign("<no object>");
2005 void *old_callee = nullptr;
2006 StructuredData::Generic *generic = nullptr;
2007 if (callee_wrapper_sp) {
2008 generic = callee_wrapper_sp->GetAsGeneric();
2010 old_callee = generic->GetValue();
2012 void *new_callee = old_callee;
2015 if (python_function_name && *python_function_name) {
2017 Locker py_lock(this, Locker::AcquireLock | Locker::InitSession |
2020 TypeSummaryOptionsSP options_sp(new TypeSummaryOptions(options));
2022 static Timer::Category func_cat("g_swig_typescript_callback");
2023 Timer scoped_timer(func_cat, "g_swig_typescript_callback");
2024 ret_val = g_swig_typescript_callback(
2025 python_function_name, GetSessionDictionary().get(), valobj,
2026 &new_callee, options_sp, retval);
2030 retval.assign("<no function name>");
2034 if (new_callee && old_callee != new_callee)
2035 callee_wrapper_sp.reset(new StructuredPythonObject(new_callee));
2040 void ScriptInterpreterPython::Clear() {
2041 // Release any global variables that might have strong references to
2042 // LLDB objects when clearing the python script interpreter.
2043 Locker locker(this, ScriptInterpreterPython::Locker::AcquireLock,
2044 ScriptInterpreterPython::Locker::FreeAcquiredLock);
2046 // This may be called as part of Py_Finalize. In that case the modules are
2047 // destroyed in random
2048 // order and we can't guarantee that we can access these.
2049 if (Py_IsInitialized())
2050 PyRun_SimpleString("lldb.debugger = None; lldb.target = None; lldb.process "
2051 "= None; lldb.thread = None; lldb.frame = None");
2054 bool ScriptInterpreterPython::BreakpointCallbackFunction(
2055 void *baton, StoppointCallbackContext *context, user_id_t break_id,
2056 user_id_t break_loc_id) {
2057 CommandDataPython *bp_option_data = (CommandDataPython *)baton;
2058 const char *python_function_name = bp_option_data->script_source.c_str();
2063 ExecutionContext exe_ctx(context->exe_ctx_ref);
2064 Target *target = exe_ctx.GetTargetPtr();
2069 Debugger &debugger = target->GetDebugger();
2070 ScriptInterpreter *script_interpreter =
2071 debugger.GetCommandInterpreter().GetScriptInterpreter();
2072 ScriptInterpreterPython *python_interpreter =
2073 (ScriptInterpreterPython *)script_interpreter;
2075 if (!script_interpreter)
2078 if (python_function_name && python_function_name[0]) {
2079 const StackFrameSP stop_frame_sp(exe_ctx.GetFrameSP());
2080 BreakpointSP breakpoint_sp = target->GetBreakpointByID(break_id);
2081 if (breakpoint_sp) {
2082 const BreakpointLocationSP bp_loc_sp(
2083 breakpoint_sp->FindLocationByID(break_loc_id));
2085 if (stop_frame_sp && bp_loc_sp) {
2086 bool ret_val = true;
2088 Locker py_lock(python_interpreter, Locker::AcquireLock |
2089 Locker::InitSession |
2091 ret_val = g_swig_breakpoint_callback(
2092 python_function_name,
2093 python_interpreter->m_dictionary_name.c_str(), stop_frame_sp,
2100 // We currently always true so we stop in case anything goes wrong when
2101 // trying to call the script function
2105 bool ScriptInterpreterPython::WatchpointCallbackFunction(
2106 void *baton, StoppointCallbackContext *context, user_id_t watch_id) {
2107 WatchpointOptions::CommandData *wp_option_data =
2108 (WatchpointOptions::CommandData *)baton;
2109 const char *python_function_name = wp_option_data->script_source.c_str();
2114 ExecutionContext exe_ctx(context->exe_ctx_ref);
2115 Target *target = exe_ctx.GetTargetPtr();
2120 Debugger &debugger = target->GetDebugger();
2121 ScriptInterpreter *script_interpreter =
2122 debugger.GetCommandInterpreter().GetScriptInterpreter();
2123 ScriptInterpreterPython *python_interpreter =
2124 (ScriptInterpreterPython *)script_interpreter;
2126 if (!script_interpreter)
2129 if (python_function_name && python_function_name[0]) {
2130 const StackFrameSP stop_frame_sp(exe_ctx.GetFrameSP());
2131 WatchpointSP wp_sp = target->GetWatchpointList().FindByID(watch_id);
2133 if (stop_frame_sp && wp_sp) {
2134 bool ret_val = true;
2136 Locker py_lock(python_interpreter, Locker::AcquireLock |
2137 Locker::InitSession |
2139 ret_val = g_swig_watchpoint_callback(
2140 python_function_name,
2141 python_interpreter->m_dictionary_name.c_str(), stop_frame_sp,
2148 // We currently always true so we stop in case anything goes wrong when
2149 // trying to call the script function
2153 size_t ScriptInterpreterPython::CalculateNumChildren(
2154 const StructuredData::ObjectSP &implementor_sp, uint32_t max) {
2155 if (!implementor_sp)
2157 StructuredData::Generic *generic = implementor_sp->GetAsGeneric();
2160 void *implementor = generic->GetValue();
2164 if (!g_swig_calc_children)
2170 Locker py_lock(this,
2171 Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
2172 ret_val = g_swig_calc_children(implementor, max);
2178 lldb::ValueObjectSP ScriptInterpreterPython::GetChildAtIndex(
2179 const StructuredData::ObjectSP &implementor_sp, uint32_t idx) {
2180 if (!implementor_sp)
2181 return lldb::ValueObjectSP();
2183 StructuredData::Generic *generic = implementor_sp->GetAsGeneric();
2185 return lldb::ValueObjectSP();
2186 void *implementor = generic->GetValue();
2188 return lldb::ValueObjectSP();
2190 if (!g_swig_get_child_index || !g_swig_cast_to_sbvalue)
2191 return lldb::ValueObjectSP();
2193 lldb::ValueObjectSP ret_val;
2196 Locker py_lock(this,
2197 Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
2198 void *child_ptr = g_swig_get_child_index(implementor, idx);
2199 if (child_ptr != nullptr && child_ptr != Py_None) {
2200 lldb::SBValue *sb_value_ptr =
2201 (lldb::SBValue *)g_swig_cast_to_sbvalue(child_ptr);
2202 if (sb_value_ptr == nullptr)
2203 Py_XDECREF(child_ptr);
2205 ret_val = g_swig_get_valobj_sp_from_sbvalue(sb_value_ptr);
2207 Py_XDECREF(child_ptr);
2214 int ScriptInterpreterPython::GetIndexOfChildWithName(
2215 const StructuredData::ObjectSP &implementor_sp, const char *child_name) {
2216 if (!implementor_sp)
2219 StructuredData::Generic *generic = implementor_sp->GetAsGeneric();
2222 void *implementor = generic->GetValue();
2226 if (!g_swig_get_index_child)
2229 int ret_val = UINT32_MAX;
2232 Locker py_lock(this,
2233 Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
2234 ret_val = g_swig_get_index_child(implementor, child_name);
2240 bool ScriptInterpreterPython::UpdateSynthProviderInstance(
2241 const StructuredData::ObjectSP &implementor_sp) {
2242 bool ret_val = false;
2244 if (!implementor_sp)
2247 StructuredData::Generic *generic = implementor_sp->GetAsGeneric();
2250 void *implementor = generic->GetValue();
2254 if (!g_swig_update_provider)
2258 Locker py_lock(this,
2259 Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
2260 ret_val = g_swig_update_provider(implementor);
2266 bool ScriptInterpreterPython::MightHaveChildrenSynthProviderInstance(
2267 const StructuredData::ObjectSP &implementor_sp) {
2268 bool ret_val = false;
2270 if (!implementor_sp)
2273 StructuredData::Generic *generic = implementor_sp->GetAsGeneric();
2276 void *implementor = generic->GetValue();
2280 if (!g_swig_mighthavechildren_provider)
2284 Locker py_lock(this,
2285 Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
2286 ret_val = g_swig_mighthavechildren_provider(implementor);
2292 lldb::ValueObjectSP ScriptInterpreterPython::GetSyntheticValue(
2293 const StructuredData::ObjectSP &implementor_sp) {
2294 lldb::ValueObjectSP ret_val(nullptr);
2296 if (!implementor_sp)
2299 StructuredData::Generic *generic = implementor_sp->GetAsGeneric();
2302 void *implementor = generic->GetValue();
2306 if (!g_swig_getvalue_provider || !g_swig_cast_to_sbvalue ||
2307 !g_swig_get_valobj_sp_from_sbvalue)
2311 Locker py_lock(this,
2312 Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
2313 void *child_ptr = g_swig_getvalue_provider(implementor);
2314 if (child_ptr != nullptr && child_ptr != Py_None) {
2315 lldb::SBValue *sb_value_ptr =
2316 (lldb::SBValue *)g_swig_cast_to_sbvalue(child_ptr);
2317 if (sb_value_ptr == nullptr)
2318 Py_XDECREF(child_ptr);
2320 ret_val = g_swig_get_valobj_sp_from_sbvalue(sb_value_ptr);
2322 Py_XDECREF(child_ptr);
2329 ConstString ScriptInterpreterPython::GetSyntheticTypeName(
2330 const StructuredData::ObjectSP &implementor_sp) {
2331 Locker py_lock(this,
2332 Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
2334 static char callee_name[] = "get_type_name";
2336 ConstString ret_val;
2337 bool got_string = false;
2340 if (!implementor_sp)
2343 StructuredData::Generic *generic = implementor_sp->GetAsGeneric();
2346 PythonObject implementor(PyRefType::Borrowed,
2347 (PyObject *)generic->GetValue());
2348 if (!implementor.IsAllocated())
2351 PythonObject pmeth(PyRefType::Owned,
2352 PyObject_GetAttrString(implementor.get(), callee_name));
2354 if (PyErr_Occurred())
2357 if (!pmeth.IsAllocated())
2360 if (PyCallable_Check(pmeth.get()) == 0) {
2361 if (PyErr_Occurred())
2366 if (PyErr_Occurred())
2369 // right now we know this function exists and is callable..
2370 PythonObject py_return(
2372 PyObject_CallMethod(implementor.get(), callee_name, nullptr));
2374 // if it fails, print the error but otherwise go on
2375 if (PyErr_Occurred()) {
2380 if (py_return.IsAllocated() && PythonString::Check(py_return.get())) {
2381 PythonString py_string(PyRefType::Borrowed, py_return.get());
2382 llvm::StringRef return_data(py_string.GetString());
2383 if (!return_data.empty()) {
2384 buffer.assign(return_data.data(), return_data.size());
2390 ret_val.SetCStringWithLength(buffer.c_str(), buffer.size());
2395 bool ScriptInterpreterPython::RunScriptFormatKeyword(const char *impl_function,
2397 std::string &output,
2401 error.SetErrorString("no process");
2404 if (!impl_function || !impl_function[0]) {
2405 error.SetErrorString("no function to execute");
2408 if (!g_swig_run_script_keyword_process) {
2409 error.SetErrorString("internal helper function missing");
2413 ProcessSP process_sp(process->shared_from_this());
2414 Locker py_lock(this,
2415 Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
2416 ret_val = g_swig_run_script_keyword_process(
2417 impl_function, m_dictionary_name.c_str(), process_sp, output);
2419 error.SetErrorString("python script evaluation failed");
2424 bool ScriptInterpreterPython::RunScriptFormatKeyword(const char *impl_function,
2426 std::string &output,
2430 error.SetErrorString("no thread");
2433 if (!impl_function || !impl_function[0]) {
2434 error.SetErrorString("no function to execute");
2437 if (!g_swig_run_script_keyword_thread) {
2438 error.SetErrorString("internal helper function missing");
2442 ThreadSP thread_sp(thread->shared_from_this());
2443 Locker py_lock(this,
2444 Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
2445 ret_val = g_swig_run_script_keyword_thread(
2446 impl_function, m_dictionary_name.c_str(), thread_sp, output);
2448 error.SetErrorString("python script evaluation failed");
2453 bool ScriptInterpreterPython::RunScriptFormatKeyword(const char *impl_function,
2455 std::string &output,
2459 error.SetErrorString("no thread");
2462 if (!impl_function || !impl_function[0]) {
2463 error.SetErrorString("no function to execute");
2466 if (!g_swig_run_script_keyword_target) {
2467 error.SetErrorString("internal helper function missing");
2471 TargetSP target_sp(target->shared_from_this());
2472 Locker py_lock(this,
2473 Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
2474 ret_val = g_swig_run_script_keyword_target(
2475 impl_function, m_dictionary_name.c_str(), target_sp, output);
2477 error.SetErrorString("python script evaluation failed");
2482 bool ScriptInterpreterPython::RunScriptFormatKeyword(const char *impl_function,
2484 std::string &output,
2488 error.SetErrorString("no frame");
2491 if (!impl_function || !impl_function[0]) {
2492 error.SetErrorString("no function to execute");
2495 if (!g_swig_run_script_keyword_frame) {
2496 error.SetErrorString("internal helper function missing");
2500 StackFrameSP frame_sp(frame->shared_from_this());
2501 Locker py_lock(this,
2502 Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
2503 ret_val = g_swig_run_script_keyword_frame(
2504 impl_function, m_dictionary_name.c_str(), frame_sp, output);
2506 error.SetErrorString("python script evaluation failed");
2511 bool ScriptInterpreterPython::RunScriptFormatKeyword(const char *impl_function,
2513 std::string &output,
2517 error.SetErrorString("no value");
2520 if (!impl_function || !impl_function[0]) {
2521 error.SetErrorString("no function to execute");
2524 if (!g_swig_run_script_keyword_value) {
2525 error.SetErrorString("internal helper function missing");
2529 ValueObjectSP value_sp(value->GetSP());
2530 Locker py_lock(this,
2531 Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
2532 ret_val = g_swig_run_script_keyword_value(
2533 impl_function, m_dictionary_name.c_str(), value_sp, output);
2535 error.SetErrorString("python script evaluation failed");
2540 uint64_t replace_all(std::string &str, const std::string &oldStr,
2541 const std::string &newStr) {
2543 uint64_t matches = 0;
2544 while ((pos = str.find(oldStr, pos)) != std::string::npos) {
2546 str.replace(pos, oldStr.length(), newStr);
2547 pos += newStr.length();
2552 bool ScriptInterpreterPython::LoadScriptingModule(
2553 const char *pathname, bool can_reload, bool init_session,
2554 lldb_private::Status &error, StructuredData::ObjectSP *module_sp) {
2555 if (!pathname || !pathname[0]) {
2556 error.SetErrorString("invalid pathname");
2560 if (!g_swig_call_module_init) {
2561 error.SetErrorString("internal helper function missing");
2565 lldb::DebuggerSP debugger_sp = m_interpreter.GetDebugger().shared_from_this();
2568 FileSpec target_file(pathname, true);
2569 std::string basename(target_file.GetFilename().GetCString());
2571 StreamString command_stream;
2573 // Before executing Python code, lock the GIL.
2574 Locker py_lock(this, Locker::AcquireLock |
2575 (init_session ? Locker::InitSession : 0) |
2577 Locker::FreeAcquiredLock |
2578 (init_session ? Locker::TearDownSession : 0));
2579 namespace fs = llvm::sys::fs;
2581 std::error_code ec = status(target_file.GetPath(), st);
2583 if (ec || st.type() == fs::file_type::status_error ||
2584 st.type() == fs::file_type::type_unknown ||
2585 st.type() == fs::file_type::file_not_found) {
2586 // if not a valid file of any sort, check if it might be a filename still
2587 // dot can't be used but / and \ can, and if either is found, reject
2588 if (strchr(pathname, '\\') || strchr(pathname, '/')) {
2589 error.SetErrorString("invalid pathname");
2592 basename = pathname; // not a filename, probably a package of some sort,
2593 // let it go through
2594 } else if (is_directory(st) || is_regular_file(st)) {
2595 std::string directory = target_file.GetDirectory().GetCString();
2596 replace_all(directory, "\\", "\\\\");
2597 replace_all(directory, "'", "\\'");
2599 // now make sure that Python has "directory" in the search path
2600 StreamString command_stream;
2601 command_stream.Printf("if not (sys.path.__contains__('%s')):\n "
2602 "sys.path.insert(1,'%s');\n\n",
2603 directory.c_str(), directory.c_str());
2604 bool syspath_retval =
2605 ExecuteMultipleLines(command_stream.GetData(),
2606 ScriptInterpreter::ExecuteScriptOptions()
2608 .SetSetLLDBGlobals(false))
2610 if (!syspath_retval) {
2611 error.SetErrorString("Python sys.path handling failed");
2615 // strip .py or .pyc extension
2616 ConstString extension = target_file.GetFileNameExtension();
2618 if (::strcmp(extension.GetCString(), "py") == 0)
2619 basename.resize(basename.length() - 3);
2620 else if (::strcmp(extension.GetCString(), "pyc") == 0)
2621 basename.resize(basename.length() - 4);
2624 error.SetErrorString("no known way to import this module specification");
2628 // check if the module is already import-ed
2629 command_stream.Clear();
2630 command_stream.Printf("sys.modules.__contains__('%s')", basename.c_str());
2631 bool does_contain = false;
2632 // this call will succeed if the module was ever imported in any Debugger in
2633 // the lifetime of the process
2634 // in which this LLDB framework is living
2635 bool was_imported_globally =
2636 (ExecuteOneLineWithReturn(
2637 command_stream.GetData(),
2638 ScriptInterpreterPython::eScriptReturnTypeBool, &does_contain,
2639 ScriptInterpreter::ExecuteScriptOptions()
2641 .SetSetLLDBGlobals(false)) &&
2643 // this call will fail if the module was not imported in this Debugger
2645 command_stream.Clear();
2646 command_stream.Printf("sys.getrefcount(%s)", basename.c_str());
2647 bool was_imported_locally = GetSessionDictionary()
2648 .GetItemForKey(PythonString(basename))
2651 bool was_imported = (was_imported_globally || was_imported_locally);
2653 if (was_imported == true && can_reload == false) {
2654 error.SetErrorString("module already imported");
2658 // now actually do the import
2659 command_stream.Clear();
2662 if (!was_imported_locally)
2663 command_stream.Printf("import %s ; reload_module(%s)", basename.c_str(),
2666 command_stream.Printf("reload_module(%s)", basename.c_str());
2668 command_stream.Printf("import %s", basename.c_str());
2670 error = ExecuteMultipleLines(command_stream.GetData(),
2671 ScriptInterpreter::ExecuteScriptOptions()
2673 .SetSetLLDBGlobals(false));
2677 // if we are here, everything worked
2678 // call __lldb_init_module(debugger,dict)
2679 if (!g_swig_call_module_init(basename.c_str(), m_dictionary_name.c_str(),
2681 error.SetErrorString("calling __lldb_init_module failed");
2686 // everything went just great, now set the module object
2687 command_stream.Clear();
2688 command_stream.Printf("%s", basename.c_str());
2689 void *module_pyobj = nullptr;
2690 if (ExecuteOneLineWithReturn(
2691 command_stream.GetData(),
2692 ScriptInterpreter::eScriptReturnTypeOpaqueObject,
2695 module_sp->reset(new StructuredPythonObject(module_pyobj));
2702 bool ScriptInterpreterPython::IsReservedWord(const char *word) {
2703 if (!word || !word[0])
2706 llvm::StringRef word_sr(word);
2708 // filter out a few characters that would just confuse us
2709 // and that are clearly not keyword material anyway
2710 if (word_sr.find_first_of("'\"") != llvm::StringRef::npos)
2713 StreamString command_stream;
2714 command_stream.Printf("keyword.iskeyword('%s')", word);
2716 ExecuteScriptOptions options;
2717 options.SetEnableIO(false);
2718 options.SetMaskoutErrors(true);
2719 options.SetSetLLDBGlobals(false);
2720 if (ExecuteOneLineWithReturn(command_stream.GetData(),
2721 ScriptInterpreter::eScriptReturnTypeBool,
2727 ScriptInterpreterPython::SynchronicityHandler::SynchronicityHandler(
2728 lldb::DebuggerSP debugger_sp, ScriptedCommandSynchronicity synchro)
2729 : m_debugger_sp(debugger_sp), m_synch_wanted(synchro),
2730 m_old_asynch(debugger_sp->GetAsyncExecution()) {
2731 if (m_synch_wanted == eScriptedCommandSynchronicitySynchronous)
2732 m_debugger_sp->SetAsyncExecution(false);
2733 else if (m_synch_wanted == eScriptedCommandSynchronicityAsynchronous)
2734 m_debugger_sp->SetAsyncExecution(true);
2737 ScriptInterpreterPython::SynchronicityHandler::~SynchronicityHandler() {
2738 if (m_synch_wanted != eScriptedCommandSynchronicityCurrentValue)
2739 m_debugger_sp->SetAsyncExecution(m_old_asynch);
2742 bool ScriptInterpreterPython::RunScriptBasedCommand(
2743 const char *impl_function, const char *args,
2744 ScriptedCommandSynchronicity synchronicity,
2745 lldb_private::CommandReturnObject &cmd_retobj, Status &error,
2746 const lldb_private::ExecutionContext &exe_ctx) {
2747 if (!impl_function) {
2748 error.SetErrorString("no function to execute");
2752 if (!g_swig_call_command) {
2753 error.SetErrorString("no helper function to run scripted commands");
2757 lldb::DebuggerSP debugger_sp = m_interpreter.GetDebugger().shared_from_this();
2758 lldb::ExecutionContextRefSP exe_ctx_ref_sp(new ExecutionContextRef(exe_ctx));
2760 if (!debugger_sp.get()) {
2761 error.SetErrorString("invalid Debugger pointer");
2765 bool ret_val = false;
2767 std::string err_msg;
2770 Locker py_lock(this,
2771 Locker::AcquireLock | Locker::InitSession |
2772 (cmd_retobj.GetInteractive() ? 0 : Locker::NoSTDIN),
2773 Locker::FreeLock | Locker::TearDownSession);
2775 SynchronicityHandler synch_handler(debugger_sp, synchronicity);
2778 g_swig_call_command(impl_function, m_dictionary_name.c_str(),
2779 debugger_sp, args, cmd_retobj, exe_ctx_ref_sp);
2783 error.SetErrorString("unable to execute script function");
2790 bool ScriptInterpreterPython::RunScriptBasedCommand(
2791 StructuredData::GenericSP impl_obj_sp, const char *args,
2792 ScriptedCommandSynchronicity synchronicity,
2793 lldb_private::CommandReturnObject &cmd_retobj, Status &error,
2794 const lldb_private::ExecutionContext &exe_ctx) {
2795 if (!impl_obj_sp || !impl_obj_sp->IsValid()) {
2796 error.SetErrorString("no function to execute");
2800 if (!g_swig_call_command_object) {
2801 error.SetErrorString("no helper function to run scripted commands");
2805 lldb::DebuggerSP debugger_sp = m_interpreter.GetDebugger().shared_from_this();
2806 lldb::ExecutionContextRefSP exe_ctx_ref_sp(new ExecutionContextRef(exe_ctx));
2808 if (!debugger_sp.get()) {
2809 error.SetErrorString("invalid Debugger pointer");
2813 bool ret_val = false;
2815 std::string err_msg;
2818 Locker py_lock(this,
2819 Locker::AcquireLock | Locker::InitSession |
2820 (cmd_retobj.GetInteractive() ? 0 : Locker::NoSTDIN),
2821 Locker::FreeLock | Locker::TearDownSession);
2823 SynchronicityHandler synch_handler(debugger_sp, synchronicity);
2825 ret_val = g_swig_call_command_object(impl_obj_sp->GetValue(), debugger_sp,
2826 args, cmd_retobj, exe_ctx_ref_sp);
2830 error.SetErrorString("unable to execute script function");
2837 // in Python, a special attribute __doc__ contains the docstring
2838 // for an object (function, method, class, ...) if any is defined
2839 // Otherwise, the attribute's value is None
2840 bool ScriptInterpreterPython::GetDocumentationForItem(const char *item,
2841 std::string &dest) {
2843 if (!item || !*item)
2845 std::string command(item);
2846 command += ".__doc__";
2848 char *result_ptr = nullptr; // Python is going to point this to valid data if
2849 // ExecuteOneLineWithReturn returns successfully
2851 if (ExecuteOneLineWithReturn(
2852 command.c_str(), ScriptInterpreter::eScriptReturnTypeCharStrOrNone,
2854 ScriptInterpreter::ExecuteScriptOptions().SetEnableIO(false))) {
2856 dest.assign(result_ptr);
2859 StreamString str_stream;
2861 "Function %s was not found. Containing module might be missing.", item);
2862 dest = str_stream.GetString();
2867 bool ScriptInterpreterPython::GetShortHelpForCommandObject(
2868 StructuredData::GenericSP cmd_obj_sp, std::string &dest) {
2869 bool got_string = false;
2872 Locker py_lock(this, Locker::AcquireLock | Locker::NoSTDIN, Locker::FreeLock);
2874 static char callee_name[] = "get_short_help";
2879 PythonObject implementor(PyRefType::Borrowed,
2880 (PyObject *)cmd_obj_sp->GetValue());
2882 if (!implementor.IsAllocated())
2885 PythonObject pmeth(PyRefType::Owned,
2886 PyObject_GetAttrString(implementor.get(), callee_name));
2888 if (PyErr_Occurred())
2891 if (!pmeth.IsAllocated())
2894 if (PyCallable_Check(pmeth.get()) == 0) {
2895 if (PyErr_Occurred())
2900 if (PyErr_Occurred())
2903 // right now we know this function exists and is callable..
2904 PythonObject py_return(
2906 PyObject_CallMethod(implementor.get(), callee_name, nullptr));
2908 // if it fails, print the error but otherwise go on
2909 if (PyErr_Occurred()) {
2914 if (py_return.IsAllocated() && PythonString::Check(py_return.get())) {
2915 PythonString py_string(PyRefType::Borrowed, py_return.get());
2916 llvm::StringRef return_data(py_string.GetString());
2917 dest.assign(return_data.data(), return_data.size());
2923 uint32_t ScriptInterpreterPython::GetFlagsForCommandObject(
2924 StructuredData::GenericSP cmd_obj_sp) {
2925 uint32_t result = 0;
2927 Locker py_lock(this, Locker::AcquireLock | Locker::NoSTDIN, Locker::FreeLock);
2929 static char callee_name[] = "get_flags";
2934 PythonObject implementor(PyRefType::Borrowed,
2935 (PyObject *)cmd_obj_sp->GetValue());
2937 if (!implementor.IsAllocated())
2940 PythonObject pmeth(PyRefType::Owned,
2941 PyObject_GetAttrString(implementor.get(), callee_name));
2943 if (PyErr_Occurred())
2946 if (!pmeth.IsAllocated())
2949 if (PyCallable_Check(pmeth.get()) == 0) {
2950 if (PyErr_Occurred())
2955 if (PyErr_Occurred())
2958 // right now we know this function exists and is callable..
2959 PythonObject py_return(
2961 PyObject_CallMethod(implementor.get(), callee_name, nullptr));
2963 // if it fails, print the error but otherwise go on
2964 if (PyErr_Occurred()) {
2969 if (py_return.IsAllocated() && PythonInteger::Check(py_return.get())) {
2970 PythonInteger int_value(PyRefType::Borrowed, py_return.get());
2971 result = int_value.GetInteger();
2977 bool ScriptInterpreterPython::GetLongHelpForCommandObject(
2978 StructuredData::GenericSP cmd_obj_sp, std::string &dest) {
2979 bool got_string = false;
2982 Locker py_lock(this, Locker::AcquireLock | Locker::NoSTDIN, Locker::FreeLock);
2984 static char callee_name[] = "get_long_help";
2989 PythonObject implementor(PyRefType::Borrowed,
2990 (PyObject *)cmd_obj_sp->GetValue());
2992 if (!implementor.IsAllocated())
2995 PythonObject pmeth(PyRefType::Owned,
2996 PyObject_GetAttrString(implementor.get(), callee_name));
2998 if (PyErr_Occurred())
3001 if (!pmeth.IsAllocated())
3004 if (PyCallable_Check(pmeth.get()) == 0) {
3005 if (PyErr_Occurred())
3011 if (PyErr_Occurred())
3014 // right now we know this function exists and is callable..
3015 PythonObject py_return(
3017 PyObject_CallMethod(implementor.get(), callee_name, nullptr));
3019 // if it fails, print the error but otherwise go on
3020 if (PyErr_Occurred()) {
3025 if (py_return.IsAllocated() && PythonString::Check(py_return.get())) {
3026 PythonString str(PyRefType::Borrowed, py_return.get());
3027 llvm::StringRef str_data(str.GetString());
3028 dest.assign(str_data.data(), str_data.size());
3035 std::unique_ptr<ScriptInterpreterLocker>
3036 ScriptInterpreterPython::AcquireInterpreterLock() {
3037 std::unique_ptr<ScriptInterpreterLocker> py_lock(new Locker(
3038 this, Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN,
3039 Locker::FreeLock | Locker::TearDownSession));
3043 void ScriptInterpreterPython::InitializeInterpreter(
3044 SWIGInitCallback swig_init_callback,
3045 SWIGBreakpointCallbackFunction swig_breakpoint_callback,
3046 SWIGWatchpointCallbackFunction swig_watchpoint_callback,
3047 SWIGPythonTypeScriptCallbackFunction swig_typescript_callback,
3048 SWIGPythonCreateSyntheticProvider swig_synthetic_script,
3049 SWIGPythonCreateCommandObject swig_create_cmd,
3050 SWIGPythonCalculateNumChildren swig_calc_children,
3051 SWIGPythonGetChildAtIndex swig_get_child_index,
3052 SWIGPythonGetIndexOfChildWithName swig_get_index_child,
3053 SWIGPythonCastPyObjectToSBValue swig_cast_to_sbvalue,
3054 SWIGPythonGetValueObjectSPFromSBValue swig_get_valobj_sp_from_sbvalue,
3055 SWIGPythonUpdateSynthProviderInstance swig_update_provider,
3056 SWIGPythonMightHaveChildrenSynthProviderInstance
3057 swig_mighthavechildren_provider,
3058 SWIGPythonGetValueSynthProviderInstance swig_getvalue_provider,
3059 SWIGPythonCallCommand swig_call_command,
3060 SWIGPythonCallCommandObject swig_call_command_object,
3061 SWIGPythonCallModuleInit swig_call_module_init,
3062 SWIGPythonCreateOSPlugin swig_create_os_plugin,
3063 SWIGPythonScriptKeyword_Process swig_run_script_keyword_process,
3064 SWIGPythonScriptKeyword_Thread swig_run_script_keyword_thread,
3065 SWIGPythonScriptKeyword_Target swig_run_script_keyword_target,
3066 SWIGPythonScriptKeyword_Frame swig_run_script_keyword_frame,
3067 SWIGPythonScriptKeyword_Value swig_run_script_keyword_value,
3068 SWIGPython_GetDynamicSetting swig_plugin_get,
3069 SWIGPythonCreateScriptedThreadPlan swig_thread_plan_script,
3070 SWIGPythonCallThreadPlan swig_call_thread_plan) {
3071 g_swig_init_callback = swig_init_callback;
3072 g_swig_breakpoint_callback = swig_breakpoint_callback;
3073 g_swig_watchpoint_callback = swig_watchpoint_callback;
3074 g_swig_typescript_callback = swig_typescript_callback;
3075 g_swig_synthetic_script = swig_synthetic_script;
3076 g_swig_create_cmd = swig_create_cmd;
3077 g_swig_calc_children = swig_calc_children;
3078 g_swig_get_child_index = swig_get_child_index;
3079 g_swig_get_index_child = swig_get_index_child;
3080 g_swig_cast_to_sbvalue = swig_cast_to_sbvalue;
3081 g_swig_get_valobj_sp_from_sbvalue = swig_get_valobj_sp_from_sbvalue;
3082 g_swig_update_provider = swig_update_provider;
3083 g_swig_mighthavechildren_provider = swig_mighthavechildren_provider;
3084 g_swig_getvalue_provider = swig_getvalue_provider;
3085 g_swig_call_command = swig_call_command;
3086 g_swig_call_command_object = swig_call_command_object;
3087 g_swig_call_module_init = swig_call_module_init;
3088 g_swig_create_os_plugin = swig_create_os_plugin;
3089 g_swig_run_script_keyword_process = swig_run_script_keyword_process;
3090 g_swig_run_script_keyword_thread = swig_run_script_keyword_thread;
3091 g_swig_run_script_keyword_target = swig_run_script_keyword_target;
3092 g_swig_run_script_keyword_frame = swig_run_script_keyword_frame;
3093 g_swig_run_script_keyword_value = swig_run_script_keyword_value;
3094 g_swig_plugin_get = swig_plugin_get;
3095 g_swig_thread_plan_script = swig_thread_plan_script;
3096 g_swig_call_thread_plan = swig_call_thread_plan;
3099 void ScriptInterpreterPython::InitializePrivate() {
3103 g_initialized = true;
3105 static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
3106 Timer scoped_timer(func_cat, LLVM_PRETTY_FUNCTION);
3108 // RAII-based initialization which correctly handles multiple-initialization,
3110 // specific differences among Python 2 and Python 3, and saving and restoring
3112 // other pieces of state that can get mucked with during initialization.
3113 InitializePythonRAII initialize_guard;
3115 if (g_swig_init_callback)
3116 g_swig_init_callback();
3118 // Update the path python uses to search for modules to include the current
3121 PyRun_SimpleString("import sys");
3122 AddToSysPath(AddLocation::End, ".");
3125 // Don't denormalize paths when calling file_spec.GetPath(). On platforms
3127 // a backslash as the path separator, this will result in executing python
3129 // paths with unescaped backslashes. But Python also accepts forward slashes,
3131 // life easier we just use that.
3132 if (HostInfo::GetLLDBPath(ePathTypePythonDir, file_spec))
3133 AddToSysPath(AddLocation::Beginning, file_spec.GetPath(false));
3134 if (HostInfo::GetLLDBPath(ePathTypeLLDBShlibDir, file_spec))
3135 AddToSysPath(AddLocation::Beginning, file_spec.GetPath(false));
3137 PyRun_SimpleString("sys.dont_write_bytecode = 1; import "
3138 "lldb.embedded_interpreter; from "
3139 "lldb.embedded_interpreter import run_python_interpreter; "
3140 "from lldb.embedded_interpreter import run_one_line");
3143 void ScriptInterpreterPython::AddToSysPath(AddLocation location,
3145 std::string path_copy;
3147 std::string statement;
3148 if (location == AddLocation::Beginning) {
3149 statement.assign("sys.path.insert(0,\"");
3150 statement.append(path);
3151 statement.append("\")");
3153 statement.assign("sys.path.append(\"");
3154 statement.append(path);
3155 statement.append("\")");
3157 PyRun_SimpleString(statement.c_str());
3161 // ScriptInterpreterPython::Terminate ()
3163 // // We are intentionally NOT calling Py_Finalize here (this would be the
3164 // logical place to call it). Calling
3165 // // Py_Finalize here causes test suite runs to seg fault: The test suite
3166 // runs in Python. It registers
3167 // // SBDebugger::Terminate to be called 'at_exit'. When the test suite
3168 // Python harness finishes up, it calls
3169 // // Py_Finalize, which calls all the 'at_exit' registered functions.
3170 // SBDebugger::Terminate calls Debugger::Terminate,
3171 // // which calls lldb::Terminate, which calls ScriptInterpreter::Terminate,
3173 // // ScriptInterpreterPython::Terminate. So if we call Py_Finalize here, we
3174 // end up with Py_Finalize being called from
3175 // // within Py_Finalize, which results in a seg fault.
3177 // // Since this function only gets called when lldb is shutting down and
3178 // going away anyway, the fact that we don't
3179 // // actually call Py_Finalize should not cause any problems (everything
3180 // should shut down/go away anyway when the
3181 // // process exits).
3183 //// Py_Finalize ();
3186 #endif // #ifdef LLDB_DISABLE_PYTHON