[lldb] make it easier to find LLDB's python

[lawrence_danna]

Summary

It is surprisingly difficult to write a simple python script that
can reliably import lldb without failing, or crashing. I'm
currently resorting to convolutions like this:

    def find_lldb(may_reexec=False):
		if prefix := os.environ.get('LLDB_PYTHON_PREFIX'):
			if os.path.realpath(prefix) != os.path.realpath(sys.prefix):
				raise Exception("cannot import lldb.\n"
					f"  sys.prefix should be: {prefix}\n"
					f"  but it is: {sys.prefix}")
		else:
			line1, line2 = subprocess.run(
				['lldb', '-x', '-b', '-o', 'script print(sys.prefix)'],
				encoding='utf8', stdout=subprocess.PIPE,
				check=True).stdout.strip().splitlines()
			assert line1.strip() == '(lldb) script print(sys.prefix)'
			prefix = line2.strip()
			os.environ['LLDB_PYTHON_PREFIX'] = prefix

		if sys.prefix != prefix:
			if not may_reexec:
				raise Exception(
					"cannot import lldb.\n" +
					f"  This python, at {sys.prefix}\n"
					f"  does not math LLDB's python at {prefix}")
			os.environ['LLDB_PYTHON_PREFIX'] = prefix
			python_exe = os.path.join(prefix, 'bin', 'python3')
			os.execl(python_exe, python_exe, *sys.argv)

		lldb_path = subprocess.run(['lldb', '-P'],
			check=True, stdout=subprocess.PIPE,
				encoding='utf8').stdout.strip()

		sys.path = [lldb_path] + sys.path

This patch aims to replace all that with:

#!/usr/bin/env lldb-python
import lldb
...

... by adding the following features:

• new command line option: --print-script-interpreter-info. This prints language-specific information about the script interpreter in JSON format.

• new tool (unix only): lldb-python which finds python and exec's it.

[JDevlieghere]

I feel like this puts too much Python specific logic in the driver compared to the convenience it brings. Even though we already leak python details (like --python-path), LLDB has always been designed to support several scripting languages. I'm not convinced this use case is compelling enough to make the situation worse.

FWIW crashlog.py has a good example of how to import LLDB. It's complicated slightly by us having to honor the LLDB_DEFAULT_PYTHON_VERSION, but otherwise it's pretty simple:

try:
    import lldb
except ImportError:
    lldb_python_path = subprocess.check_output(['xcrun', 'lldb', '-P']).decode("utf-8").strip()
    if os.path.exists(lldb_python_path) and not sys.path.__contains__(lldb_python_path):
        sys.path.append(lldb_python_path)
        import lldb

A potential alternative to this could be an lldb-python (python) script that reinvokes itself with the correct PYTHONPATH set?

[jingham]

Since you do need to match the lldb module to the python it was built against, this seems a useful addition.

The original --python-path was a bit unfortunate, we're supposed to be able to support multiple scripting interpreters (currently python & lua) and it would be annoying to have to add one of these variables for each scripting language we support. So it seems a shame to repeat that error.

Maybe it would be better to have:

--scripting-module-path {python, lua}

and

--scripting-executable-path {python, lua}

as the arguments to the driver (we'll have to keep the --python-path for compatibility.)

Seems like "where is your module" and "where is your executable" are also questions we should be asking the ScriptInterpreter base class, and not going straight to the Python interpreter.

[jingham]

In D112973#3101602, @JDevlieghere wrote:

I feel like this puts too much Python specific logic in the driver compared to the convenience it brings. Even though we already leak python details (like --python-path), LLDB has always been designed to support several scripting languages. I'm not convinced this use case is compelling enough to make the situation worse.

FWIW crashlog.py has a good example of how to import LLDB. It's complicated slightly by us having to honor the LLDB_DEFAULT_PYTHON_VERSION, but otherwise it's pretty simple:

try:
    import lldb
except ImportError:
    lldb_python_path = subprocess.check_output(['xcrun', 'lldb', '-P']).decode("utf-8").strip()
    if os.path.exists(lldb_python_path) and not sys.path.__contains__(lldb_python_path):
        sys.path.append(lldb_python_path)
        import lldb

A potential alternative to this could be an lldb-python (python) script that reinvokes itself with the correct PYTHONPATH set?

I don't think that fits exactly with what Larry's patch is doing. The lldb vrs. Python problem is two-fold, one problem is finding some lldb module somewhere, but the other is making sure that the python you pick (should you have multiple on your system) is the one that's going to work with the lldb module your lldb is going to find for you.

The solutions we have to this problem all assume you've ALREADY found the right python, now you just have to find some lldb module. OTOH lldb-python uses the Python library that lldb loads to find the right python executable and match it to the right lldb module.

This isn't 100% necessary: once you've found your lldb, you could just continue to use lldb, employing the script command to feed the Python interpreter. But I can see how you might want Python to be in control, and this solution makes that use case less error-prone.

[jingham]

But I do agree with Jonas that we should find a less python-specific way to implement this. I don't think you need to actually fill in the Lua parts, but whoever does that shouldn't have to copy everything that was done for python, a lot of this should be shareable.

[lawrence_danna]

In D112973#3101602, @JDevlieghere wrote:

FWIW crashlog.py has a good example of how to import LLDB. It's complicated slightly by us having to honor the LLDB_DEFAULT_PYTHON_VERSION, but otherwise it's pretty simple:

Unfortunately that is not enough to solve the problem, because if we run that script with the wrong version of python it will crash (see https://reviews.llvm.org/D112972)
Even if that bug is fixed, it will still raise an ImportError

A potential alternative to this could be an lldb-python (python) script that reinvokes itself with the correct PYTHONPATH set?

That approach would work, but I'd still need --python-prefix to find the right python. I'll update this diff tomorrow doing it that way.

[lawrence_danna]

change lldb-python into a script instead of a feature of Driver.cpp

[jingham]

I still don't think adding python specific ways of getting at generic ScriptInterpreter features (e.g. the path to the lldb module for that script interpreter - not your fault but... - and the path to the script's native script runner binary) with language specific affordances is the right way to continue...

These should be "--interpreter-prefix python" and --interpreter-prefix lua" and there should be a ScriptInterpreter::GetInterpreterPrefix(Language) or whatever to fetch the paths. Even most of the work your lldb-python does could probably work for Lua with just a few changes (like PYTHONPATH-> whatever that is for Lua...)

[JDevlieghere]

I was talking to Jim about this offline and one potential solution would be to have a flag that asks the current script interpreter for some of this relevant information. What that means would be different for every language, so the output would have to be able to define its own keys and values. (JSON could be a good candidate for this?) For Python, this would include the python path and the prefix, while for lua this might be something totally different. Both could include a version.

So the way I imagine this working is something like this:

$ lldb -l python --print-script-interpreter-info
{ 
  "prefix": "/foo/bar",
  "path": "/baz/quux",
   "version": "3.9"
}
$ lldb -l lua --print-script-interpreter-info
{ 
   "version": "5.4"
}

From an SB API perspective, this would be a function in SBDebugger that would return a string or populate a buffer. The driver would then simply print that, and the Python script would parse it and do the right thing.

WDYT?

[jingham]

I would do this:

lldb --print-script-interpreter-info python

making the interpreter the argument for this option. That seems clearer than having to provide two flags. language is overloaded anyway, because it can be a source language or a script interpreter language, so it might be better to side-step that one.

[lawrence_danna]

@JDevlieghere

That approach would work great for my purposes, i'll update like that.

[lawrence_danna]

updated according to reviewer feedback.

[lawrence_danna]

clang-format

[JDevlieghere]

Rather than percolating up a JSON string, we should use StructuredData (and SBStructuredData at the SB API layer) and only convert it to JSON at the very last moment.

lldb/tools/driver/Driver.cpp

411

[lawrence_danna]

changed internal apis to use StructuredData instead of char*

[JDevlieghere]

A few small nits but I'm very happy with the approach. Thanks Larry!

lldb/include/lldb/API/SBHostOS.h

23 ↗

(On Diff #386170)

Is still still relevant?

lldb/test/API/functionalities/paths/TestPaths.py

50

51

Might be nice to check that all the keys you expect for Python are in the structured data, either here or in a separate test.

[lawrence_danna]

cleanup

lldb/include/lldb/API/SBHostOS.h

23 ↗

(On Diff #386170)

nope.

[JDevlieghere]

LGTM

[stella.stamenova]

Windows buildbot is broken:

https://lab.llvm.org/buildbot/#/builders/83/builds/11865

[lawrence_danna]

In D112973#3122496, @stella.stamenova wrote:

Windows buildbot is broken:

https://lab.llvm.org/buildbot/#/builders/83/builds/11865

eek, sorry.

fix is here: https://reviews.llvm.org/D113650

lldb/bindings/interface/SBDebugger.i

#endif
     GetSummaryForType (lldb::SBTypeNameSpecifier);
 
     lldb::SBTypeFilter
     GetFilterForType (lldb::SBTypeNameSpecifier);
 
     lldb::SBTypeSynthetic
     GetSyntheticForType (lldb::SBTypeNameSpecifier);
 
+    SBStructuredData GetScriptInterpreterInfo(ScriptLanguage);
+
     STRING_EXTENSION(SBDebugger)
 
     %feature("docstring",
 "Launch a command interpreter session. Commands are read from standard input or
 from the input handle specified for the debugger object. Output/errors are
 similarly redirected to standard output/error or the configured handles.
 
 @param[in] auto_handle_events If true, automatically handle resulting events.

lldb/bindings/python/CMakeLists.txt

add_custom_command(
   VERBATIM
   COMMENT "Building LLDB Python wrapper")
 
 add_custom_target(swig_wrapper_python ALL DEPENDS
   ${CMAKE_CURRENT_BINARY_DIR}/LLDBWrapPython.cpp
   ${CMAKE_CURRENT_BINARY_DIR}/lldb.py
 )
 
+if (NOT WIN32)
+add_custom_command(
+  OUTPUT  ${LLVM_RUNTIME_OUTPUT_INTDIR}/lldb-python
+  VERBATIM
+  COMMAND ${CMAKE_COMMAND} -E copy lldb-python ${LLVM_RUNTIME_OUTPUT_INTDIR}/lldb-python
+  WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+)
+add_custom_target(lldb-python-wrapper ALL DEPENDS
+  ${LLVM_RUNTIME_OUTPUT_INTDIR}/lldb-python
+)
+endif()
+
 function(create_python_package swig_target working_dir pkg_dir)
   cmake_parse_arguments(ARG "NOINIT" "" "FILES" ${ARGN})
   if(ARG_FILES)
     set(copy_cmd COMMAND ${CMAKE_COMMAND} -E copy ${ARG_FILES} ${pkg_dir})
   endif()
   if(NOT ARG_NOINIT)
     set(init_cmd COMMAND ${Python3_EXECUTABLE}
         "${LLDB_SOURCE_DIR}/bindings/python/createPythonInit.py"
else()
       set(LIBLLDB_SYMLINK_OUTPUT_FILE "_lldb.pyd")
     endif()
   else()
     set(LIBLLDB_SYMLINK_OUTPUT_FILE "_lldb.so")
   endif()
   create_relative_symlink(${swig_target} ${LIBLLDB_SYMLINK_DEST}
                           ${lldb_python_target_dir} ${LIBLLDB_SYMLINK_OUTPUT_FILE})
 
+
+  if (NOT WIN32)
+  add_dependencies(${swig_target} lldb-python-wrapper)
+  endif()
+
   if(NOT LLDB_BUILD_FRAMEWORK)
     set(LLDB_ARGDUMPER_FILENAME "lldb-argdumper${CMAKE_EXECUTABLE_SUFFIX}")
     create_relative_symlink(${swig_target} "${LLVM_RUNTIME_OUTPUT_INTDIR}/${LLDB_ARGDUMPER_FILENAME}"
                             ${lldb_python_target_dir} ${LLDB_ARGDUMPER_FILENAME})
   endif()
 
   add_dependencies(${swig_target} swig_wrapper_python liblldb lldb-argdumper)
   set_target_properties(${swig_target} swig_wrapper_python PROPERTIES FOLDER "lldb misc")

lldb/bindings/python/lldb-python

+#!/usr/bin/env python3
+
+import subprocess
+import os
+import sys
+import json
+
+lldb = os.path.join(os.path.dirname(__file__), 'lldb')
+
+info_json = subprocess.run([lldb, "-l", "python", "-print-script-interpreter-info"],
+    check=True, stdout=subprocess.PIPE, encoding='utf8').stdout
+info = json.loads(info_json)
+
+os.environ["PYTHONPATH"] = (
+    info["lldb-pythonpath"] + os.path.pathsep + os.environ.get("PYTHONPATH", ""))
+
+os.execl(info["executable"], info["executable"], *sys.argv[1:])

lldb/docs/man/lldb.rst

 
 SCRIPTING
 ---------
 
 .. option:: -l <value>
 
  Alias for --script-language
 
+.. option:: --print-script-interpreter-info
+
+  Prints out a json dictionary with information about the scripting language interpreter.
+
 .. option:: --python-path
 
  Prints out the path to the lldb.py file for this version of lldb.
 
 .. option:: -P
 
  Alias for --python-path
 

lldb/include/lldb/API/SBDebugger.h

public:
   bool GetUseSourceCache() const;
 
   static bool GetDefaultArchitecture(char *arch_name, size_t arch_name_len);
 
   static bool SetDefaultArchitecture(const char *arch_name);
 
   lldb::ScriptLanguage GetScriptingLanguage(const char *script_language_name);
 
+  SBStructuredData GetScriptInterpreterInfo(ScriptLanguage);
+
   static const char *GetVersionString();
 
   static const char *StateAsCString(lldb::StateType state);
 
   static SBStructuredData GetBuildConfiguration();
 
   static bool StateIsRunningState(lldb::StateType state);
 

lldb/include/lldb/Interpreter/ScriptInterpreter.h

enum ScriptReturnType {
     eScriptReturnTypeOpaqueObject
   };
 
   ScriptInterpreter(
       Debugger &debugger, lldb::ScriptLanguage script_lang,
       lldb::ScriptedProcessInterfaceUP scripted_process_interface_up =
           std::make_unique<ScriptedProcessInterface>());
 
+  virtual StructuredData::DictionarySP GetInterpreterInfo();
+
   ~ScriptInterpreter() override = default;
 
   virtual bool Interrupt() { return false; }
 
   virtual bool ExecuteOneLine(
       llvm::StringRef command, CommandReturnObject *result,
       const ExecuteScriptOptions &options = ExecuteScriptOptions()) = 0;
 

lldb/source/API/SBDebugger.cpp

LLDB_RECORD_METHOD(lldb::ScriptLanguage, SBDebugger, GetScriptingLanguage,
                      (const char *), script_language_name);
 
   if (!script_language_name)
     return eScriptLanguageDefault;
   return OptionArgParser::ToScriptLanguage(
       llvm::StringRef(script_language_name), eScriptLanguageDefault, nullptr);
 }
 
+SBStructuredData
+SBDebugger::GetScriptInterpreterInfo(lldb::ScriptLanguage language) {
+  LLDB_RECORD_METHOD(SBStructuredData, SBDebugger, GetScriptInterpreterInfo,
+                     (lldb::ScriptLanguage), language);
+  SBStructuredData data;
+  if (m_opaque_sp) {
+    lldb_private::ScriptInterpreter *interp =
+        m_opaque_sp->GetScriptInterpreter(language);
+    if (interp) {
+      data.m_impl_up->SetObjectSP(interp->GetInterpreterInfo());
+    }
+  }
+  return LLDB_RECORD_RESULT(data);
+}
+
 const char *SBDebugger::GetVersionString() {
   LLDB_RECORD_STATIC_METHOD_NO_ARGS(const char *, SBDebugger, GetVersionString);
 
   return lldb_private::GetVersion();
 }
 
 const char *SBDebugger::StateAsCString(StateType state) {
   LLDB_RECORD_STATIC_METHOD(const char *, SBDebugger, StateAsCString,
template <> void RegisterMethods<SBDebugger>(Registry &R) {
   LLDB_REGISTER_METHOD(
       void, SBDebugger, HandleProcessEvent,
       (const lldb::SBProcess &, const lldb::SBEvent &, FileSP, FileSP));
   LLDB_REGISTER_METHOD(lldb::SBSourceManager, SBDebugger, GetSourceManager, ());
   LLDB_REGISTER_STATIC_METHOD(bool, SBDebugger, SetDefaultArchitecture,
                               (const char *));
   LLDB_REGISTER_METHOD(lldb::ScriptLanguage, SBDebugger, GetScriptingLanguage,
                        (const char *));
+  LLDB_REGISTER_METHOD(SBStructuredData, SBDebugger, GetScriptInterpreterInfo,
+                       (lldb::ScriptLanguage));
   LLDB_REGISTER_STATIC_METHOD(const char *, SBDebugger, GetVersionString, ());
   LLDB_REGISTER_STATIC_METHOD(const char *, SBDebugger, StateAsCString,
                               (lldb::StateType));
   LLDB_REGISTER_STATIC_METHOD(lldb::SBStructuredData, SBDebugger,
                               GetBuildConfiguration, ());
   LLDB_REGISTER_STATIC_METHOD(bool, SBDebugger, StateIsRunningState,
                               (lldb::StateType));
   LLDB_REGISTER_STATIC_METHOD(bool, SBDebugger, StateIsStoppedState,

lldb/source/Interpreter/ScriptInterpreter.cpp

 }
 
 void ScriptInterpreter::CollectDataForWatchpointCommandCallback(
     WatchpointOptions *bp_options, CommandReturnObject &result) {
   result.AppendError(
       "This script interpreter does not support watchpoint callbacks.");
 }
 
+StructuredData::DictionarySP ScriptInterpreter::GetInterpreterInfo() {
+  return nullptr;
+}
+
 bool ScriptInterpreter::LoadScriptingModule(const char *filename,
                                             const LoadScriptOptions &options,
                                             lldb_private::Status &error,
                                             StructuredData::ObjectSP *module_sp,
                                             FileSpec extra_search_dir) {
   error.SetErrorString(
       "This script interpreter does not support importing modules.");
   return false;

lldb/source/Plugins/ScriptInterpreter/Lua/ScriptInterpreterLua.h

public:
   void ExecuteInterpreterLoop() override;
 
   bool LoadScriptingModule(const char *filename,
                            const LoadScriptOptions &options,
                            lldb_private::Status &error,
                            StructuredData::ObjectSP *module_sp = nullptr,
                            FileSpec extra_search_dir = {}) override;
 
+  StructuredData::DictionarySP GetInterpreterInfo() override;
+
   // Static Functions
   static void Initialize();
 
   static void Terminate();
 
   static lldb::ScriptInterpreterSP CreateInstance(Debugger &debugger);
 
   static llvm::StringRef GetPluginNameStatic() { return "script-lua"; }

lldb/source/Plugins/ScriptInterpreter/Lua/ScriptInterpreterLua.cpp

 };
 
 ScriptInterpreterLua::ScriptInterpreterLua(Debugger &debugger)
     : ScriptInterpreter(debugger, eScriptLanguageLua),
       m_lua(std::make_unique<Lua>()) {}
 
 ScriptInterpreterLua::~ScriptInterpreterLua() = default;
 
+StructuredData::DictionarySP ScriptInterpreterLua::GetInterpreterInfo() {
+  auto info = std::make_shared<StructuredData::Dictionary>();
+  info->AddStringItem("language", "lua");
+  return info;
+}
+
 bool ScriptInterpreterLua::ExecuteOneLine(llvm::StringRef command,
                                           CommandReturnObject *result,
                                           const ExecuteScriptOptions &options) {
   if (command.empty()) {
     if (result)
       result->AppendError("empty command passed to lua\n");
     return false;
   }

lldb/source/Plugins/ScriptInterpreter/Python/PythonDataObjects.h

 class PythonObject;
 class PythonBytes;
 class PythonString;
 class PythonList;
 class PythonDictionary;
 class PythonInteger;
 class PythonException;
 
+class GIL {
+public:
+  GIL() {
+    m_state = PyGILState_Ensure();
+    assert(!PyErr_Occurred());
+  }
+  ~GIL() { PyGILState_Release(m_state); }
+
+protected:
+  PyGILState_STATE m_state;
+};
+
 class StructuredPythonObject : public StructuredData::Generic {
 public:
   StructuredPythonObject() : StructuredData::Generic() {}
 
   StructuredPythonObject(void *obj) : StructuredData::Generic(obj) {
     Py_XINCREF(GetValue());
   }
 

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

#else
   if (r < 0) {
     llvm::consumeError(exception()); // clear the exception and log it.
     return false;
   }
   return !!r;
 #endif
 }
 
-namespace {
-class GIL {
-public:
-  GIL() {
-    m_state = PyGILState_Ensure();
-    assert(!PyErr_Occurred());
-  }
-  ~GIL() { PyGILState_Release(m_state); }
-
-protected:
-  PyGILState_STATE m_state;
-};
-} // namespace
-
 const char *PythonException::toCString() const {
   if (!m_repr_bytes)
     return "unknown exception";
   return PyBytes_AS_STRING(m_repr_bytes);
 }
 
 PythonException::PythonException(const char *caller) {
   assert(PyErr_Occurred());

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

public:
     }
     lldb::StructuredDataImplUP m_extra_args_up;
   };
 
   ScriptInterpreterPython(Debugger &debugger)
       : ScriptInterpreter(debugger, lldb::eScriptLanguagePython),
         IOHandlerDelegateMultiline("DONE") {}
 
+  StructuredData::DictionarySP GetInterpreterInfo() override;
   static void Initialize();
   static void Terminate();
   static llvm::StringRef GetPluginNameStatic() { return "script-python"; }
   static llvm::StringRef GetPluginDescriptionStatic();
   static FileSpec GetPythonDir();
   static void SharedLibraryDirectoryHelper(FileSpec &this_file);
 
 protected:
   static void ComputePythonDirForApple(llvm::SmallVectorImpl<char> &path);
   static void ComputePythonDir(llvm::SmallVectorImpl<char> &path);
 };
 } // namespace lldb_private
 
 #endif // LLDB_ENABLE_PYTHON
 #endif // LLDB_PLUGINS_SCRIPTINTERPRETER_PYTHON_SCRIPTINTERPRETERPYTHON_H

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

#else
     ComputePythonDir(path);
 #endif
     spec.GetDirectory().SetString(path);
     return spec;
   }();
   return g_spec;
 }
 
+StructuredData::DictionarySP ScriptInterpreterPython::GetInterpreterInfo() {
+  GIL gil;
+  FileSpec python_dir_spec = GetPythonDir();
+  if (!python_dir_spec)
+    return nullptr;
+  PythonString python_dir(python_dir_spec.GetPath());
+  PythonDictionary info(PyInitialValue::Empty);
+  llvm::Error error = info.SetItem("lldb-pythonpath", python_dir);
+  if (error)
+    return nullptr;
+  static const char script[] = R"(
+def main(info):
+  import sys
+  import os
+  name = 'python' + str(sys.version_info.major)
+  info.update({
+    "language": "python",
+    "prefix": sys.prefix,
+    "executable": os.path.join(sys.prefix, "bin", name),
+  })
+  return info
+)";
+  PythonScript get_info(script);
+  auto info_json = unwrapIgnoringErrors(As<PythonDictionary>(get_info(info)));
+  if (!info_json)
+    return nullptr;
+  return info_json.CreateStructuredDictionary();
+}
+
 void ScriptInterpreterPython::SharedLibraryDirectoryHelper(
     FileSpec &this_file) {
   // When we're loaded from python, this_file will point to the file inside the
   // python package directory. Replace it with the one in the lib directory.
 #ifdef _WIN32
   // On windows, we need to manually back out of the python tree, and go into
   // the bin directory. This is pretty much the inverse of what ComputePythonDir
   // does.

lldb/test/API/functionalities/paths/TestPaths.py

 """
 Test some lldb command abbreviations.
 """
 
 
 import lldb
 import os
+import sys
+import json
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 from lldbsuite.test import lldbplatformutil
 
 
 class TestPaths(TestBase):
 
def test_paths(self):
             filenames = ['liblldb.dll']
         elif lldbplatformutil.getHostPlatform() == 'darwin':
             filenames = ['LLDB', 'liblldb.dylib']
         else:
             filenames = ['liblldb.so']
         self.assertTrue(any([os.path.exists(os.path.join(shlib_dir, f)) for f in
             filenames]), "shlib_dir = " + shlib_dir)
 
+    @no_debug_info_test
+    def test_interpreter_info(self):
+        info_sd = self.dbg.GetScriptInterpreterInfo(self.dbg.GetScriptingLanguage("python"))
+        self.assertTrue(info_sd.IsValid())
+        stream = lldb.SBStream()
+        self.assertTrue(info_sd.GetAsJSON(stream).Success())
+        info = json.loads(stream.GetData())
+        prefix = info['prefix']
+        self.assertEqual(os.path.realpath(sys.prefix), os.path.realpath(prefix))
+        self.assertEqual(
+            os.path.realpath(os.path.join(info['lldb-pythonpath'], 'lldb')),
+            os.path.realpath(os.path.dirname(lldb.__file__)))
+        self.assertTrue(os.path.exists(info['executable']))
+        self.assertEqual(info['language'], 'python')
+
 
     @no_debug_info_test
     def test_directory_doesnt_end_with_slash(self):
         current_directory_spec = lldb.SBFileSpec(os.path.curdir)
         current_directory_string = current_directory_spec.GetDirectory()
         self.assertNotEqual(current_directory_string[-1:], '/')
 
     @skipUnlessPlatform(["windows"])

lldb/test/Shell/Driver/TestHelp.test

 CHECK: -r
 CHECK: --repl-language
 CHECK: --repl
 CHECK: -R
 CHECK: -r
 
 CHECK: SCRIPTING
 CHECK: -l
+CHECK: --print-script-interpreter-info
 CHECK: --python-path
 CHECK: -P
 CHECK: --script-language

lldb/tools/driver/Driver.h

struct OptionData {
     std::vector<InitialCmdEntry> m_initial_commands;
     std::vector<InitialCmdEntry> m_after_file_commands;
     std::vector<InitialCmdEntry> m_after_crash_commands;
 
     bool m_debug_mode = false;
     bool m_source_quietly = false;
     bool m_print_version = false;
     bool m_print_python_path = false;
+    bool m_print_script_interpreter_info = false;
     bool m_wait_for = false;
     bool m_repl = false;
     bool m_batch = false;
 
     // FIXME: When we have set/show variables we can remove this from here.
     bool m_use_external_editor = false;
 
     using OptionSet = std::set<char>;

lldb/tools/driver/Driver.cpp

 #include "lldb/API/SBCommandReturnObject.h"
 #include "lldb/API/SBDebugger.h"
 #include "lldb/API/SBFile.h"
 #include "lldb/API/SBHostOS.h"
 #include "lldb/API/SBLanguageRuntime.h"
 #include "lldb/API/SBReproducer.h"
 #include "lldb/API/SBStream.h"
 #include "lldb/API/SBStringList.h"
+#include "lldb/API/SBStructuredData.h"
 
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/InitLLVM.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/Process.h"
 #include "llvm/Support/Signals.h"
 #include "llvm/Support/WithColor.h"
SBError Driver::ProcessArgs(const opt::InputArgList &args, bool &exiting) {
 
   if (args.hasArg(OPT_version)) {
     m_option_data.m_print_version = true;
   }
 
   if (args.hasArg(OPT_python_path)) {
     m_option_data.m_print_python_path = true;
   }
+  if (args.hasArg(OPT_print_script_interpreter_info)) {
+    m_option_data.m_print_script_interpreter_info = true;
+  }
 
   if (args.hasArg(OPT_batch)) {
     m_option_data.m_batch = true;
   }
 
   if (auto *arg = args.getLastArg(OPT_core)) {
     auto arg_value = arg->getValue();
     SBFileSpec file(arg_value);
if (python_file_spec.IsValid()) {
       } else
         llvm::outs() << "<PATH TOO LONG>\n";
     } else
       llvm::outs() << "<COULD NOT FIND PATH>\n";
     exiting = true;
     return error;
   }
 
+  if (m_option_data.m_print_script_interpreter_info) {
+    SBStructuredData info =
+        m_debugger.GetScriptInterpreterInfo(m_debugger.GetScriptLanguage());
+    if (!info) {
+      error.SetErrorString("no script interpreter.");
+    } else {
+      SBStream stream;
+      error = info.GetAsJSON(stream);
+      if (error.Success()) {
+        llvm::outs() << stream.GetData() << '\n';
+      }
+    }
+    exiting = true;
+    return error;
+  }
+
   return error;
 }
 
 static inline int OpenPipe(int fds[2], std::size_t size) {
 #ifdef _WIN32
   return _pipe(fds, size, O_BINARY);
 #else
   (void)size;

lldb/tools/driver/Options.td

 def python_path: F<"python-path">,
   HelpText<"Prints out the path to the lldb.py file for this version of lldb.">,
   Group<grp_scripting>;
 def: Flag<["-"], "P">,
   Alias<python_path>,
   HelpText<"Alias for --python-path">,
   Group<grp_scripting>;
 
+def print_script_interpreter_info: F<"print-script-interpreter-info">,
+  HelpText<"Prints out a json dictionary with information about the scripting language interpreter.">,
+  Group<grp_scripting>;
+
 def script_language: Separate<["--", "-"], "script-language">,
   MetaVarName<"<language>">,
   HelpText<"Tells the debugger to use the specified scripting language for user-defined scripts.">,
   Group<grp_scripting>;
 def: Separate<["-"], "l">,
   Alias<script_language>,
   HelpText<"Alias for --script-language">,
   Group<grp_scripting>;