[LLDB/Python] Fix segfault on Python scripted breakpoints

[tammela]

Summary

The code that calls into the ScriptInterpreter was not considering the
case that it receives a Lua interpreter.

[JDevlieghere]

It appears there are many similar calls in this file, can you update those as well?

[labath]

In D92249#2421639, @JDevlieghere wrote:

It appears there are many similar calls in this file, can you update those as well?

If there are many of these calls, adding a static helper function for this purpose might be a good idea as well...

[tammela]

In D92249#2422205, @labath wrote:

In D92249#2421639, @JDevlieghere wrote:

It appears there are many similar calls in this file, can you update those as well?

If there are many of these calls, adding a static helper function for this purpose might be a good idea as well...

Yes, it looks like the same 3-line routine is being replicated across multiple functions. I will clean it up.

[tammela]

Addressing comments

[JDevlieghere]

Thanks! LGTM

lldb/source/Plugins/ScriptInterpreter/Python/ScriptInterpreterPython.cpp

 //===-- ScriptInterpreterPython.cpp ---------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Host/Config.h"
+#include "lldb/lldb-enumerations.h"
 
 #if LLDB_ENABLE_PYTHON
 
 // LLDB Python header must be included first
 #include "lldb-python.h"
 
 #include "PythonDataObjects.h"
 #include "PythonReadline.h"

 extern "C" bool LLDBSWIGPythonRunScriptKeywordValue(
     const char *python_function_name, const char *session_dictionary_name,
     lldb::ValueObjectSP &value, std::string &output);
 
 extern "C" void *
 LLDBSWIGPython_GetDynamicSetting(void *module, const char *setting,
                                  const lldb::TargetSP &target_sp);
 
+static ScriptInterpreterPythonImpl *GetPythonInterpreter(Debugger &debugger) {
+  ScriptInterpreter *script_interpreter =
+      debugger.GetScriptInterpreter(true, lldb::eScriptLanguagePython);
+  return static_cast<ScriptInterpreterPythonImpl *>(script_interpreter);
+}
+
 static bool g_initialized = false;
 
 namespace {
 
 // Initializing Python is not a straightforward process.  We cannot control
 // what external code may have done before getting to this point in LLDB,
 // including potentially having already initialized Python, so we need to do a
 // lot of work to ensure that the existing state of the system is maintained
StructuredData::ObjectSP ScriptInterpreterPythonImpl::CreateScriptedThreadPlan(
     std::string &error_str, lldb::ThreadPlanSP thread_plan_sp) {
   if (class_name == nullptr || class_name[0] == '\0')
     return StructuredData::ObjectSP();
 
   if (!thread_plan_sp.get())
     return {};
 
   Debugger &debugger = thread_plan_sp->GetTarget().GetDebugger();
-  ScriptInterpreter *script_interpreter = debugger.GetScriptInterpreter();
   ScriptInterpreterPythonImpl *python_interpreter =
-      static_cast<ScriptInterpreterPythonImpl *>(script_interpreter);
+      GetPythonInterpreter(debugger);
 
-  if (!script_interpreter)
+  if (!python_interpreter)
     return {};
 
   void *ret_val;
 
   {
     Locker py_lock(this,
                    Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
     ret_val = LLDBSwigPythonCreateScriptedThreadPlan(
ScriptInterpreterPythonImpl::CreateScriptedBreakpointResolver(
 
   if (class_name == nullptr || class_name[0] == '\0')
     return StructuredData::GenericSP();
 
   if (!bkpt_sp.get())
     return StructuredData::GenericSP();
 
   Debugger &debugger = bkpt_sp->GetTarget().GetDebugger();
-  ScriptInterpreter *script_interpreter = debugger.GetScriptInterpreter();
   ScriptInterpreterPythonImpl *python_interpreter =
-      static_cast<ScriptInterpreterPythonImpl *>(script_interpreter);
+      GetPythonInterpreter(debugger);
 
-  if (!script_interpreter)
+  if (!python_interpreter)
     return StructuredData::GenericSP();
 
   void *ret_val;
 
   {
     Locker py_lock(this,
                    Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
 
if (!target_sp) {
     return StructuredData::GenericSP();
   }
 
   if (class_name == nullptr || class_name[0] == '\0') {
     error.SetErrorString("No class name for scripted stop-hook.");
     return StructuredData::GenericSP();
   }
 
-  ScriptInterpreter *script_interpreter = m_debugger.GetScriptInterpreter();
   ScriptInterpreterPythonImpl *python_interpreter =
-      static_cast<ScriptInterpreterPythonImpl *>(script_interpreter);
+      GetPythonInterpreter(m_debugger);
 
-  if (!script_interpreter) {
+  if (!python_interpreter) {
     error.SetErrorString("No script interpreter for scripted stop-hook.");
     return StructuredData::GenericSP();
   }
 
   void *ret_val;
 
   {
     Locker py_lock(this,
ScriptInterpreterPythonImpl::CreateSyntheticScriptedProvider(
 
   ExecutionContext exe_ctx(valobj->GetExecutionContextRef());
   Target *target = exe_ctx.GetTargetPtr();
 
   if (!target)
     return StructuredData::ObjectSP();
 
   Debugger &debugger = target->GetDebugger();
-  ScriptInterpreter *script_interpreter = debugger.GetScriptInterpreter();
   ScriptInterpreterPythonImpl *python_interpreter =
-      (ScriptInterpreterPythonImpl *)script_interpreter;
+      GetPythonInterpreter(debugger);
 
-  if (!script_interpreter)
+  if (!python_interpreter)
     return StructuredData::ObjectSP();
 
   void *ret_val = nullptr;
 
   {
     Locker py_lock(this,
                    Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
     ret_val = LLDBSwigPythonCreateSyntheticProvider(
bool ScriptInterpreterPythonImpl::BreakpointCallbackFunction(
 
   ExecutionContext exe_ctx(context->exe_ctx_ref);
   Target *target = exe_ctx.GetTargetPtr();
 
   if (!target)
     return true;
 
   Debugger &debugger = target->GetDebugger();
-  ScriptInterpreter *script_interpreter = debugger.GetScriptInterpreter();
   ScriptInterpreterPythonImpl *python_interpreter =
-      (ScriptInterpreterPythonImpl *)script_interpreter;
+      GetPythonInterpreter(debugger);
 
-  if (!script_interpreter)
+  if (!python_interpreter)
     return true;
 
   if (python_function_name && python_function_name[0]) {
     const StackFrameSP stop_frame_sp(exe_ctx.GetFrameSP());
     BreakpointSP breakpoint_sp = target->GetBreakpointByID(break_id);
     if (breakpoint_sp) {
       const BreakpointLocationSP bp_loc_sp(
           breakpoint_sp->FindLocationByID(break_loc_id));
bool ScriptInterpreterPythonImpl::WatchpointCallbackFunction(
 
   ExecutionContext exe_ctx(context->exe_ctx_ref);
   Target *target = exe_ctx.GetTargetPtr();
 
   if (!target)
     return true;
 
   Debugger &debugger = target->GetDebugger();
-  ScriptInterpreter *script_interpreter = debugger.GetScriptInterpreter();
   ScriptInterpreterPythonImpl *python_interpreter =
-      (ScriptInterpreterPythonImpl *)script_interpreter;
+      GetPythonInterpreter(debugger);
 
-  if (!script_interpreter)
+  if (!python_interpreter)
     return true;
 
   if (python_function_name && python_function_name[0]) {
     const StackFrameSP stop_frame_sp(exe_ctx.GetFrameSP());
     WatchpointSP wp_sp = target->GetWatchpointList().FindByID(watch_id);
     if (wp_sp) {
       if (stop_frame_sp && wp_sp) {
         bool ret_val = true;

lldb/test/Shell/ScriptInterpreter/Python/scripted_breakpoint_lua.test

+# REQUIRES: python
+# UNSUPPORTED: lldb-repro
+#
+# RUN: cat %s | %lldb --script-language lua 2>&1 | FileCheck %s
+b main
+breakpoint command add -s python -o 'print(frame); return False'
+run
+# CHECK: frame #0