[lldb/CMake] Rename LLDB_DISABLE_PYTHON to LLDB_ENABLE_PYTHON

[JDevlieghere]

Summary

This matches the naming scheme used by LLVM and all the other optional dependencies in LLDB.

[mgorny]

lldb/cmake/modules/LLDBConfig.cmake

46

I know that the same thing is done above but… what's the point of setting it to ON again?

[JDevlieghere]

lldb/cmake/modules/LLDBConfig.cmake

46

It's just setting the default to the old value. If the value was set, we should honor it, both if it was OFF or ON.

[mgorny]

lldb/cmake/modules/LLDBConfig.cmake

46

But it's already set to ON a few lines above.

[JDevlieghere]

lldb/cmake/modules/LLDBConfig.cmake

46

Do you mean the DEFINED? That just checks if the variable exists, not its value.

[teemperor]

That seems like a simple mechanical change and the move from DISABLE to ENABLE was IIRC already consensus, so LGTM.

lldb/source/Commands/CommandObjectType.cpp

1173

lol?

[mgorny]

lldb/cmake/modules/LLDBConfig.cmake

46

No, I mean you have:

set(default_enable_python ON)
#...
if (DEFINED LLDB_DISABLE_PYTHON)
  #...
  else()
    set(default_enable_python ON)

This is superfluous since the default is already ON.

[JDevlieghere]

lldb/cmake/modules/LLDBConfig.cmake

46

Got it, thanks. Simplified the code.

lldb/source/Commands/CommandObjectType.cpp

1173

Hahaha

[labath]

lldb/cmake/modules/LLDBConfig.cmake

46

Yeah, I added the curses stuff without too much optimization to keep the debian bot working until the master restarts (so the configuration change takes effect). I don't think we have any bots using LLDB_DISABLE_PYTHON, so this probably wasn't even needed, but this all isn't very important -- the code will be gone in a few days anyway...

[labath]

lldb/cmake/modules/LLDBConfig.cmake

46

Btw, I've just removed the LLDB_DISABLE_CURSES blurb. If you don't know of any reason to keep LLDB_DISABLE_PYTHON python around (I don't) then I think that can go too...

lldb/CMakeLists.txt

 if(APPLE)
   add_definitions(-DLLDB_USE_OS_LOG)
 endif()
 
 if (WIN32)
   add_definitions(-D_ENABLE_EXTENDED_ALIGNED_STORAGE)
 endif()
 
-if (NOT LLDB_DISABLE_PYTHON)
+if (LLDB_ENABLE_PYTHON)
   execute_process(
     COMMAND ${PYTHON_EXECUTABLE}
         -c "import distutils.sysconfig; print(distutils.sysconfig.get_python_lib(True, False, ''))"
     OUTPUT_VARIABLE LLDB_PYTHON_DEFAULT_RELATIVE_PATH
     OUTPUT_STRIP_TRAILING_WHITESPACE)
 
   file(TO_CMAKE_PATH ${LLDB_PYTHON_DEFAULT_RELATIVE_PATH} LLDB_PYTHON_DEFAULT_RELATIVE_PATH)
   set(LLDB_PYTHON_RELATIVE_PATH ${LLDB_PYTHON_DEFAULT_RELATIVE_PATH}

 option(LLDB_INCLUDE_TESTS "Generate build targets for the LLDB unit tests." ${LLVM_INCLUDE_TESTS})
 if(LLDB_INCLUDE_TESTS)
   add_subdirectory(test)
   add_subdirectory(unittests)
   add_subdirectory(utils/lit-cpuid)
   add_subdirectory(utils/lldb-dotest)
 endif()
 
-if (NOT LLDB_DISABLE_PYTHON)
+if (LLDB_ENABLE_PYTHON)
   get_target_property(lldb_scripts_dir swig_wrapper BINARY_DIR)
 
   if(LLDB_BUILD_FRAMEWORK)
     set(lldb_python_build_path "${LLDB_FRAMEWORK_ABSOLUTE_BUILD_DIR}/LLDB.framework/Resources/Python/lldb")
   else()
     set(lldb_python_build_path "${CMAKE_BINARY_DIR}/${CMAKE_CFG_INTDIR}/${LLDB_PYTHON_RELATIVE_PATH}/lldb")
   endif()
 

lldb/cmake/modules/LLDBConfig.cmake

 endif()
 
 set(LLDB_LINKER_SUPPORTS_GROUPS OFF)
 if (LLVM_COMPILER_IS_GCC_COMPATIBLE AND NOT "${CMAKE_SYSTEM_NAME}" MATCHES "Darwin")
   # The Darwin linker doesn't understand --start-group/--end-group.
   set(LLDB_LINKER_SUPPORTS_GROUPS ON)
 endif()
 
-set(default_disable_python OFF)
+set(default_enable_python ON)
 set(default_enable_libedit ON)
 set(default_enable_curses ON)
 
-# Temporary support the old LLDB_DISABLE_CURSES variable
+# Temporary support the old LLDB_DISABLE_* variables
 if (DEFINED LLDB_DISABLE_CURSES)
   if (LLDB_DISABLE_CURSES)
     set(default_enable_curses OFF)
-  else()
-    set(default_enable_curses ON)
+  endif()
+endif()
+if (DEFINED LLDB_DISABLE_PYTHON)
+  if (LLDB_DISABLE_PYTHON)
+    set(default_enable_python OFF)
   endif()
 endif()
 
 if(DEFINED LLVM_ENABLE_LIBEDIT AND NOT LLVM_ENABLE_LIBEDIT)
   set(default_disable_libedit ON)
 endif()
 
 if(CMAKE_SYSTEM_NAME MATCHES "Windows")
   set(default_enable_libedit OFF)
   set(default_enable_curses OFF)
 elseif(CMAKE_SYSTEM_NAME MATCHES "Android")
-  set(default_disable_python ON)
+  set(default_enable_python OFF)
   set(default_enable_libedit OFF)
   set(default_enable_curses OFF)
 elseif(IOS)
-  set(default_disable_python ON)
+  set(default_enable_python OFF)
 endif()
 
-option(LLDB_DISABLE_PYTHON "Disable Python scripting integration." ${default_disable_python})
+option(LLDB_ENABLE_PYTHON "Enable Python scripting integration." ${default_enable_python})
 option(LLDB_ENABLE_LIBEDIT "Enable the use of editline." ${default_enable_libedit})
 option(LLDB_ENABLE_CURSES "Enable Curses integration." ${default_enable_curses})
 option(LLDB_RELOCATABLE_PYTHON "Use the PYTHONHOME environment variable to locate Python." OFF)
 option(LLDB_USE_SYSTEM_SIX "Use six.py shipped with system and do not install a copy of it" OFF)
 option(LLDB_USE_ENTITLEMENTS "When codesigning, use entitlements if available" ON)
 option(LLDB_BUILD_FRAMEWORK "Build LLDB.framework (Darwin only)" OFF)
 option(LLDB_NO_INSTALL_DEFAULT_RPATH "Disable default RPATH settings in binaries" OFF)
 option(LLDB_USE_SYSTEM_DEBUGSERVER "Use the system's debugserver for testing (Darwin only)." OFF)
foreach(component PYTHON_EXE;PYTHON_LIB;PYTHON_DLL)
     if(NOT EXISTS ${${component}})
       message(WARNING "Unable to find ${component}")
       unset(${component})
     endif()
   endforeach()
 
   if (NOT PYTHON_EXE OR NOT PYTHON_LIB OR NOT PYTHON_DLL)
     message(WARNING "Unable to find all Python components.  Python support will be disabled for this build.")
-    set(LLDB_DISABLE_PYTHON 1 PARENT_SCOPE)
+    set(LLDB_ENABLE_PYTHON 0 PARENT_SCOPE)
     return()
   endif()
 
   # Find the version of the Python interpreter.
   execute_process(COMMAND "${PYTHON_EXE}" -c
                   "import sys; sys.stdout.write('.'.join([str(x) for x in sys.version_info[:3]]))"
                   OUTPUT_VARIABLE PYTHON_VERSION_OUTPUT
                   RESULT_VARIABLE PYTHON_VERSION_RESULT
                   ERROR_QUIET)
 
   if(PYTHON_VERSION_RESULT)
     message(WARNING "Unable to retrieve Python executable version")
     set(PYTHON_VERSION_OUTPUT "")
   endif()
 
   set(${OUT_EXE_PATH_VARNAME} ${PYTHON_EXE} PARENT_SCOPE)
   set(${OUT_LIB_PATH_VARNAME} ${PYTHON_LIB} PARENT_SCOPE)
   set(${OUT_DLL_PATH_VARNAME} ${PYTHON_DLL} PARENT_SCOPE)
   set(${OUT_VERSION_VARNAME}  ${PYTHON_VERSION_OUTPUT} PARENT_SCOPE)
 endfunction()
 
 function(find_python_libs_windows)
   if ("${PYTHON_HOME}" STREQUAL "")
     message(WARNING "LLDB embedded Python on Windows requires specifying a value for PYTHON_HOME.  Python support disabled.")
-    set(LLDB_DISABLE_PYTHON 1 PARENT_SCOPE)
+    set(LLDB_ENABLE_PYTHON 0 PARENT_SCOPE)
     return()
   endif()
 
   file(TO_CMAKE_PATH "${PYTHON_HOME}/Include" PYTHON_INCLUDE_DIR)
 
   if(EXISTS "${PYTHON_INCLUDE_DIR}/patchlevel.h")
     file(STRINGS "${PYTHON_INCLUDE_DIR}/patchlevel.h" python_version_str
          REGEX "^#define[ \t]+PY_VERSION[ \t]+\"[^\"]+\"")
     string(REGEX REPLACE "^#define[ \t]+PY_VERSION[ \t]+\"([^\"+]+)[+]?\".*" "\\1"
          PYTHONLIBS_VERSION_STRING "${python_version_str}")
     message(STATUS "Found Python library version ${PYTHONLIBS_VERSION_STRING}")
     string(REGEX REPLACE "([0-9]+)[.]([0-9]+)[.][0-9]+" "python\\1\\2" PYTHONLIBS_BASE_NAME "${PYTHONLIBS_VERSION_STRING}")
     unset(python_version_str)
   else()
     message(WARNING "Unable to find ${PYTHON_INCLUDE_DIR}/patchlevel.h, Python installation is corrupt.")
     message(WARNING "Python support will be disabled for this build.")
-    set(LLDB_DISABLE_PYTHON 1 PARENT_SCOPE)
+    set(LLDB_ENABLE_PYTHON 0 PARENT_SCOPE)
     return()
   endif()
 
   file(TO_CMAKE_PATH "${PYTHON_HOME}" PYTHON_HOME)
   # TODO(compnerd) when CMake Policy `CMP0091` is set to NEW, we should use
   # if(CMAKE_MSVC_RUNTIME_LIBRARY MATCHES MultiThreadedDebug)
   if(NOT DEFINED CMAKE_BUILD_TYPE)
     # Multi-target generator was selected (like Visual Studio or Xcode) where no concrete build type was passed
     # Lookup for both debug and release python installations
     find_python_libs_windows_helper(TRUE  PYTHON_DEBUG_EXE   PYTHON_DEBUG_LIB   PYTHON_DEBUG_DLL   PYTHON_DEBUG_VERSION_STRING)
     find_python_libs_windows_helper(FALSE PYTHON_RELEASE_EXE PYTHON_RELEASE_LIB PYTHON_RELEASE_DLL PYTHON_RELEASE_VERSION_STRING)
-    if(LLDB_DISABLE_PYTHON)
-      set(LLDB_DISABLE_PYTHON 1 PARENT_SCOPE)
+    if(NOT LLDB_ENABLE_PYTHON)
+      set(LLDB_ENABLE_PYTHON 0 PARENT_SCOPE)
       return()
     endif()
 
     # We should have been found both debug and release python here
     # Now check that their versions are equal
     if(NOT PYTHON_DEBUG_VERSION_STRING STREQUAL PYTHON_RELEASE_VERSION_STRING)
       message(FATAL_ERROR "Python versions for debug (${PYTHON_DEBUG_VERSION_STRING}) and release (${PYTHON_RELEASE_VERSION_STRING}) are different."
                           "Python installation is corrupted")
     endif ()
 
     set(PYTHON_EXECUTABLE $<$<CONFIG:Debug>:${PYTHON_DEBUG_EXE}>$<$<NOT:$<CONFIG:Debug>>:${PYTHON_RELEASE_EXE}>)
     set(PYTHON_LIBRARY    $<$<CONFIG:Debug>:${PYTHON_DEBUG_LIB}>$<$<NOT:$<CONFIG:Debug>>:${PYTHON_RELEASE_LIB}>)
     set(PYTHON_DLL        $<$<CONFIG:Debug>:${PYTHON_DEBUG_DLL}>$<$<NOT:$<CONFIG:Debug>>:${PYTHON_RELEASE_DLL}>)
     set(PYTHON_VERSION_STRING ${PYTHON_RELEASE_VERSION_STRING})
   else()
     # Lookup for concrete python installation depending on build type
     if (CMAKE_BUILD_TYPE STREQUAL Debug)
       set(LOOKUP_DEBUG_PYTHON TRUE)
     else()
       set(LOOKUP_DEBUG_PYTHON FALSE)
     endif()
     find_python_libs_windows_helper(${LOOKUP_DEBUG_PYTHON} PYTHON_EXECUTABLE PYTHON_LIBRARY PYTHON_DLL PYTHON_VERSION_STRING)
-    if(LLDB_DISABLE_PYTHON)
-      set(LLDB_DISABLE_PYTHON 1 PARENT_SCOPE)
+    if(NOT LLDB_ENABLE_PYTHON)
+      set(LLDB_ENABLE_PYTHON 0 PARENT_SCOPE)
       return()
     endif()
   endif()
 
   if(PYTHON_VERSION_STRING)
     string(REPLACE "." ";" PYTHON_VERSION_PARTS "${PYTHON_VERSION_STRING}")
     list(GET PYTHON_VERSION_PARTS 0 PYTHON_VERSION_MAJOR)
     list(GET PYTHON_VERSION_PARTS 1 PYTHON_VERSION_MINOR)
function(find_python_libs_windows)
   message(STATUS "LLDB Found PythonExecutable: ${PYTHON_EXECUTABLE} (${PYTHON_VERSION_STRING})")
   message(STATUS "LLDB Found PythonLibs: ${PYTHON_LIBRARY} (${PYTHONLIBS_VERSION_STRING})")
   message(STATUS "LLDB Found PythonDLL: ${PYTHON_DLL}")
   message(STATUS "LLDB Found PythonIncludeDirs: ${PYTHON_INCLUDE_DIR}")
 endfunction(find_python_libs_windows)
 
 # Call find_python_libs_windows ahead of the rest of the python configuration.
 # It's possible that it won't find a python installation and will then set
-# LLDB_DISABLE_PYTHON to ON.
-if (NOT LLDB_DISABLE_PYTHON AND "${CMAKE_SYSTEM_NAME}" STREQUAL "Windows")
+# LLDB_ENABLE_PYTHON to OFF.
+if (LLDB_ENABLE_PYTHON AND "${CMAKE_SYSTEM_NAME}" STREQUAL "Windows")
   find_python_libs_windows()
 endif()
 
-if (NOT LLDB_DISABLE_PYTHON)
+if (LLDB_ENABLE_PYTHON)
   if ("${CMAKE_SYSTEM_NAME}" STREQUAL "Windows")
     if (NOT LLDB_RELOCATABLE_PYTHON)
       file(TO_CMAKE_PATH "${PYTHON_HOME}" LLDB_PYTHON_HOME)
     endif()
   else()
     find_package(PythonInterp REQUIRED)
     find_package(PythonLibs REQUIRED)
   endif()
if (NOT CMAKE_CROSSCOMPILING)
     endif()
   endif()
 
   if (PYTHON_INCLUDE_DIR)
     include_directories(${PYTHON_INCLUDE_DIR})
   endif()
 endif()
 
-if (LLDB_DISABLE_PYTHON)
+if (NOT LLDB_ENABLE_PYTHON)
   unset(PYTHON_INCLUDE_DIR)
   unset(PYTHON_LIBRARY)
   unset(PYTHON_EXECUTABLE)
 endif()
 
 if (LLVM_EXTERNAL_CLANG_SOURCE_DIR)
   include_directories(${LLVM_EXTERNAL_CLANG_SOURCE_DIR}/include)
 else ()

lldb/docs/CMakeLists.txt

if(DOXYGEN_FOUND)
 
   add_custom_target(lldb-cpp-doc
     ${DOXYGEN_EXECUTABLE} ${CMAKE_CURRENT_BINARY_DIR}/doxygen.cfg
     WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
     COMMENT "Generating LLDB C++ API reference with Doxygen" VERBATIM
   )
 endif()
 
-if (NOT LLDB_DISABLE_PYTHON)
+if (LLDB_ENABLE_PYTHON)
   find_program(EPYDOC_EXECUTABLE NAMES epydoc epydoc.py)
   if(EPYDOC_EXECUTABLE)
     message(STATUS "Found epydoc - ${EPYDOC_EXECUTABLE}")
 
     find_program(DOT_EXECUTABLE dot)
     if(DOT_EXECUTABLE)
       set(EPYDOC_OPTIONS ${EPYDOC_OPTIONS} --graph all --dotpath ${DOT_EXECUTABLE})
       message(STATUS "Found dot - ${DOT_EXECUTABLE}")

lldb/docs/resources/build.rst

 platforms. In this case, you will need to obtain them from another source,
 either a cross-package if one is available, or cross-compiling the respective
 library from source. Fortunately the list of LLDB dependencies is not big and
 if you are only interested in the server component, you can reduce this even
 further by passing the appropriate cmake options, such as:
 
 ::
 
-  -DLLDB_DISABLE_PYTHON=1
+  -DLLDB_ENABLE_PYTHON=0
   -DLLDB_ENABLE_LIBEDIT=0
   -DLLDB_ENABLE_CURSES=0
   -DLLVM_ENABLE_TERMINFO=0
 
 In this case you, will often not need anything other than the standard C and
 C++ libraries.
 
 Once all of the dependencies are in place, it's just a matter of configuring

 ::
 
   -DCMAKE_CROSSCOMPILING=1 \
   -DCMAKE_C_COMPILER=aarch64-linux-gnu-gcc \
   -DCMAKE_CXX_COMPILER=aarch64-linux-gnu-g++ \
   -DLLVM_HOST_TRIPLE=aarch64-unknown-linux-gnu \
   -DLLVM_TABLEGEN=<path-to-host>/bin/llvm-tblgen \
   -DCLANG_TABLEGEN=<path-to-host>/bin/clang-tblgen \
-  -DLLDB_DISABLE_PYTHON=1 \
+  -DLLDB_ENABLE_PYTHON=0 \
   -DLLDB_ENABLE_LIBEDIT=0 \
   -DLLDB_ENABLE_CURSES=0
 
 An alternative (and recommended) way to compile LLDB is with clang.
 Unfortunately, clang is not able to find all the include paths necessary for a
 successful cross-compile, so we need to help it with a couple of CFLAGS
 options. In my case it was sufficient to add the following arguments to
 ``CMAKE_C_FLAGS`` and ``CMAKE_CXX_FLAGS`` (in addition to changing
 ``CMAKE_C(XX)_COMPILER`` to point to clang compilers):
 
 ::
 
   -target aarch64-linux-gnu \
   -I /usr/aarch64-linux-gnu/include/c++/4.8.2/aarch64-linux-gnu \
   -I /usr/aarch64-linux-gnu/include
 
 If you wanted to build a full version of LLDB and avoid passing
-``-DLLDB_DISABLE_PYTHON`` and other options, you would need to obtain the
+``-DLLDB_ENABLE_PYTHON=0`` and other options, you would need to obtain the
 target versions of the respective libraries. The easiest way to achieve this is
 to use the qemu-debootstrap utility, which can prepare a system image using
 qemu and chroot to simulate the target environment. Then you can install the
 necessary packages in this environment (python-dev, libedit-dev, etc.) and
 point your compiler to use them using the correct -I and -L arguments.
 
 Example 2: Cross-compiling for Android on Linux
 ***********************************************

lldb/include/lldb/Host/Config.h.cmake

 #cmakedefine01 LLDB_ENABLE_LZMA
 
 #cmakedefine01 LLDB_ENABLE_CURSES
 
 #cmakedefine01 LLDB_ENABLE_LIBEDIT
 
 #cmakedefine01 LLDB_ENABLE_LIBXML2
 
-#cmakedefine LLDB_DISABLE_PYTHON
+#cmakedefine01 LLDB_ENABLE_PYTHON
 
 #cmakedefine LLDB_PYTHON_HOME "${LLDB_PYTHON_HOME}"
 
 #define LLDB_LIBDIR_SUFFIX "${LLVM_LIBDIR_SUFFIX}"
 
 #endif // #ifndef LLDB_HOST_CONFIG_H

lldb/packages/Python/lldbsuite/test/dotest.py

else:
                 lldbPythonDir = lines[-1]
                 if "freebsd" in sys.platform or "linux" in sys.platform:
                     os.environ['LLDB_LIB_DIR'] = os.path.join(
                         lldbPythonDir, '..', '..')
 
         if not lldbPythonDir:
             print(
                 "Unable to load lldb extension module.  Possible reasons for this include:")
-            print("  1) LLDB was built with LLDB_DISABLE_PYTHON=1")
+            print("  1) LLDB was built with LLDB_ENABLE_PYTHON=0")
             print(
                 "  2) PYTHONPATH and PYTHONHOME are not set correctly.  PYTHONHOME should refer to")
             print(
                 "     the version of Python that LLDB built and linked against, and PYTHONPATH")
             print(
                 "     should contain the Lib directory for the same python distro, as well as the")
             print("     location of LLDB\'s site-packages folder.")
             print(

lldb/source/API/CMakeLists.txt

 if ( CMAKE_SYSTEM_NAME MATCHES "Windows" )
   add_definitions( -DEXPORT_LIBLLDB )
 endif()
 
 get_property(LLDB_ALL_PLUGINS GLOBAL PROPERTY LLDB_PLUGINS)
 
-if(NOT LLDB_DISABLE_PYTHON)
+if(LLDB_ENABLE_PYTHON)
   get_target_property(lldb_scripts_dir swig_wrapper BINARY_DIR)
   set(lldb_python_wrapper ${lldb_scripts_dir}/LLDBWrapPython.cpp)
 endif()
 
 if(LLDB_BUILD_FRAMEWORK)
   set(option_install_prefix INSTALL_PREFIX ${LLDB_FRAMEWORK_INSTALL_DIR})
   set(option_framework FRAMEWORK)
 endif()
else()
     add_llvm_symbol_exports(liblldb ${CMAKE_CURRENT_SOURCE_DIR}/liblldb-private.exports)
   endif()
   set_target_properties(liblldb_exports PROPERTIES FOLDER "lldb misc")
 endif()
 
 if ( CMAKE_SYSTEM_NAME MATCHES "Windows" )
   # Only MSVC has the ABI compatibility problem and avoids using FindPythonLibs,
   # so only it needs to explicitly link against ${PYTHON_LIBRARY}
-  if (MSVC AND NOT LLDB_DISABLE_PYTHON)
+  if (MSVC AND LLDB_ENABLE_PYTHON)
     target_link_libraries(liblldb PRIVATE ${PYTHON_LIBRARY})
   endif()
 else()
   set_target_properties(liblldb
     PROPERTIES
     OUTPUT_NAME lldb
   )
 endif()
 
 if (NOT LLDB_BUILT_STANDALONE)
   add_dependencies(liblldb clang-resource-headers)
 endif()
 
 if(LLDB_BUILD_FRAMEWORK)
   include(LLDBFramework)
 endif()

lldb/source/API/SBHostOS.cpp

 #include "lldb/Host/Host.h"
 #include "lldb/Host/HostInfo.h"
 #include "lldb/Host/HostNativeThread.h"
 #include "lldb/Host/HostThread.h"
 #include "lldb/Host/ThreadLauncher.h"
 #include "lldb/Utility/FileSpec.h"
 
 #include "Plugins/ExpressionParser/Clang/ClangHost.h"
-#ifndef LLDB_DISABLE_PYTHON
+#if LLDB_ENABLE_PYTHON
 #include "Plugins/ScriptInterpreter/Python/ScriptInterpreterPython.h"
 #endif
 
 #include "llvm/ADT/SmallString.h"
 #include "llvm/Support/Path.h"
 
 using namespace lldb;
 using namespace lldb_private;
case ePathTypeLLDBShlibDir:
     break;
   case ePathTypeSupportExecutableDir:
     fspec = HostInfo::GetSupportExeDir();
     break;
   case ePathTypeHeaderDir:
     fspec = HostInfo::GetHeaderDir();
     break;
   case ePathTypePythonDir:
-#ifndef LLDB_DISABLE_PYTHON
+#if LLDB_ENABLE_PYTHON
     fspec = ScriptInterpreterPython::GetPythonDir();
 #endif
     break;
   case ePathTypeLLDBSystemPlugins:
     fspec = HostInfo::GetSystemPluginDir();
     break;
   case ePathTypeLLDBUserPlugins:
     fspec = HostInfo::GetUserPluginDir();

lldb/source/API/SystemInitializerFull.cpp

 //===-- SystemInitializerFull.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
 //
 //===----------------------------------------------------------------------===//
 
 #include "SystemInitializerFull.h"
 #include "lldb/API/SBCommandInterpreter.h"
 #include "lldb/Host/Config.h"
 
-#if !defined(LLDB_DISABLE_PYTHON)
+#if LLDB_ENABLE_PYTHON
 #include "Plugins/ScriptInterpreter/Python/ScriptInterpreterPython.h"
 #endif
 
 #include "lldb/Core/Debugger.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Initialization/SystemInitializerCommon.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Symbol/ClangASTContext.h"
llvm::Error SystemInitializerFull::Initialize() {
   ObjectFileMachO::Initialize();
   ObjectFilePECOFF::Initialize();
 
   ObjectContainerBSDArchive::Initialize();
   ObjectContainerUniversalMachO::Initialize();
 
   ScriptInterpreterNone::Initialize();
 
-#ifndef LLDB_DISABLE_PYTHON
+#if LLDB_ENABLE_PYTHON
   OperatingSystemPython::Initialize();
 #endif
 
-#if !defined(LLDB_DISABLE_PYTHON)
+#if LLDB_ENABLE_PYTHON
   ScriptInterpreterPython::Initialize();
 #endif
 
   platform_freebsd::PlatformFreeBSD::Initialize();
   platform_linux::PlatformLinux::Initialize();
   platform_netbsd::PlatformNetBSD::Initialize();
   platform_openbsd::PlatformOpenBSD::Initialize();
   PlatformWindows::Initialize();
#endif
   StructuredDataDarwinLog::Terminate();
 
   DynamicLoaderMacOSXDYLD::Terminate();
   DynamicLoaderMacOS::Terminate();
   DynamicLoaderPOSIXDYLD::Terminate();
   DynamicLoaderStatic::Terminate();
   DynamicLoaderWindowsDYLD::Terminate();
 
-#ifndef LLDB_DISABLE_PYTHON
+#if LLDB_ENABLE_PYTHON
   OperatingSystemPython::Terminate();
 #endif
 
   platform_freebsd::PlatformFreeBSD::Terminate();
   platform_linux::PlatformLinux::Terminate();
   platform_netbsd::PlatformNetBSD::Terminate();
   platform_openbsd::PlatformOpenBSD::Terminate();
   PlatformWindows::Terminate();

lldb/source/Commands/CommandObjectFrame.cpp

(int) fd = 3
 
     )");
   }
   ~CommandObjectFrameRecognizerAdd() override = default;
 };
 
 bool CommandObjectFrameRecognizerAdd::DoExecute(Args &command,
                                                 CommandReturnObject &result) {
-#ifndef LLDB_DISABLE_PYTHON
+#if LLDB_ENABLE_PYTHON
   if (m_options.m_class_name.empty()) {
     result.AppendErrorWithFormat(
         "%s needs a Python class name (-l argument).\n", m_cmd_name.c_str());
     result.SetStatus(eReturnStatusFailed);
     return false;
   }
 
   if (m_options.m_module.empty()) {
CommandObjectMultiwordFrame::CommandObjectMultiwordFrame(
   LoadSubCommand("diagnose",
                  CommandObjectSP(new CommandObjectFrameDiagnose(interpreter)));
   LoadSubCommand("info",
                  CommandObjectSP(new CommandObjectFrameInfo(interpreter)));
   LoadSubCommand("select",
                  CommandObjectSP(new CommandObjectFrameSelect(interpreter)));
   LoadSubCommand("variable",
                  CommandObjectSP(new CommandObjectFrameVariable(interpreter)));
-#ifndef LLDB_DISABLE_PYTHON
+#if LLDB_ENABLE_PYTHON
   LoadSubCommand("recognizer", CommandObjectSP(new CommandObjectFrameRecognizer(
                                    interpreter)));
 #endif
 }
 
 CommandObjectMultiwordFrame::~CommandObjectMultiwordFrame() = default;

lldb/source/Commands/CommandObjectType.cpp

if (output_sp && interactive) {
       output_sp->Flush();
     }
   }
 
   void IOHandlerInputComplete(IOHandler &io_handler,
                               std::string &data) override {
     StreamFileSP error_sp = io_handler.GetErrorStreamFileSP();
 
-#ifndef LLDB_DISABLE_PYTHON
+#if LLDB_ENABLE_PYTHON
     ScriptInterpreter *interpreter = GetDebugger().GetScriptInterpreter();
     if (interpreter) {
       StringList lines;
       lines.SplitIntoLines(data);
       if (lines.GetSize() > 0) {
         ScriptAddOptions *options_ptr =
             ((ScriptAddOptions *)io_handler.GetUserData());
         if (options_ptr) {
if (interpreter) {
         error_sp->Printf("error: empty function, didn't add python command.\n");
         error_sp->Flush();
       }
     } else {
       error_sp->Printf(
           "error: script interpreter missing, didn't add python command.\n");
       error_sp->Flush();
     }
-#endif // LLDB_DISABLE_PYTHON
+#endif
     io_handler.SetIsDone(true);
   }
 
   static bool AddSummary(ConstString type_name, lldb::TypeSummaryImplSP entry,
                          SummaryFormatType type, std::string category,
                          Status *error = nullptr);
 
 protected:
if (output_sp && interactive) {
       output_sp->Flush();
     }
   }
 
   void IOHandlerInputComplete(IOHandler &io_handler,
                               std::string &data) override {
     StreamFileSP error_sp = io_handler.GetErrorStreamFileSP();
 
-#ifndef LLDB_DISABLE_PYTHON
+#if LLDB_ENABLE_PYTHON
     ScriptInterpreter *interpreter = GetDebugger().GetScriptInterpreter();
     if (interpreter) {
       StringList lines;
       lines.SplitIntoLines(data);
       if (lines.GetSize() > 0) {
         SynthAddOptions *options_ptr =
             ((SynthAddOptions *)io_handler.GetUserData());
         if (options_ptr) {
if (interpreter) {
         error_sp->Flush();
       }
     } else {
       error_sp->Printf(
           "error: script interpreter missing, didn't add python command.\n");
       error_sp->Flush();
     }
 
-#endif // LLDB_DISABLE_PYTHON
+#endif
     io_handler.SetIsDone(true);
   }
 
 public:
   enum SynthFormatType { eRegularSynth, eRegexSynth };
 
   CommandObjectTypeSynthAdd(CommandInterpreter &interpreter);
 

 class CommandObjectTypeFormatList
     : public CommandObjectTypeFormatterList<TypeFormatImpl> {
 public:
   CommandObjectTypeFormatList(CommandInterpreter &interpreter)
       : CommandObjectTypeFormatterList(interpreter, "type format list",
                                        "Show a list of current formats.") {}
 };
 
-#ifndef LLDB_DISABLE_PYTHON
-
-// CommandObjectTypeSummaryAdd
-
-#endif // LLDB_DISABLE_PYTHON
-
 Status CommandObjectTypeSummaryAdd::CommandOptions::SetOptionValue(
     uint32_t option_idx, llvm::StringRef option_arg,
     ExecutionContext *execution_context) {
   Status error;
   const int short_option = m_getopt_table[option_idx].val;
   bool success;
 
   switch (short_option) {
void CommandObjectTypeSummaryAdd::CommandOptions::OptionParsingStarting(
   m_name.Clear();
   m_python_script = "";
   m_python_function = "";
   m_format_string = "";
   m_is_add_script = false;
   m_category = "default";
 }
 
-#ifndef LLDB_DISABLE_PYTHON
+#if LLDB_ENABLE_PYTHON
 
 bool CommandObjectTypeSummaryAdd::Execute_ScriptSummary(
     Args &command, CommandReturnObject &result) {
   const size_t argc = command.GetArgumentCount();
 
   if (argc < 1 && !m_options.m_name) {
     result.AppendErrorWithFormat("%s takes one or more args.\n",
                                  m_cmd_name.c_str());
if (error.Fail()) {
       result.SetStatus(eReturnStatusFailed);
       return false;
     }
   }
 
   return result.Succeeded();
 }
 
-#endif // LLDB_DISABLE_PYTHON
+#endif
 
 bool CommandObjectTypeSummaryAdd::Execute_StringSummary(
     Args &command, CommandReturnObject &result) {
   const size_t argc = command.GetArgumentCount();
 
   if (argc < 1 && !m_options.m_name) {
     result.AppendErrorWithFormat("%s takes one or more args.\n",
                                  m_cmd_name.c_str());

 (lldb) type summary add JustADemo -o "value = valobj.GetChildMemberWithName('value'); return 'My value is ' + value.GetValue();")");
 }
 
 bool CommandObjectTypeSummaryAdd::DoExecute(Args &command,
                                             CommandReturnObject &result) {
   WarnOnPotentialUnquotedUnsignedType(command, result);
 
   if (m_options.m_is_add_script) {
-#ifndef LLDB_DISABLE_PYTHON
+#if LLDB_ENABLE_PYTHON
     return Execute_ScriptSummary(command, result);
 #else
     result.AppendError("python is disabled");
     result.SetStatus(eReturnStatusFailed);
     return false;
-#endif // LLDB_DISABLE_PYTHON
+#endif
   }
 
   return Execute_StringSummary(command, result);
 }
 
 static bool FixArrayTypeNameWithRegex(ConstString &type_name) {
   llvm::StringRef type_name_ref(type_name.GetStringRef());
 

 class CommandObjectTypeFilterList
     : public CommandObjectTypeFormatterList<TypeFilterImpl> {
 public:
   CommandObjectTypeFilterList(CommandInterpreter &interpreter)
       : CommandObjectTypeFormatterList(interpreter, "type filter list",
                                        "Show a list of current filters.") {}
 };
 
-#ifndef LLDB_DISABLE_PYTHON
+#if LLDB_ENABLE_PYTHON
 
 // CommandObjectTypeSynthList
 
 class CommandObjectTypeSynthList
     : public CommandObjectTypeFormatterList<SyntheticChildren> {
 public:
   CommandObjectTypeSynthList(CommandInterpreter &interpreter)
       : CommandObjectTypeFormatterList(
             interpreter, "type synthetic list",
             "Show a list of current synthetic providers.") {}
 };
 
-#endif // LLDB_DISABLE_PYTHON
+#endif
 
 // CommandObjectTypeFilterDelete
 
 class CommandObjectTypeFilterDelete : public CommandObjectTypeFormatterDelete {
 public:
   CommandObjectTypeFilterDelete(CommandInterpreter &interpreter)
       : CommandObjectTypeFormatterDelete(
             interpreter,
             eFormatCategoryItemFilter | eFormatCategoryItemRegexFilter,
             "type filter delete", "Delete an existing filter for a type.") {}
 
   ~CommandObjectTypeFilterDelete() override = default;
 };
 
-#ifndef LLDB_DISABLE_PYTHON
+#if LLDB_ENABLE_PYTHON
 
 // CommandObjectTypeSynthDelete
 
 class CommandObjectTypeSynthDelete : public CommandObjectTypeFormatterDelete {
 public:
   CommandObjectTypeSynthDelete(CommandInterpreter &interpreter)
       : CommandObjectTypeFormatterDelete(
             interpreter,
             eFormatCategoryItemSynth | eFormatCategoryItemRegexSynth,
             "type synthetic delete",
             "Delete an existing synthetic provider for a type.") {}
 
   ~CommandObjectTypeSynthDelete() override = default;
 };
 
-#endif // LLDB_DISABLE_PYTHON
+#endif
 
 // CommandObjectTypeFilterClear
 
 class CommandObjectTypeFilterClear : public CommandObjectTypeFormatterClear {
 public:
   CommandObjectTypeFilterClear(CommandInterpreter &interpreter)
       : CommandObjectTypeFormatterClear(
             interpreter,
             eFormatCategoryItemFilter | eFormatCategoryItemRegexFilter,
             "type filter clear", "Delete all existing filter.") {}
 };
 
-#ifndef LLDB_DISABLE_PYTHON
+#if LLDB_ENABLE_PYTHON
 // CommandObjectTypeSynthClear
 
 class CommandObjectTypeSynthClear : public CommandObjectTypeFormatterClear {
 public:
   CommandObjectTypeSynthClear(CommandInterpreter &interpreter)
       : CommandObjectTypeFormatterClear(
             interpreter,
             eFormatCategoryItemSynth | eFormatCategoryItemRegexSynth,
if (type == eRegexSynth) {
 
     return true;
   } else {
     category->GetTypeSyntheticsContainer()->Add(std::move(type_name), entry);
     return true;
   }
 }
 
-#endif // LLDB_DISABLE_PYTHON
+#endif
 #define LLDB_OPTIONS_type_filter_add
 #include "CommandOptions.inc"
 
 class CommandObjectTypeFilterAdd : public CommandObjectParsed {
 private:
   class CommandOptions : public Options {
     typedef std::vector<std::string> option_vector;
 
LoadSubCommand(
                     [](ValueObject &valobj) -> TypeFormatImpl::SharedPointer {
                       return valobj.GetValueFormat();
                     })));
   }
 
   ~CommandObjectTypeFormat() override = default;
 };
 
-#ifndef LLDB_DISABLE_PYTHON
+#if LLDB_ENABLE_PYTHON
 
 class CommandObjectTypeSynth : public CommandObjectMultiword {
 public:
   CommandObjectTypeSynth(CommandInterpreter &interpreter)
       : CommandObjectMultiword(
             interpreter, "type synthetic",
             "Commands for operating on synthetic type representations.",
             "type synthetic [<sub-command-options>] ") {
LoadSubCommand(
             [](ValueObject &valobj) -> SyntheticChildren::SharedPointer {
               return valobj.GetSyntheticChildren();
             })));
   }
 
   ~CommandObjectTypeSynth() override = default;
 };
 
-#endif // LLDB_DISABLE_PYTHON
+#endif
 
 class CommandObjectTypeFilter : public CommandObjectMultiword {
 public:
   CommandObjectTypeFilter(CommandInterpreter &interpreter)
       : CommandObjectMultiword(interpreter, "type filter",
                                "Commands for operating on type filters.",
                                "type synthetic [<sub-command-options>] ") {
     LoadSubCommand(
CommandObjectType::CommandObjectType(CommandInterpreter &interpreter)
   LoadSubCommand("category",
                  CommandObjectSP(new CommandObjectTypeCategory(interpreter)));
   LoadSubCommand("filter",
                  CommandObjectSP(new CommandObjectTypeFilter(interpreter)));
   LoadSubCommand("format",
                  CommandObjectSP(new CommandObjectTypeFormat(interpreter)));
   LoadSubCommand("summary",
                  CommandObjectSP(new CommandObjectTypeSummary(interpreter)));
-#ifndef LLDB_DISABLE_PYTHON
+#if LLDB_ENABLE_PYTHON
   LoadSubCommand("synthetic",
                  CommandObjectSP(new CommandObjectTypeSynth(interpreter)));
-#endif // LLDB_DISABLE_PYTHON
+#endif
   LoadSubCommand("lookup",
                  CommandObjectSP(new CommandObjectTypeLookup(interpreter)));
 }
 
 CommandObjectType::~CommandObjectType() = default;

lldb/source/Core/ValueObject.cpp

bool ValueObject::UpdateFormatsIfNeeded() {
 
   if ((m_last_format_mgr_revision != DataVisualization::GetCurrentRevision())) {
     m_last_format_mgr_revision = DataVisualization::GetCurrentRevision();
     any_change = true;
 
     SetValueFormat(DataVisualization::GetFormat(*this, eNoDynamicValues));
     SetSummaryFormat(
         DataVisualization::GetSummaryFormat(*this, GetDynamicValueType()));
-#ifndef LLDB_DISABLE_PYTHON
+#if LLDB_ENABLE_PYTHON
     SetSyntheticChildren(
         DataVisualization::GetSyntheticChildren(*this, GetDynamicValueType()));
 #endif
   }
 
   return any_change;
 }
 

lldb/source/Interpreter/CommandObjectScript.cpp

: CommandObjectRaw(
           "Invoke the script interpreter with provided code and display any "
           "results.  Start the interactive interpreter if no code is supplied.",
           "script [<script-code>]") {}
 
 CommandObjectScript::~CommandObjectScript() {}
 
 bool CommandObjectScript::DoExecute(llvm::StringRef command,
                                     CommandReturnObject &result) {
-#ifdef LLDB_DISABLE_PYTHON
-  // if we ever support languages other than Python this simple #ifdef won't
-  // work
-  result.AppendError("your copy of LLDB does not support scripting.");
-  result.SetStatus(eReturnStatusFailed);
-  return false;
-#else
+#if LLDB_ENABLE_PYTHON
   if (m_interpreter.GetDebugger().GetScriptLanguage() ==
       lldb::eScriptLanguageNone) {
     result.AppendError(
         "the script-lang setting is set to none - scripting not available");
     result.SetStatus(eReturnStatusFailed);
     return false;
   }
 
#if LLDB_ENABLE_PYTHON
 
   // We can do better when reporting the status of one-liner script execution.
   if (script_interpreter->ExecuteOneLine(command, &result))
     result.SetStatus(eReturnStatusSuccessFinishNoResult);
   else
     result.SetStatus(eReturnStatusFailed);
 
   return result.Succeeded();
+#else
+  // if we ever support languages other than Python this simple #ifdef won't
+  // work
+  result.AppendError("your copy of LLDB does not support scripting.");
+  result.SetStatus(eReturnStatusFailed);
+  return false;
 #endif
 }

lldb/source/Plugins/OperatingSystem/Python/OperatingSystemPython.h

 //===-- OperatingSystemPython.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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_OperatingSystemPython_h_
 #define liblldb_OperatingSystemPython_h_
 
 #include "lldb/Host/Config.h"
 
-#ifndef LLDB_DISABLE_PYTHON
+#if LLDB_ENABLE_PYTHON
 
 #include "lldb/Target/OperatingSystem.h"
 #include "lldb/Utility/StructuredData.h"
 
 class DynamicRegisterInfo;
 
 namespace lldb_private {
 class ScriptInterpreter;
protected:
   DynamicRegisterInfo *GetDynamicRegisterInfo();
 
   lldb::ValueObjectSP m_thread_list_valobj_sp;
   std::unique_ptr<DynamicRegisterInfo> m_register_info_up;
   lldb_private::ScriptInterpreter *m_interpreter;
   lldb_private::StructuredData::ObjectSP m_python_object_sp;
 };
 
-#endif // LLDB_DISABLE_PYTHON
+#endif
 
 #endif // liblldb_OperatingSystemPython_h_

lldb/source/Plugins/OperatingSystem/Python/OperatingSystemPython.cpp

 //===-- OperatingSystemPython.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
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Host/Config.h"
 
-#ifndef LLDB_DISABLE_PYTHON
+#if LLDB_ENABLE_PYTHON
 
 #include "OperatingSystemPython.h"
 
 #include "Plugins/Process/Utility/DynamicRegisterInfo.h"
 #include "Plugins/Process/Utility/RegisterContextDummy.h"
 #include "Plugins/Process/Utility/RegisterContextMemory.h"
 #include "Plugins/Process/Utility/ThreadMemory.h"
 #include "lldb/Core/Debugger.h"
if (thread_info_dict) {
       if (did_create)
         thread_list.AddThread(thread_sp);
       return thread_sp;
     }
   }
   return ThreadSP();
 }
 
-#endif // #ifndef LLDB_DISABLE_PYTHON
+#endif // #if LLDB_ENABLE_PYTHON

lldb/source/Plugins/ScriptInterpreter/CMakeLists.txt

 add_subdirectory(None)
-if (NOT LLDB_DISABLE_PYTHON)
+if (LLDB_ENABLE_PYTHON)
   add_subdirectory(Python)
 endif()

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

 //
 
 
 #ifndef LLDB_PLUGINS_SCRIPTINTERPRETER_PYTHON_PYTHONDATAOBJECTS_H
 #define LLDB_PLUGINS_SCRIPTINTERPRETER_PYTHON_PYTHONDATAOBJECTS_H
 
 #include "lldb/Host/Config.h"
 
-#ifndef LLDB_DISABLE_PYTHON
+#if LLDB_ENABLE_PYTHON
 
 // LLDB Python header must be included first
 #include "lldb-python.h"
 
 #include "lldb/Host/File.h"
 #include "lldb/Utility/StructuredData.h"
 
 #include "llvm/ADT/ArrayRef.h"

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

 //===-- PythonDataObjects.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
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Host/Config.h"
 
-#ifndef LLDB_DISABLE_PYTHON
+#if LLDB_ENABLE_PYTHON
 
 #include "PythonDataObjects.h"
 #include "ScriptInterpreterPython.h"
 
 #include "lldb/Host/File.h"
 #include "lldb/Host/FileSystem.h"
 #include "lldb/Interpreter/ScriptInterpreter.h"
 #include "lldb/Utility/Log.h"

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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_PLUGINS_SCRIPTINTERPRETER_PYTHON_SCRIPTINTERPRETERPYTHON_H
 #define LLDB_PLUGINS_SCRIPTINTERPRETER_PYTHON_SCRIPTINTERPRETERPYTHON_H
 
 #include "lldb/Host/Config.h"
 
-#ifdef LLDB_DISABLE_PYTHON
-
-// Python is disabled in this build
-
-#else
+#if LLDB_ENABLE_PYTHON
 
 #include "lldb/Breakpoint/BreakpointOptions.h"
 #include "lldb/Core/IOHandler.h"
 #include "lldb/Core/StructuredDataImpl.h"
 #include "lldb/Interpreter/ScriptInterpreter.h"
 #include "lldb/lldb-private.h"
 
 #include <memory>
public:
   static FileSpec GetPythonDir();
 
 protected:
   static void ComputePythonDirForApple(llvm::SmallVectorImpl<char> &path);
   static void ComputePythonDir(llvm::SmallVectorImpl<char> &path);
 };
 } // namespace lldb_private
 
-#endif // LLDB_DISABLE_PYTHON
+#endif // LLDB_ENABLE_PYTHON
 #endif // LLDB_PLUGINS_SCRIPTINTERPRETER_PYTHON_SCRIPTINTERPRETERPYTHON_H

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

 //===-- ScriptInterpreterPython.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
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Host/Config.h"
 
-#ifndef LLDB_DISABLE_PYTHON
+#if LLDB_ENABLE_PYTHON
 
 // LLDB Python header must be included first
 #include "lldb-python.h"
 
 #include "PythonDataObjects.h"
 #include "PythonReadline.h"
 #include "ScriptInterpreterPythonImpl.h"
 

 // 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).
 //
 // void ScriptInterpreterPythonImpl::Terminate() { Py_Finalize (); }
 
-#endif // LLDB_DISABLE_PYTHON
+#endif

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

 //===-- ScriptInterpreterPythonImpl.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
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Host/Config.h"
 
-#ifndef LLDB_DISABLE_PYTHON
+#if LLDB_ENABLE_PYTHON
 
 #include "lldb-python.h"
 
 #include "PythonDataObjects.h"
 #include "ScriptInterpreterPython.h"
 
 #include "lldb/Host/Terminal.h"
 #include "lldb/Utility/StreamString.h"

lldb/source/Plugins/ScriptInterpreter/Python/lldb-python.h

 //===-- lldb-python.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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_PLUGINS_SCRIPTINTERPRETER_PYTHON_LLDB_PYTHON_H
 #define LLDB_PLUGINS_SCRIPTINTERPRETER_PYTHON_LLDB_PYTHON_H
 
 #include "lldb/Host/Config.h"
 
 // Python.h needs to be included before any system headers in order to avoid
 // redefinition of macros
 
-#ifdef LLDB_DISABLE_PYTHON
-// Python is disabled in this build
-#else
+#if LLDB_ENABLE_PYTHON
 #include "llvm/Support/Compiler.h"
 #if defined(_WIN32)
 // If anyone #includes Host/PosixApi.h later, it will try to typedef pid_t.  We
 // need to ensure this doesn't happen.  At the same time, Python.h will also try
 // to redefine a bunch of stuff that PosixApi.h defines.  So define it all now
 // so that PosixApi.h doesn't redefine it.
 #define NO_PID_T
 #endif

 // Include locale before Python so _PY_PORT_CTYPE_UTF8_ISSUE doesn't cause
 // macro redefinitions.
 #if defined(__APPLE__)
 #include <locale>
 #endif
 
 // Include python for non windows machines
 #include <Python.h>
-#endif // LLDB_DISABLE_PYTHON
+#endif
 
 #endif // LLDB_PLUGINS_SCRIPTINTERPRETER_PYTHON_LLDB_PYTHON_H

lldb/test/API/lit.site.cfg.py.in

 config.host_triple = "@LLVM_HOST_TRIPLE@"
 config.shared_libs = @LLVM_ENABLE_SHARED_LIBS@
 config.llvm_use_sanitizer = "@LLVM_USE_SANITIZER@"
 config.target_triple = "@TARGET_TRIPLE@"
 config.lldb_build_directory = "@LLDB_TEST_BUILD_DIRECTORY@"
 config.python_executable = "@PYTHON_EXECUTABLE@"
 config.dotest_path = "@LLDB_SOURCE_DIR@/test/API/dotest.py"
 config.dotest_args_str = "@LLDB_DOTEST_ARGS@"
-config.lldb_disable_python = @LLDB_DISABLE_PYTHON@
+config.lldb_enable_python = @LLDB_ENABLE_PYTHON@
 config.dotest_lit_args_str = None
 # The API tests use their own module caches.
 config.lldb_module_cache = os.path.join("@LLDB_TEST_MODULE_CACHE_LLDB@", "lldb-api")
 config.clang_module_cache = os.path.join("@LLDB_TEST_MODULE_CACHE_CLANG@", "lldb-api")
 
 # Additional dotest arguments can be passed to lit by providing a
 # semicolon-separates list: --param dotest-args="arg;arg".
 dotest_lit_args_str = lit_config.params.get('dotest-args', None)

lldb/test/API/lldbtest.py

def getTestsInDirectory(self, testSuite, path_in_suite, litConfig,
                 if ext in localConfig.suffixes:
                     yield lit.Test.Test(testSuite, path_in_suite +
                                         (filename, ), localConfig)
 
     def execute(self, test, litConfig):
         if litConfig.noExecute:
             return lit.Test.PASS, ''
 
-        if test.config.lldb_disable_python:
+        if not test.config.lldb_enable_python:
             return (lit.Test.UNSUPPORTED, 'Python module disabled')
 
         if test.config.unsupported:
             return (lit.Test.UNSUPPORTED, 'Test is unsupported')
 
         testPath, testFile = os.path.split(test.getSourcePath())
         # On Windows, the system does not always correctly interpret
         # shebang lines.  To make sure we can execute the tests, add

lldb/test/CMakeLists.txt

 endif()
 
 if (CMAKE_SIZEOF_VOID_P EQUAL 8)
   set(LLDB_IS_64_BITS 1)
 endif()
 
 # These values are not canonicalized within LLVM.
 llvm_canonicalize_cmake_booleans(
-  LLDB_DISABLE_PYTHON
+  LLDB_ENABLE_PYTHON
   LLVM_ENABLE_ZLIB
   LLVM_ENABLE_SHARED_LIBS
   LLDB_IS_64_BITS)
 
 # Configure the individual test suites.
 add_subdirectory(API)
 add_subdirectory(Shell)
 add_subdirectory(Unit)

lldb/test/Shell/lit.cfg.py

if 'native' in config.available_features:
     else:
         out, err, exitcode = lit.util.executeCommand([cpuid_exe])
         if exitcode == 0:
             for x in out.split():
                 config.available_features.add('native-cpu-%s' % x)
         else:
             lit_config.warning("lit-cpuid failed: %s" % err)
 
-if not config.lldb_disable_python:
+if config.lldb_enable_python:
     config.available_features.add('python')
 
 if config.lldb_enable_lzma:
     config.available_features.add('lzma')
 
 if find_executable('xz') != None:
     config.available_features.add('xz')
 

lldb/test/Shell/lit.site.cfg.py.in

 # should not need to be escaped.
 config.lldb_lit_tools_dir = r"@LLDB_LIT_TOOLS_DIR@"
 config.target_triple = "@TARGET_TRIPLE@"
 config.python_executable = "@PYTHON_EXECUTABLE@"
 config.have_zlib = @LLVM_ENABLE_ZLIB@
 config.lldb_enable_lzma = @LLDB_ENABLE_LZMA@
 config.host_triple = "@LLVM_HOST_TRIPLE@"
 config.lldb_bitness = 64 if @LLDB_IS_64_BITS@ else 32
-config.lldb_disable_python = @LLDB_DISABLE_PYTHON@
+config.lldb_enable_python = @LLDB_ENABLE_PYTHON@
 config.lldb_build_directory = "@LLDB_TEST_BUILD_DIRECTORY@"
 # The shell tests use their own module caches.
 config.lldb_module_cache = os.path.join("@LLDB_TEST_MODULE_CACHE_LLDB@", "lldb-shell")
 config.clang_module_cache = os.path.join("@LLDB_TEST_MODULE_CACHE_CLANG@", "lldb-shell")
 
 # Support substitution of the tools and libs dirs with user parameters. This is
 # used when we can't determine the tool dir at configuration time.
 try:

lldb/tools/intel-features/CMakeLists.txt

 
 if (LLDB_BUILD_INTEL_PT)
   add_subdirectory(intel-pt)
   LIST (APPEND FEATURE_LIBS ${FEATURE_LIBS} lldbIntelPT)
   SET (CLI_WRAPPER_PREPROCESSORS "${CLI_WRAPPER_PREPROCESSORS} -DBUILD_INTEL_PT")
 endif()
 
 # Add python wrapper if python not disabled
-if (NOT LLDB_DISABLE_PYTHON AND LLDB_BUILD_INTEL_PT)
+if (LLDB_ENABLE_PYTHON AND LLDB_BUILD_INTEL_PT)
   set(LLDB_INTEL_FEATURES_PYTHON_WRAP
      ${LLDB_BINARY_DIR}/tools/intel-features/scripts/IntelFeaturesPythonWrap.cpp)
   set_source_files_properties(${LLDB_INTEL_FEATURES_PYTHON_WRAP}
                               PROPERTIES GENERATED 1)
 
   if (CLANG_CL)
     set_source_files_properties(${LLDB_INTEL_FEATURES_PYTHON_WRAP}
                                  PROPERTIES COMPILE_FLAGS -Wno-unused-function)
add_lldb_library(lldbIntelFeatures SHARED
   cli-wrapper.cpp
   ${LLDB_INTEL_FEATURES_PYTHON_WRAP}
 
   LINK_LIBS
     ${FEATURE_LIBS}
   )
 
 # Add link dependencies for python wrapper
-if (NOT LLDB_DISABLE_PYTHON AND LLDB_BUILD_INTEL_PT)
+if (LLDB_ENABLE_PYTHON AND LLDB_BUILD_INTEL_PT)
   add_dependencies(lldbIntelFeatures intel-features-swig_wrapper)
 endif()
 
 install(TARGETS lldbIntelFeatures
   LIBRARY DESTINATION lib${LLVM_LIBDIR_SUFFIX})

lldb/unittests/ScriptInterpreter/CMakeLists.txt

-if (NOT LLDB_DISABLE_PYTHON)
+if (LLDB_ENABLE_PYTHON)
   add_subdirectory(Python)
 endif()