//===-- ScriptInterpreterPython.cpp -----------------------------*- C++ -*-===// // // The LLVM Compiler Infrastructure // // This file is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// // In order to guarantee correct working with Python, Python.h *MUST* be // the *FIRST* header file included in ScriptInterpreterPython.h, and that // must be the *FIRST* header file included here. #include "lldb/Interpreter/ScriptInterpreterPython.h" #include #include #include #include "lldb/API/SBFrame.h" #include "lldb/API/SBBreakpointLocation.h" #include "lldb/Breakpoint/StoppointCallbackContext.h" #include "lldb/Core/Debugger.h" #include "lldb/Core/Timer.h" #include "lldb/Host/Host.h" #include "lldb/Interpreter/CommandInterpreter.h" #include "lldb/Interpreter/CommandReturnObject.h" #include "lldb/Target/Thread.h" // This function is in the C++ output file generated by SWIG after it is // run on all of the headers in "lldb/API/SB*.h" extern "C" void init_lldb (void); extern "C" bool LLDBSWIGPythonBreakpointCallbackFunction ( const char *python_function_name, const char *session_dictionary_name, lldb::SBFrame& sb_frame, lldb::SBBreakpointLocation& sb_bp_loc ); using namespace lldb; using namespace lldb_private; const char embedded_interpreter_string[] = "import readline\n\ import code\n\ import sys\n\ import traceback\n\ \n\ class SimpleREPL(code.InteractiveConsole):\n\ def __init__(self, prompt, dict):\n\ code.InteractiveConsole.__init__(self,dict)\n\ self.prompt = prompt\n\ self.loop_exit = False\n\ self.dict = dict\n\ \n\ def interact(self):\n\ try:\n\ sys.ps1\n\ except AttributeError:\n\ sys.ps1 = \">>> \"\n\ try:\n\ sys.ps2\n\ except AttributeError:\n\ sys.ps2 = \"... \"\n\ \n\ while not self.loop_exit:\n\ try:\n\ self.read_py_command()\n\ except (SystemExit, EOFError):\n\ # EOF while in Python just breaks out to top level.\n\ self.write('\\n')\n\ self.loop_exit = True\n\ break\n\ except KeyboardInterrupt:\n\ self.write(\"\\nKeyboardInterrupt\\n\")\n\ self.resetbuffer()\n\ more = 0\n\ except:\n\ traceback.print_exc()\n\ \n\ def process_input (self, in_str):\n\ # Canonicalize the format of the input string\n\ temp_str = in_str\n\ temp_str.strip(' \t')\n\ words = temp_str.split()\n\ temp_str = ('').join(words)\n\ \n\ # Check the input string to see if it was the quit\n\ # command. If so, intercept it, so that it doesn't\n\ # close stdin on us!\n\ if (temp_str.lower() == \"quit()\" or temp_str.lower() == \"exit()\"):\n\ self.loop_exit = True\n\ in_str = \"raise SystemExit \"\n\ return in_str\n\ \n\ def my_raw_input (self, prompt):\n\ stream = sys.stdout\n\ stream.write (prompt)\n\ stream.flush ()\n\ try:\n\ line = sys.stdin.readline()\n\ except KeyboardInterrupt:\n\ line = \" \\n\"\n\ except (SystemExit, EOFError):\n\ line = \"quit()\\n\"\n\ if not line:\n\ raise EOFError\n\ if line[-1] == '\\n':\n\ line = line[:-1]\n\ return line\n\ \n\ def read_py_command(self):\n\ # Read off a complete Python command.\n\ more = 0\n\ while 1:\n\ if more:\n\ prompt = sys.ps2\n\ else:\n\ prompt = sys.ps1\n\ line = self.my_raw_input(prompt)\n\ # Can be None if sys.stdin was redefined\n\ encoding = getattr(sys.stdin, \"encoding\", None)\n\ if encoding and not isinstance(line, unicode):\n\ line = line.decode(encoding)\n\ line = self.process_input (line)\n\ more = self.push(line)\n\ if not more:\n\ break\n\ \n\ def one_line (self, input):\n\ line = self.process_input (input)\n\ more = self.push(line)\n\ if more:\n\ self.write (\"Input not a complete line.\")\n\ self.resetbuffer()\n\ more = 0\n\ \n\ def run_python_interpreter (dict):\n\ # Pass in the dictionary, for continuity from one session to the next.\n\ repl = SimpleREPL('>>> ', dict)\n\ repl.interact()\n\ \n\ def run_one_line (dict, input_string):\n\ repl = SimpleREPL ('', dict)\n\ repl.one_line (input_string)\n"; static int _check_and_flush (FILE *stream) { int prev_fail = ferror (stream); return fflush (stream) || prev_fail ? EOF : 0; } static Predicate & PythonMutexPredicate () { static lldb_private::Predicate g_interpreter_is_running (LLDB_INVALID_THREAD_ID); return g_interpreter_is_running; } static bool CurrentThreadHasPythonLock () { TimeValue timeout; timeout = TimeValue::Now(); // Don't wait any time. return PythonMutexPredicate().WaitForValueEqualTo (Host::GetCurrentThreadID(), &timeout, NULL); } static bool GetPythonLock (uint32_t seconds_to_wait) { TimeValue timeout; if (seconds_to_wait != UINT32_MAX) { timeout = TimeValue::Now(); timeout.OffsetWithSeconds (seconds_to_wait); } return PythonMutexPredicate().WaitForValueEqualToAndSetValueTo (LLDB_INVALID_THREAD_ID, Host::GetCurrentThreadID(), &timeout, NULL); } static void ReleasePythonLock () { PythonMutexPredicate().SetValue (LLDB_INVALID_THREAD_ID, eBroadcastAlways); } ScriptInterpreterPython::ScriptInterpreterPython (CommandInterpreter &interpreter) : ScriptInterpreter (interpreter, eScriptLanguagePython), m_embedded_python_pty (), m_embedded_thread_input_reader_sp (), m_dbg_stdout (interpreter.GetDebugger().GetOutputFile().GetStream()), m_new_sysout (NULL), m_dictionary_name (interpreter.GetDebugger().GetInstanceName().AsCString()), m_terminal_state (), m_session_is_active (false), m_pty_slave_is_open (false), m_valid_session (true) { static int g_initialized = false; if (!g_initialized) { g_initialized = true; ScriptInterpreterPython::Initialize (); } bool safe_to_run = false; bool need_to_release_lock = true; int interval = 5; // Number of seconds to try getting the Python lock before timing out. // We don't dare exit this function without finishing setting up the script interpreter, so we must wait until // we can get the Python lock. if (CurrentThreadHasPythonLock()) { safe_to_run = true; need_to_release_lock = false; } while (!safe_to_run) { safe_to_run = GetPythonLock (interval); if (!safe_to_run) { FILE *tmp_fh = (m_dbg_stdout ? m_dbg_stdout : stdout); fprintf (tmp_fh, "Python interpreter is locked on another thread; " "please release interpreter in order to continue.\n"); interval = interval * 2; } } m_dictionary_name.append("_dict"); StreamString run_string; run_string.Printf ("%s = dict()", m_dictionary_name.c_str()); PyRun_SimpleString (run_string.GetData()); run_string.Clear(); run_string.Printf ("run_one_line (%s, 'import sys')", m_dictionary_name.c_str()); PyRun_SimpleString (run_string.GetData()); // Importing 'lldb' module calls SBDebugger::Initialize, which calls Debugger::Initialize, which increments a // global debugger ref-count; therefore we need to check the ref-count before and after importing lldb, and if the // ref-count increased we need to call Debugger::Terminate here to decrement the ref-count so that when the final // call to Debugger::Terminate is made, the ref-count has the correct value. // // Bonus question: Why doesn't the ref-count always increase? Because sometimes lldb has already been imported, in // which case the code inside it, including the call to SBDebugger::Initialize(), does not get executed. int old_count = Debugger::TestDebuggerRefCount(); run_string.Clear(); run_string.Printf ("run_one_line (%s, 'import lldb')", m_dictionary_name.c_str()); PyRun_SimpleString (run_string.GetData()); int new_count = Debugger::TestDebuggerRefCount(); if (new_count > old_count) Debugger::Terminate(); run_string.Clear(); run_string.Printf ("run_one_line (%s, 'import copy')", m_dictionary_name.c_str()); PyRun_SimpleString (run_string.GetData()); run_string.Clear(); run_string.Printf ("run_one_line (%s, 'lldb.debugger_unique_id = %d')", m_dictionary_name.c_str(), interpreter.GetDebugger().GetID()); PyRun_SimpleString (run_string.GetData()); if (m_dbg_stdout != NULL) { m_new_sysout = PyFile_FromFile (m_dbg_stdout, (char *) "", (char *) "w", _check_and_flush); } if (need_to_release_lock) ReleasePythonLock(); } ScriptInterpreterPython::~ScriptInterpreterPython () { Debugger &debugger = GetCommandInterpreter().GetDebugger(); if (m_embedded_thread_input_reader_sp.get() != NULL) { m_embedded_thread_input_reader_sp->SetIsDone (true); m_embedded_python_pty.CloseSlaveFileDescriptor(); m_pty_slave_is_open = false; const InputReaderSP reader_sp = m_embedded_thread_input_reader_sp; m_embedded_thread_input_reader_sp.reset(); debugger.PopInputReader (reader_sp); } if (m_new_sysout) { FILE *tmp_fh = (m_dbg_stdout ? m_dbg_stdout : stdout); if (!CurrentThreadHasPythonLock ()) { while (!GetPythonLock (1)) fprintf (tmp_fh, "Python interpreter locked on another thread; waiting to acquire lock...\n"); Py_DECREF (m_new_sysout); ReleasePythonLock (); } else Py_DECREF (m_new_sysout); } } void ScriptInterpreterPython::ResetOutputFileHandle (FILE *fh) { if (fh == NULL) return; m_dbg_stdout = fh; FILE *tmp_fh = (m_dbg_stdout ? m_dbg_stdout : stdout); if (!CurrentThreadHasPythonLock ()) { while (!GetPythonLock (1)) fprintf (tmp_fh, "Python interpreter locked on another thread; waiting to acquire lock...\n"); EnterSession (); m_new_sysout = PyFile_FromFile (m_dbg_stdout, (char *) "", (char *) "w", _check_and_flush); LeaveSession (); ReleasePythonLock (); } else { EnterSession (); m_new_sysout = PyFile_FromFile (m_dbg_stdout, (char *) "", (char *) "w", _check_and_flush); LeaveSession (); } } void ScriptInterpreterPython::SaveTerminalState (int fd) { // Python mucks with the terminal state of STDIN. If we can possibly avoid // this by setting the file handles up correctly prior to entering the // interpreter we should. For now we save and restore the terminal state // on the input file handle. m_terminal_state.Save (fd, false); } void ScriptInterpreterPython::RestoreTerminalState () { // Python mucks with the terminal state of STDIN. If we can possibly avoid // this by setting the file handles up correctly prior to entering the // interpreter we should. For now we save and restore the terminal state // on the input file handle. m_terminal_state.Restore(); } void ScriptInterpreterPython::LeaveSession () { m_session_is_active = false; } void ScriptInterpreterPython::EnterSession () { // If we have already entered the session, without having officially 'left' it, then there is no need to // 'enter' it again. if (m_session_is_active) return; m_session_is_active = true; StreamString run_string; run_string.Printf ("run_one_line (%s, 'lldb.debugger_unique_id = %d')", m_dictionary_name.c_str(), GetCommandInterpreter().GetDebugger().GetID()); PyRun_SimpleString (run_string.GetData()); PyObject *sysmod = PyImport_AddModule ("sys"); PyObject *sysdict = PyModule_GetDict (sysmod); if ((m_new_sysout != NULL) && (sysmod != NULL) && (sysdict != NULL)) PyDict_SetItemString (sysdict, "stdout", m_new_sysout); if (PyErr_Occurred()) PyErr_Clear (); if (!m_pty_slave_is_open) { run_string.Clear(); run_string.Printf ("run_one_line (%s, \"new_stdin = open('%s', 'r')\")", m_dictionary_name.c_str(), m_pty_slave_name.c_str()); PyRun_SimpleString (run_string.GetData()); m_pty_slave_is_open = true; run_string.Clear(); run_string.Printf ("run_one_line (%s, 'sys.stdin = new_stdin')", m_dictionary_name.c_str()); PyRun_SimpleString (run_string.GetData()); } } bool ScriptInterpreterPython::ExecuteOneLine (const char *command, CommandReturnObject *result) { if (!m_valid_session) return false; // We want to call run_one_line, passing in the dictionary and the command string. We cannot do this through // PyRun_SimpleString here because the command string may contain escaped characters, and putting it inside // another string to pass to PyRun_SimpleString messes up the escaping. So we use the following more complicated // method to pass the command string directly down to Python. bool need_to_release_lock = true; if (CurrentThreadHasPythonLock()) need_to_release_lock = false; else if (!GetPythonLock (1)) { fprintf ((m_dbg_stdout ? m_dbg_stdout : stdout), "Python interpreter is currently locked by another thread; unable to process command.\n"); return false; } EnterSession (); bool success = false; if (command) { // Find the correct script interpreter dictionary in the main module. PyObject *main_mod = PyImport_AddModule ("__main__"); PyObject *script_interpreter_dict = NULL; if (main_mod != NULL) { PyObject *main_dict = PyModule_GetDict (main_mod); if ((main_dict != NULL) && PyDict_Check (main_dict)) { // Go through the main dictionary looking for the correct python script interpreter dictionary PyObject *key, *value; Py_ssize_t pos = 0; while (PyDict_Next (main_dict, &pos, &key, &value)) { // We have stolen references to the key and value objects in the dictionary; we need to increment // them now so that Python's garbage collector doesn't collect them out from under us. Py_INCREF (key); Py_INCREF (value); if (strcmp (PyString_AsString (key), m_dictionary_name.c_str()) == 0) { script_interpreter_dict = value; break; } } } if (script_interpreter_dict != NULL) { PyObject *pfunc = NULL; PyObject *pmod = PyImport_AddModule ("embedded_interpreter"); if (pmod != NULL) { PyObject *pmod_dict = PyModule_GetDict (pmod); if ((pmod_dict != NULL) && PyDict_Check (pmod_dict)) { PyObject *key, *value; Py_ssize_t pos = 0; while (PyDict_Next (pmod_dict, &pos, &key, &value)) { Py_INCREF (key); Py_INCREF (value); if (strcmp (PyString_AsString (key), "run_one_line") == 0) { pfunc = value; break; } } PyObject *string_arg = PyString_FromString (command); if (pfunc && string_arg && PyCallable_Check (pfunc)) { PyObject *pargs = PyTuple_New (2); if (pargs != NULL) { PyTuple_SetItem (pargs, 0, script_interpreter_dict); PyTuple_SetItem (pargs, 1, string_arg); PyObject *pvalue = PyObject_CallObject (pfunc, pargs); Py_DECREF (pargs); if (pvalue != NULL) { Py_DECREF (pvalue); success = true; } else if (PyErr_Occurred ()) { PyErr_Print(); PyErr_Clear(); } } } } } Py_INCREF (script_interpreter_dict); } } LeaveSession (); if (need_to_release_lock) ReleasePythonLock(); if (success) return true; // The one-liner failed. Append the error message. if (result) result->AppendErrorWithFormat ("python failed attempting to evaluate '%s'\n", command); return false; } LeaveSession (); if (need_to_release_lock) ReleasePythonLock (); if (result) result->AppendError ("empty command passed to python\n"); return false; } size_t ScriptInterpreterPython::InputReaderCallback ( void *baton, InputReader &reader, InputReaderAction notification, const char *bytes, size_t bytes_len ) { lldb::thread_t embedded_interpreter_thread; LogSP log (lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_SCRIPT)); if (baton == NULL) return 0; ScriptInterpreterPython *script_interpreter = (ScriptInterpreterPython *) baton; if (script_interpreter->m_script_lang != eScriptLanguagePython) return 0; File &out_file = reader.GetDebugger().GetOutputFile(); switch (notification) { case eInputReaderActivate: { out_file.Printf ("Python Interactive Interpreter. To exit, type 'quit()', 'exit()' or Ctrl-D.\n"); // Save terminal settings if we can int input_fd = reader.GetDebugger().GetInputFile().GetDescriptor(); if (input_fd == File::kInvalidDescriptor) input_fd = STDIN_FILENO; script_interpreter->SaveTerminalState(input_fd); if (!CurrentThreadHasPythonLock()) { while (!GetPythonLock(1)) { out_file.Printf ("Python interpreter locked on another thread; waiting to acquire lock...\n"); } script_interpreter->EnterSession (); ReleasePythonLock(); } else script_interpreter->EnterSession (); char error_str[1024]; if (script_interpreter->m_embedded_python_pty.OpenFirstAvailableMaster (O_RDWR|O_NOCTTY, error_str, sizeof(error_str))) { if (log) log->Printf ("ScriptInterpreterPython::InputReaderCallback, Activate, succeeded in opening master pty (fd = %d).", script_interpreter->m_embedded_python_pty.GetMasterFileDescriptor()); embedded_interpreter_thread = Host::ThreadCreate ("", ScriptInterpreterPython::RunEmbeddedPythonInterpreter, script_interpreter, NULL); if (IS_VALID_LLDB_HOST_THREAD(embedded_interpreter_thread)) { if (log) log->Printf ("ScriptInterpreterPython::InputReaderCallback, Activate, succeeded in creating thread (thread = %d)", embedded_interpreter_thread); Error detach_error; Host::ThreadDetach (embedded_interpreter_thread, &detach_error); } else { if (log) log->Printf ("ScriptInterpreterPython::InputReaderCallback, Activate, failed in creating thread"); reader.SetIsDone (true); } } else { if (log) log->Printf ("ScriptInterpreterPython::InputReaderCallback, Activate, failed to open master pty "); reader.SetIsDone (true); } } break; case eInputReaderDeactivate: script_interpreter->LeaveSession (); break; case eInputReaderReactivate: if (!CurrentThreadHasPythonLock()) { while (!GetPythonLock(1)) { // Wait until lock is acquired. } script_interpreter->EnterSession (); ReleasePythonLock(); } else script_interpreter->EnterSession (); break; case eInputReaderInterrupt: ::write (script_interpreter->m_embedded_python_pty.GetMasterFileDescriptor(), "raise KeyboardInterrupt\n", 24); break; case eInputReaderEndOfFile: ::write (script_interpreter->m_embedded_python_pty.GetMasterFileDescriptor(), "quit()\n", 7); break; case eInputReaderGotToken: if (script_interpreter->m_embedded_python_pty.GetMasterFileDescriptor() != -1) { if (log) log->Printf ("ScriptInterpreterPython::InputReaderCallback, GotToken, bytes='%s', byte_len = %d", bytes, bytes_len); if (bytes && bytes_len) { if ((int) bytes[0] == 4) ::write (script_interpreter->m_embedded_python_pty.GetMasterFileDescriptor(), "quit()", 6); else ::write (script_interpreter->m_embedded_python_pty.GetMasterFileDescriptor(), bytes, bytes_len); } ::write (script_interpreter->m_embedded_python_pty.GetMasterFileDescriptor(), "\n", 1); } else { if (log) log->Printf ("ScriptInterpreterPython::InputReaderCallback, GotToken, bytes='%s', byte_len = %d, Master File Descriptor is bad.", bytes, bytes_len); reader.SetIsDone (true); } break; case eInputReaderDone: script_interpreter->LeaveSession (); // Restore terminal settings if they were validly saved if (log) log->Printf ("ScriptInterpreterPython::InputReaderCallback, Done, closing down input reader."); script_interpreter->RestoreTerminalState (); script_interpreter->m_embedded_python_pty.CloseMasterFileDescriptor(); break; } return bytes_len; } void ScriptInterpreterPython::ExecuteInterpreterLoop () { Timer scoped_timer (__PRETTY_FUNCTION__, __PRETTY_FUNCTION__); Debugger &debugger = GetCommandInterpreter().GetDebugger(); // At the moment, the only time the debugger does not have an input file handle is when this is called // directly from Python, in which case it is both dangerous and unnecessary (not to mention confusing) to // try to embed a running interpreter loop inside the already running Python interpreter loop, so we won't // do it. if (!debugger.GetInputFile().IsValid()) return; InputReaderSP reader_sp (new InputReader(debugger)); if (reader_sp) { Error error (reader_sp->Initialize (ScriptInterpreterPython::InputReaderCallback, this, // baton eInputReaderGranularityLine, // token size, to pass to callback function NULL, // end token NULL, // prompt true)); // echo input if (error.Success()) { debugger.PushInputReader (reader_sp); m_embedded_thread_input_reader_sp = reader_sp; } } } bool ScriptInterpreterPython::ExecuteOneLineWithReturn (const char *in_string, ScriptInterpreter::ReturnType return_type, void *ret_value) { bool need_to_release_lock = true; if (CurrentThreadHasPythonLock()) need_to_release_lock = false; else if (!GetPythonLock (1)) { fprintf ((m_dbg_stdout ? m_dbg_stdout : stdout), "Python interpreter is currently locked by another thread; unable to process command.\n"); return false; } EnterSession (); PyObject *py_return = NULL; PyObject *mainmod = PyImport_AddModule ("__main__"); PyObject *globals = PyModule_GetDict (mainmod); PyObject *locals = NULL; PyObject *py_error = NULL; bool ret_success; bool should_decrement_locals = false; int success; if (PyDict_Check (globals)) { PyObject *key, *value; Py_ssize_t pos = 0; int i = 0; while (PyDict_Next (globals, &pos, &key, &value)) { // We have stolen references to the key and value objects in the dictionary; we need to increment them now // so that Python's garbage collector doesn't collect them out from under us. Py_INCREF (key); Py_INCREF (value); char *c_str = PyString_AsString (key); if (strcmp (c_str, m_dictionary_name.c_str()) == 0) locals = value; ++i; } } if (locals == NULL) { locals = PyObject_GetAttrString (globals, m_dictionary_name.c_str()); should_decrement_locals = true; } if (locals == NULL) { locals = globals; should_decrement_locals = false; } py_error = PyErr_Occurred(); if (py_error != NULL) PyErr_Clear(); if (in_string != NULL) { py_return = PyRun_String (in_string, Py_eval_input, globals, locals); if (py_return == NULL) { py_error = PyErr_Occurred (); if (py_error != NULL) PyErr_Clear (); py_return = PyRun_String (in_string, Py_single_input, globals, locals); } if (locals != NULL && should_decrement_locals) Py_DECREF (locals); if (py_return != NULL) { switch (return_type) { case eCharPtr: // "char *" { const char format[3] = "s#"; success = PyArg_Parse (py_return, format, (char **) &ret_value); break; } case eBool: { const char format[2] = "b"; success = PyArg_Parse (py_return, format, (bool *) ret_value); break; } case eShortInt: { const char format[2] = "h"; success = PyArg_Parse (py_return, format, (short *) ret_value); break; } case eShortIntUnsigned: { const char format[2] = "H"; success = PyArg_Parse (py_return, format, (unsigned short *) ret_value); break; } case eInt: { const char format[2] = "i"; success = PyArg_Parse (py_return, format, (int *) ret_value); break; } case eIntUnsigned: { const char format[2] = "I"; success = PyArg_Parse (py_return, format, (unsigned int *) ret_value); break; } case eLongInt: { const char format[2] = "l"; success = PyArg_Parse (py_return, format, (long *) ret_value); break; } case eLongIntUnsigned: { const char format[2] = "k"; success = PyArg_Parse (py_return, format, (unsigned long *) ret_value); break; } case eLongLong: { const char format[2] = "L"; success = PyArg_Parse (py_return, format, (long long *) ret_value); break; } case eLongLongUnsigned: { const char format[2] = "K"; success = PyArg_Parse (py_return, format, (unsigned long long *) ret_value); break; } case eFloat: { const char format[2] = "f"; success = PyArg_Parse (py_return, format, (float *) ret_value); break; } case eDouble: { const char format[2] = "d"; success = PyArg_Parse (py_return, format, (double *) ret_value); break; } case eChar: { const char format[2] = "c"; success = PyArg_Parse (py_return, format, (char *) ret_value); break; } default: {} } Py_DECREF (py_return); if (success) ret_success = true; else ret_success = false; } } py_error = PyErr_Occurred(); if (py_error != NULL) { if (PyErr_GivenExceptionMatches (py_error, PyExc_SyntaxError)) PyErr_Print (); PyErr_Clear(); ret_success = false; } LeaveSession (); if (need_to_release_lock) ReleasePythonLock(); return ret_success; } bool ScriptInterpreterPython::ExecuteMultipleLines (const char *in_string) { FILE *tmp_fh = (m_dbg_stdout ? m_dbg_stdout : stdout); bool need_to_release_lock = true; if (CurrentThreadHasPythonLock()) need_to_release_lock = false; else { while (!GetPythonLock (1)) fprintf (tmp_fh, "Python interpreter locked on another thread; waiting to acquire lock...\n"); } EnterSession (); bool success = false; PyObject *py_return = NULL; PyObject *mainmod = PyImport_AddModule ("__main__"); PyObject *globals = PyModule_GetDict (mainmod); PyObject *locals = NULL; PyObject *py_error = NULL; bool should_decrement_locals = false; if (PyDict_Check (globals)) { PyObject *key, *value; Py_ssize_t pos = 0; while (PyDict_Next (globals, &pos, &key, &value)) { // We have stolen references to the key and value objects in the dictionary; we need to increment them now // so that Python's garbage collector doesn't collect them out from under us. Py_INCREF (key); Py_INCREF (value); if (strcmp (PyString_AsString (key), m_dictionary_name.c_str()) == 0) locals = value; } } if (locals == NULL) { locals = PyObject_GetAttrString (globals, m_dictionary_name.c_str()); should_decrement_locals = true; } if (locals == NULL) { locals = globals; should_decrement_locals = false; } py_error = PyErr_Occurred(); if (py_error != NULL) PyErr_Clear(); if (in_string != NULL) { struct _node *compiled_node = PyParser_SimpleParseString (in_string, Py_file_input); if (compiled_node) { PyCodeObject *compiled_code = PyNode_Compile (compiled_node, "temp.py"); if (compiled_code) { py_return = PyEval_EvalCode (compiled_code, globals, locals); if (py_return != NULL) { success = true; Py_DECREF (py_return); } if (locals && should_decrement_locals) Py_DECREF (locals); } } } py_error = PyErr_Occurred (); if (py_error != NULL) { if (PyErr_GivenExceptionMatches (py_error, PyExc_SyntaxError)) PyErr_Print (); PyErr_Clear(); success = false; } LeaveSession (); if (need_to_release_lock) ReleasePythonLock(); return success; } static const char *g_reader_instructions = "Enter your Python command(s). Type 'DONE' to end."; size_t ScriptInterpreterPython::GenerateBreakpointOptionsCommandCallback ( void *baton, InputReader &reader, InputReaderAction notification, const char *bytes, size_t bytes_len ) { static StringList commands_in_progress; File &out_file = reader.GetDebugger().GetOutputFile(); switch (notification) { case eInputReaderActivate: { commands_in_progress.Clear(); if (out_file.IsValid()) { out_file.Printf ("%s\n", g_reader_instructions); if (reader.GetPrompt()) out_file.Printf ("%s", reader.GetPrompt()); out_file.Flush (); } } break; case eInputReaderDeactivate: break; case eInputReaderReactivate: if (reader.GetPrompt() && out_file.IsValid()) { out_file.Printf ("%s", reader.GetPrompt()); out_file.Flush (); } break; case eInputReaderGotToken: { std::string temp_string (bytes, bytes_len); commands_in_progress.AppendString (temp_string.c_str()); if (out_file.IsValid() && !reader.IsDone() && reader.GetPrompt()) { out_file.Printf ("%s", reader.GetPrompt()); out_file.Flush (); } } break; case eInputReaderEndOfFile: case eInputReaderInterrupt: // Control-c (SIGINT) & control-d both mean finish & exit. reader.SetIsDone(true); // Control-c (SIGINT) ALSO means cancel; do NOT create a breakpoint command. if (notification == eInputReaderInterrupt) commands_in_progress.Clear(); // Fall through here... case eInputReaderDone: { BreakpointOptions *bp_options = (BreakpointOptions *)baton; std::auto_ptr data_ap(new BreakpointOptions::CommandData()); data_ap->user_source.AppendList (commands_in_progress); if (data_ap.get()) { ScriptInterpreter *interpreter = reader.GetDebugger().GetCommandInterpreter().GetScriptInterpreter(); if (interpreter) { if (interpreter->GenerateBreakpointCommandCallbackData (data_ap->user_source, data_ap->script_source)) { if (data_ap->script_source.GetSize() == 1) { BatonSP baton_sp (new BreakpointOptions::CommandBaton (data_ap.release())); bp_options->SetCallback (ScriptInterpreterPython::BreakpointCallbackFunction, baton_sp); } } else out_file.Printf ("Warning: No command attached to breakpoint.\n"); } else { // FIXME: Error processing. } } } break; } return bytes_len; } void ScriptInterpreterPython::CollectDataForBreakpointCommandCallback (BreakpointOptions *bp_options, CommandReturnObject &result) { Debugger &debugger = GetCommandInterpreter().GetDebugger(); InputReaderSP reader_sp (new InputReader (debugger)); if (reader_sp) { Error err = reader_sp->Initialize ( ScriptInterpreterPython::GenerateBreakpointOptionsCommandCallback, bp_options, // baton eInputReaderGranularityLine, // token size, for feeding data to callback function "DONE", // end token "> ", // prompt true); // echo input if (err.Success()) debugger.PushInputReader (reader_sp); else { result.AppendError (err.AsCString()); result.SetStatus (eReturnStatusFailed); } } else { result.AppendError("out of memory"); result.SetStatus (eReturnStatusFailed); } } // Set a Python one-liner as the callback for the breakpoint. void ScriptInterpreterPython::SetBreakpointCommandCallback (BreakpointOptions *bp_options, const char *oneliner) { std::auto_ptr data_ap(new BreakpointOptions::CommandData()); // It's necessary to set both user_source and script_source to the oneliner. // The former is used to generate callback description (as in breakpoint command list) // while the latter is used for Python to interpret during the actual callback. data_ap->user_source.AppendString (oneliner); if (GenerateBreakpointCommandCallbackData (data_ap->user_source, data_ap->script_source)) { if (data_ap->script_source.GetSize() == 1) { BatonSP baton_sp (new BreakpointOptions::CommandBaton (data_ap.release())); bp_options->SetCallback (ScriptInterpreterPython::BreakpointCallbackFunction, baton_sp); } } return; } bool ScriptInterpreterPython::ExportFunctionDefinitionToInterpreter (StringList &function_def) { // Convert StringList to one long, newline delimited, const char *. std::string function_def_string; int num_lines = function_def.GetSize(); for (int i = 0; i < num_lines; ++i) { function_def_string.append (function_def.GetStringAtIndex(i)); if (function_def_string.at (function_def_string.length() - 1) != '\n') function_def_string.append ("\n"); } return ExecuteMultipleLines (function_def_string.c_str()); } bool ScriptInterpreterPython::GenerateBreakpointCommandCallbackData (StringList &user_input, StringList &callback_data) { static int num_created_functions = 0; user_input.RemoveBlankLines (); int num_lines = user_input.GetSize (); StreamString sstr; // Check to see if we have any data; if not, just return. if (user_input.GetSize() == 0) return false; // Take what the user wrote, wrap it all up inside one big auto-generated Python function, passing in the // frame and breakpoint location as parameters to the function. sstr.Printf ("lldb_autogen_python_bp_callback_func_%d", num_created_functions); ++num_created_functions; std::string auto_generated_function_name = sstr.GetData(); sstr.Clear(); StringList auto_generated_function; // Create the function name & definition string. sstr.Printf ("def %s (frame, bp_loc, dict):", auto_generated_function_name.c_str()); auto_generated_function.AppendString (sstr.GetData()); // Pre-pend code for setting up the session dictionary. auto_generated_function.AppendString (" global_dict = globals()"); // Grab the global dictionary auto_generated_function.AppendString (" new_keys = dict.keys()"); // Make a list of keys in the session dict auto_generated_function.AppendString (" old_keys = global_dict.keys()"); // Save list of keys in global dict auto_generated_function.AppendString (" global_dict.update (dict)"); // Add the session dictionary to the // global dictionary. // Wrap everything up inside the function, increasing the indentation. for (int i = 0; i < num_lines; ++i) { sstr.Clear (); sstr.Printf (" %s", user_input.GetStringAtIndex (i)); auto_generated_function.AppendString (sstr.GetData()); } // Append code to clean up the global dictionary and update the session dictionary (all updates in the function // got written to the values in the global dictionary, not the session dictionary). auto_generated_function.AppendString (" for key in new_keys:"); // Iterate over all the keys from session dict auto_generated_function.AppendString (" dict[key] = global_dict[key]"); // Update session dict values auto_generated_function.AppendString (" if key not in old_keys:"); // If key was not originally in global dict auto_generated_function.AppendString (" del global_dict[key]"); // ...then remove key/value from global dict // Verify that the results are valid Python. if (!ExportFunctionDefinitionToInterpreter (auto_generated_function)) { return false; } // Store the name of the auto-generated function to be called. callback_data.AppendString (auto_generated_function_name.c_str()); return true; } bool ScriptInterpreterPython::BreakpointCallbackFunction ( void *baton, StoppointCallbackContext *context, user_id_t break_id, user_id_t break_loc_id ) { BreakpointOptions::CommandData *bp_option_data = (BreakpointOptions::CommandData *) baton; const char *python_function_name = bp_option_data->script_source.GetStringAtIndex (0); if (!context) return true; Target *target = context->exe_ctx.target; if (!target) return true; Debugger &debugger = target->GetDebugger(); ScriptInterpreter *script_interpreter = debugger.GetCommandInterpreter().GetScriptInterpreter(); ScriptInterpreterPython *python_interpreter = (ScriptInterpreterPython *) script_interpreter; if (!script_interpreter) return true; if (python_function_name != NULL && python_function_name[0] != '\0') { Thread *thread = context->exe_ctx.thread; const StackFrameSP stop_frame_sp = thread->GetStackFrameSPForStackFramePtr (context->exe_ctx.frame); BreakpointSP breakpoint_sp = target->GetBreakpointByID (break_id); const BreakpointLocationSP bp_loc_sp = breakpoint_sp->FindLocationByID (break_loc_id); SBFrame sb_frame (stop_frame_sp); SBBreakpointLocation sb_bp_loc (bp_loc_sp); if (sb_bp_loc.IsValid() || sb_frame.IsValid()) { bool ret_val = true; FILE *tmp_fh = (python_interpreter->m_dbg_stdout ? python_interpreter->m_dbg_stdout : stdout); if (CurrentThreadHasPythonLock()) { python_interpreter->EnterSession (); ret_val = LLDBSWIGPythonBreakpointCallbackFunction(python_function_name, python_interpreter->m_dictionary_name.c_str(), sb_frame, sb_bp_loc); python_interpreter->LeaveSession (); } else { while (!GetPythonLock (1)) fprintf (tmp_fh, "Python interpreter locked on another thread; waiting to acquire lock...\n"); python_interpreter->EnterSession (); ret_val = LLDBSWIGPythonBreakpointCallbackFunction(python_function_name, python_interpreter->m_dictionary_name.c_str(), sb_frame, sb_bp_loc); python_interpreter->LeaveSession (); ReleasePythonLock (); } return ret_val; } } // We currently always true so we stop in case anything goes wrong when // trying to call the script function return true; } lldb::thread_result_t ScriptInterpreterPython::RunEmbeddedPythonInterpreter (lldb::thread_arg_t baton) { ScriptInterpreterPython *script_interpreter = (ScriptInterpreterPython *) baton; LogSP log (lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_SCRIPT)); if (log) log->Printf ("%p ScriptInterpreterPython::RunEmbeddedPythonInterpreter () thread starting...", baton); char error_str[1024]; const char *pty_slave_name = script_interpreter->m_embedded_python_pty.GetSlaveName (error_str, sizeof (error_str)); bool need_to_release_lock = true; bool safe_to_run = false; if (CurrentThreadHasPythonLock()) { safe_to_run = true; need_to_release_lock = false; } else { int interval = 1; safe_to_run = GetPythonLock (interval); while (!safe_to_run) { interval = interval * 2; safe_to_run = GetPythonLock (interval); } } if (pty_slave_name != NULL && safe_to_run) { StreamString run_string; script_interpreter->EnterSession (); run_string.Printf ("run_one_line (%s, 'save_stderr = sys.stderr')", script_interpreter->m_dictionary_name.c_str()); PyRun_SimpleString (run_string.GetData()); run_string.Clear (); run_string.Printf ("run_one_line (%s, 'sys.stderr = sys.stdout')", script_interpreter->m_dictionary_name.c_str()); PyRun_SimpleString (run_string.GetData()); run_string.Clear (); run_string.Printf ("run_one_line (%s, 'save_stdin = sys.stdin')", script_interpreter->m_dictionary_name.c_str()); PyRun_SimpleString (run_string.GetData()); run_string.Clear (); run_string.Printf ("run_one_line (%s, \"sys.stdin = open ('%s', 'r')\")", script_interpreter->m_dictionary_name.c_str(), pty_slave_name); PyRun_SimpleString (run_string.GetData()); run_string.Clear (); // The following call drops into the embedded interpreter loop and stays there until the // user chooses to exit from the Python interpreter. Py_BEGIN_ALLOW_THREADS PyGILState_STATE gstate = PyGILState_Ensure(); run_string.Printf ("run_python_interpreter (%s)", script_interpreter->m_dictionary_name.c_str()); PyRun_SimpleString (run_string.GetData()); run_string.Clear (); PyGILState_Release (gstate); Py_END_ALLOW_THREADS run_string.Printf ("run_one_line (%s, 'sys.stdin = save_stdin')", script_interpreter->m_dictionary_name.c_str()); PyRun_SimpleString (run_string.GetData()); run_string.Clear(); run_string.Printf ("run_one_line (%s, 'sys.stderr = save_stderr')", script_interpreter->m_dictionary_name.c_str()); PyRun_SimpleString (run_string.GetData()); run_string.Clear(); script_interpreter->LeaveSession (); } if (!safe_to_run) fprintf ((script_interpreter->m_dbg_stdout ? script_interpreter->m_dbg_stdout : stdout), "Python interpreter locked on another thread; unable to acquire lock.\n"); if (need_to_release_lock) ReleasePythonLock (); if (script_interpreter->m_embedded_thread_input_reader_sp) script_interpreter->m_embedded_thread_input_reader_sp->SetIsDone (true); script_interpreter->m_embedded_python_pty.CloseSlaveFileDescriptor(); script_interpreter->m_pty_slave_is_open = false; log = lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_SCRIPT); if (log) log->Printf ("%p ScriptInterpreterPython::RunEmbeddedPythonInterpreter () thread exiting...", baton); // Clean up the input reader and make the debugger pop it off the stack. Debugger &debugger = script_interpreter->GetCommandInterpreter().GetDebugger(); const InputReaderSP reader_sp = script_interpreter->m_embedded_thread_input_reader_sp; script_interpreter->m_embedded_thread_input_reader_sp.reset(); debugger.PopInputReader (reader_sp); return NULL; } void ScriptInterpreterPython::Initialize () { Timer scoped_timer (__PRETTY_FUNCTION__, __PRETTY_FUNCTION__); // Python will muck with STDIN terminal state, so save off any current TTY // settings so we can restore them. TerminalState stdin_tty_state; stdin_tty_state.Save(STDIN_FILENO, false); // Find the module that owns this code and use that path we get to // set the PYTHONPATH appropriately. FileSpec file_spec; char python_dir_path[PATH_MAX]; if (Host::GetLLDBPath (ePathTypePythonDir, file_spec)) { std::string python_path; const char *curr_python_path = ::getenv ("PYTHONPATH"); if (curr_python_path) { // We have a current value for PYTHONPATH, so lets append to it python_path.append (curr_python_path); } if (file_spec.GetPath(python_dir_path, sizeof (python_dir_path))) { if (!python_path.empty()) python_path.append (1, ':'); python_path.append (python_dir_path); } if (Host::GetLLDBPath (ePathTypeLLDBShlibDir, file_spec)) { if (file_spec.GetPath(python_dir_path, sizeof (python_dir_path))) { if (!python_path.empty()) python_path.append (1, ':'); python_path.append (python_dir_path); } } const char *pathon_path_env_cstr = python_path.c_str(); ::setenv ("PYTHONPATH", pathon_path_env_cstr, 1); } PyEval_InitThreads (); Py_Initialize (); PyObject *compiled_module = Py_CompileString (embedded_interpreter_string, "embedded_interpreter.py", Py_file_input); PyObject *py_error = PyErr_Occurred (); if (py_error != NULL) { PyErr_Print(); PyErr_Clear(); } // This function is in the C++ output file generated by SWIG after it is // run on all of the headers in "lldb/API/SB*.h" init_lldb (); // Update the path python uses to search for modules to include the current directory. int success = PyRun_SimpleString ("import sys"); success = PyRun_SimpleString ("sys.path.append ('.')"); PyObject *pmod = NULL; if (compiled_module) { pmod = PyImport_ExecCodeModule (const_cast ("embedded_interpreter"), compiled_module); Py_DECREF (compiled_module); } if (pmod != NULL) { PyRun_SimpleString ("from embedded_interpreter import run_python_interpreter"); PyRun_SimpleString ("from embedded_interpreter import run_one_line"); PyRun_SimpleString ("import sys"); PyRun_SimpleString ("from termios import *"); Py_DECREF (pmod); } stdin_tty_state.Restore(); } void ScriptInterpreterPython::Terminate () { // We are intentionally NOT calling Py_Finalize here (this would be the logical place to call it). Calling // Py_Finalize here causes test suite runs to seg fault: The test suite runs in Python. It registers // SBDebugger::Terminate to be called 'at_exit'. When the test suite Python harness finishes up, it calls // Py_Finalize, which calls all the 'at_exit' registered functions. SBDebugger::Terminate calls Debugger::Terminate, // which calls lldb::Terminate, which calls ScriptInterpreter::Terminate, which calls // ScriptInterpreterPython::Terminate. So if we call Py_Finalize here, we end up with Py_Finalize being called from // within Py_Finalize, which results in a seg fault. // // Since this function only gets called when lldb is shutting down and going away anyway, the fact that we don't // actually call Py_Finalize should not cause any problems (everything should shut down/go away anyway when the // process exits). // // Py_Finalize (); }