[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

410

[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

51

52

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/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
+
+lldb = os.path.join(os.path.dirname(__file__), 'lldb')
+
+prefix = subprocess.run([lldb, "--python-prefix"],
+    check=True, stdout=subprocess.PIPE, encoding='utf8').stdout.strip()
+
+path = subprocess.run([lldb, "--python-path"],
+    check=True, stdout=subprocess.PIPE, encoding='utf8').stdout.strip()
+
+os.environ["PYTHONPATH"]= path + os.path.pathsep + os.environ.get("PYTHONPATH", "")
+
+python = os.path.join(prefix, "bin", "python3")
+
+os.execl(python, python, *sys.argv[1:])

lldb/docs/man/lldb.rst

 .. option:: -l <value>
 
  Alias for --script-language
 
 .. option:: --python-path
 
  Prints out the path to the lldb.py file for this version of lldb.
 
+.. option:: --python-prefix
+
+ Prints out the sys.prefix for the python used by this lldb.
+
 .. option:: -P
 
  Alias for --python-path
 
 .. option:: --script-language <language>
 
  Tells the debugger to use the specified scripting language for user-defined scripts.
 

lldb/docs/python_api_enums.rst

 .. py:data:: ePathTypeHeaderDir
 
    Find LLDB header file directory.
 
 .. py:data:: ePathTypePythonDir
 
    Find Python modules (PYTHONPATH) directory.
 
+.. py:data:: ePathTypePythonPrefix
+
+   Find Python's ``sys.prefix`` path.
+
 .. py:data:: ePathTypeLLDBSystemPlugins
 
    System plug-ins directory
 
 .. py:data:: ePathTypeLLDBUserPlugins
 
    User plug-ins directory
 

lldb/include/lldb/lldb-enumerations.h

 //===-- lldb-enumerations.h -------------------------------------*- C++ -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
enum PathType {
   ePathTypePythonDir,            ///< Find Python modules (PYTHONPATH) directory
   ePathTypeLLDBSystemPlugins,    ///< System plug-ins directory
   ePathTypeLLDBUserPlugins,      ///< User plug-ins directory
   ePathTypeLLDBTempSystemDir, ///< The LLDB temp directory for this system that
                               ///< will be cleaned up on exit
   ePathTypeGlobalLLDBTempSystemDir, ///< The LLDB temp directory for this
                                     ///< system, NOT cleaned up on a process
                                     ///< exit.
-  ePathTypeClangDir ///< Find path to Clang builtin headers
+  ePathTypeClangDir,                ///< Find path to Clang builtin headers
+  ePathTypePythonPrefix,            ///< Find python's  sys.prefix path
 };
 
 /// Kind of member function.
 ///
 /// Used by the type system.
 enum MemberFunctionKind {
   eMemberFunctionKindUnknown = 0,    ///< Not sure what the type of this is
   eMemberFunctionKindConstructor,    ///< A function used to create instances

lldb/source/API/SBHostOS.cpp

 //===-- SBHostOS.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
 //
 //===----------------------------------------------------------------------===//
 
SBFileSpec SBHostOS::GetLLDBPath(lldb::PathType path_type) {
   case ePathTypeHeaderDir:
     fspec = HostInfo::GetHeaderDir();
     break;
   case ePathTypePythonDir:
 #if LLDB_ENABLE_PYTHON
     fspec = ScriptInterpreterPython::GetPythonDir();
 #endif
     break;
+  case ePathTypePythonPrefix:
+#if LLDB_ENABLE_PYTHON
+    fspec = ScriptInterpreterPython::GetPythonPrefix();
+#endif
+    break;
   case ePathTypeLLDBSystemPlugins:
     fspec = HostInfo::GetSystemPluginDir();
     break;
   case ePathTypeLLDBUserPlugins:
     fspec = HostInfo::GetUserPluginDir();
     break;
   case ePathTypeLLDBTempSystemDir:
     fspec = HostInfo::GetProcessTempDir();

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

 //===-- ScriptInterpreterPython.h -------------------------------*- C++ -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
ScriptInterpreterPython(Debugger &debugger)
       : ScriptInterpreter(debugger, lldb::eScriptLanguagePython),
         IOHandlerDelegateMultiline("DONE") {}
 
   static void Initialize();
   static void Terminate();
   static llvm::StringRef GetPluginNameStatic() { return "script-python"; }
   static llvm::StringRef GetPluginDescriptionStatic();
   static FileSpec GetPythonDir();
+  static FileSpec GetPythonPrefix();
   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

 //===-- 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
 //
 //===----------------------------------------------------------------------===//
 
#else
     ComputePythonDir(path);
 #endif
     spec.GetDirectory().SetString(path);
     return spec;
   }();
   return g_spec;
 }
 
+FileSpec ScriptInterpreterPython::GetPythonPrefix() {
+  FileSpec spec;
+  InitializePythonRAII initialize_guard;
+  wchar_t *pyhome = Py_GetPrefix();
+  if (pyhome) {
+    char *pyhome8 = Py_EncodeLocale(pyhome, NULL);
+    if (pyhome8) {
+      spec.GetDirectory().SetString(pyhome8);
+      PyMem_Free(pyhome8);
+    }
+  }
+  return spec;
+}
+
 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
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 from lldbsuite.test import lldbplatformutil
 
 
 class TestPaths(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     @no_debug_info_test
     def test_paths(self):
         '''Test to make sure no file names are set in the lldb.SBFileSpec objects returned by lldb.SBHostOS.GetLLDBPath() for paths that are directories'''
         dir_path_types = [lldb.ePathTypeLLDBShlibDir,
                           lldb.ePathTypeSupportExecutableDir,
                           lldb.ePathTypeHeaderDir,
                           lldb.ePathTypePythonDir,
+                          lldb.ePathTypePythonPrefix,
                           lldb.ePathTypeLLDBSystemPlugins,
                           lldb.ePathTypeLLDBUserPlugins,
                           lldb.ePathTypeLLDBTempSystemDir,
-                          lldb.ePathTypeClangDir]
+                          lldb.ePathTypeClangDir,
+                          lldb.ePathTypePythonPrefix]
 
         for path_type in dir_path_types:
             f = lldb.SBHostOS.GetLLDBPath(path_type)
             # No directory path types should have the filename set
             self.assertIsNone(f.GetFilename())
 
         shlib_dir = lldb.SBHostOS.GetLLDBPath(lldb.ePathTypeLLDBShlibDir).GetDirectory()
         if lldbplatformutil.getHostPlatform() == 'windows':
             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_prefix(self):
+        prefix = lldb.SBHostOS.GetLLDBPath(lldb.ePathTypePythonPrefix).GetDirectory()
+        self.assertEqual(os.path.realpath(sys.prefix), os.path.realpath(prefix))
 
     @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"])
     @no_debug_info_test

lldb/test/Shell/Driver/TestHelp.test

 CHECK: --repl-language
 CHECK: --repl
 CHECK: -R
 CHECK: -r
 
 CHECK: SCRIPTING
 CHECK: -l
 CHECK: --python-path
+CHECK: --python-prefix
 CHECK: -P
 CHECK: --script-language

lldb/tools/driver/Driver.h

 //===-- Driver.h ------------------------------------------------*- C++ -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
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_python_prefix = 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

 //===-- Driver.cpp ----------------------------------------------*- C++ -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
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_python_prefix)) {
+    m_option_data.m_print_python_prefix = 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_python_prefix) {
+    SBFileSpec python_file_spec = SBHostOS::GetLLDBPath(ePathTypePythonPrefix);
+    if (python_file_spec.IsValid()) {
+      char python_path[PATH_MAX];
+      size_t num_chars = python_file_spec.GetPath(python_path, PATH_MAX);
+      if (num_chars < PATH_MAX) {
+        llvm::outs() << python_path << '\n';
+      } else
+        llvm::outs() << "<PATH TOO LONG>\n";
+    } else
+      llvm::outs() << "<COULD NOT FIND PATH>\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 python_prefix: F<"python-prefix">,
+  HelpText<"Prints out the sys.prefix for the python used by this lldb.">,
+  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>;