[CMake] Revised LLDB.framework builds

[sgraenitz]

Summary

Add features to LLDB CMake builds that have so far only been available in Xcode. Clean up a few inconveniences and prepare further improvements.

Options:

• LLDB_FRAMEWORK_BUILD_DIR determines target directory (in build-tree)
• LLDB_FRAMEWORK_INSTALL_DIR only determines target directory in install-tree
• LLVM_EXTERNALIZE_DEBUGINFO allows externalized debug info (dSYM on Darwin, emitted to bin)
• LLDB_FRAMEWORK_TOOLS determines which executables will be copied to the framework's Resources (dropped symlinking, removed INCLUDE_IN_SUITE, removed dummy targets)

Other changes:

• clean up add_lldb_executable()
• include LLDBFramework.cmake from source/API/CMakeLists.txt
• use *.plist.in files, which are typical for CMake and independent from Xcode
• add clang headers to the framework bundle

[clayborg]

I like seeing all of the cmake modifications for the LLDB.framework. Are we planning on trying to get rid of the Xcode project at some point soon and use the auto generated one made by cmake?

[sgraenitz]

I am still running some remaining tests, but please let me know what you think about it in the meantime. In case you want to try this patch yourself, please checkout together with the related revisions (see Stack).

cmake/modules/LLDBConfig.cmake

74

designated

[friss]

In D55328#1320267, @clayborg wrote:

I like seeing all of the cmake modifications for the LLDB.framework. Are we planning on trying to get rid of the Xcode project at some point soon and use the auto generated one made by cmake?

While there are no immediate plans to do so, we want to be able to do it and thus we need feature parity. Maintaining the Xcode project over a variety of branches is really expensive.

[sgraenitz]

Avoid conflicts: updating diff for recent changes on master

[sgraenitz]

Copy Clang headers to LLDB.framework without an intermediate staging directory. This approach seems much simpler and it avoids errors from an ordering issue at configuration time (preventing Clang headers from being copied to the staging directory).

[sgraenitz]

LLDB.framework requires an in-tree build

[labath]

This looks fine to me. I don't know much about frameworks, but I think it makes things cleaner by grouping all the framework-related code together.

It's not introduced in this patch, but the part that struck me as a hack has the force-overwriting of LLVM_CODESIGNING_IDENTITY. Is there any way that could be removed?

[sgraenitz]

Thanks for taking a look!

It's not introduced in this patch, but the part that struck me as a hack has the force-overwriting of LLVM_CODESIGNING_IDENTITY. Is there any way that could be removed?

I agree, this is unfortunate. The problem is that we only have a single global setting for the identity in LLVM and we want lldb_codesign as the default for LLDB. We can only change this default if we use a cache script or pass it to CMake explicitly, but at the time we arrive in LLDBConfig it's set already. So to make it work out-of-the-box we need the force-overwrite.

Actually, I considered changing the llvm_codesign function to accept an override value for the identity and pass it through lldb_add_executable/llvm_add_executable per target. In the end the use-case didn't really seem worth the amount of change. Also, overriding a global LLVM_CODESIGNING_IDENTITY with a default value might be very confusing. I considered a LLDB-specific version as well (D54352), but with the amount of code duplication @beanz was definitely right that this is not a good way either.

[sgraenitz]

It's not introduced in this patch, but the part that struck me as a hack has the force-overwriting of LLVM_CODESIGNING_IDENTITY. Is there any way that could be removed?

I agree, this is unfortunate. The problem is that we only have a single global setting for the identity in LLVM and we want lldb_codesign as the default for LLDB.

Now that I think about it again, I could at least print a warning if LLVM_CODESIGNING_IDENTITY is not empty when force-overwriting. What do you think?

[labath]

Printing the warning would definitely be nice.

Making the identity overridable via llvm_codesign arguments also sounds reasonable if we want to have the flexibility of signing things with different identities.

If we don't need that flexibility, can't we just have the users set the LLVM variable instead of the LLDB one?

[sgraenitz]

Working on it..

.. if we want to have the flexibility of signing things with different identities.

Not sure if it's a good idea to sign with different identities within one build. Could become confusing?

If we don't need that flexibility, can't we just have the users set the LLVM variable instead of the LLDB one?

Well, then we always had to pass the LLVM variable explicitly in order to achieve the default behavior. For the LLDB one we can control the default value.

[sgraenitz]

Improve handling of LLDB_CODESIGN_IDENTITY vs. LLVM_CODESIGNING_IDENTITY

[sgraenitz]

Finally fix that typo

[sgraenitz]

cmake/modules/LLDBConfig.cmake

64

@labath Could this be a way to phase out LLDB_CODESIGN_IDENTITY and move to the LLVM one?

• An explicitly set LLDB value takes precedence
• Warn if a non-empty LLVM value is overwritten
• Default to lldb_codesign if none is set explicitly

[sgraenitz]

cmake/modules/LLDBConfig.cmake

64

Not sure if it is too intrusive.

[labath]

cmake/modules/LLDBConfig.cmake

64

You say "phase out", but it's not clear to me how would that happen. What would be the next step here? I don't think llvm will ever get lldb_codesign as the default value for LLVM_CODESIGN_IDENTITY.

Given that we seem to have two parts of the project with different default policies on code signing, I think the cleanest approach would be to have code signing identity overridable on a per-call basis.

You might not even need to modify add_llvm_executable for this to work. I think you might be able to just locally do set(LLVM_CODESIGN_IDENTITY ${LLDB_CODESIGN_IDENTITY}) in the scope of add_lldb_executable and the signing code should pick that up instead of the cache variable (the cmake scope rules always confuse me, but I think this how it works).

[sgraenitz]

Move code sign changes to D55328, minor improvements

[aprantl]

resources/LLDB-Info.plist.in

19

Just out of curiosity: Why this? Is this expected to be replaced after code signing?

[sgraenitz]

cmake/modules/LLDBConfig.cmake

64

You say "phase out", but it's not clear to me how would that happen.

Yes sorry, that was dump phrasing. Explained in more detail in D55013.

[sgraenitz]

resources/LLDB-Info.plist.in

19

Good question. Seems to be a weird representation for something like default or none. It's in all the plists.

The bundle signature in new Xcode projects is initialized as ????. You can probably leave it at that, but if you want your own code, you need to register it: http://developer.apple.com/datatype/index.html

https://stackoverflow.com/questions/1875912

[aprantl]

cmake/modules/LLDBConfig.cmake

283

We should keep this warning, but just say that in-tree builds are not supported. There is no bot testing this and we don't want to bother with keeping this config work.

[aprantl]

Let's give this a try.

[aprantl]

Please be sure to watch all LLDB bots (green dragon and lab.llvm.org:8011) closely when landing this change.

[JDevlieghere]

Sorry for the late review, I had a look originally but didn't have any comments. LGTM!

[sgraenitz]

Thanks everyone for your patience with the review. I will spare us the potential merge conflicts before Christmas and land this after the holidays. Cheers

CMakeLists.txt

 else()
   find_package(LibEdit REQUIRED)
 endif()
 
 if(APPLE)
   add_definitions(-DLLDB_USE_OS_LOG)
 endif()
 
-# lldb-suite is a dummy target that encompasses all the necessary tools and
-# libraries for building a fully-functioning liblldb.
-add_custom_target(lldb-suite)
-set(LLDB_SUITE_TARGET lldb-suite)
-
-if(LLDB_BUILD_FRAMEWORK)
-  add_custom_target(lldb-framework)
-
-  # These are used to fill out LLDB-Info.plist. These are relevant when building
-  # the framework, and must be defined before building liblldb.
-  set(PRODUCT_NAME "LLDB")
-  set(EXECUTABLE_NAME "LLDB")
-  set(CURRENT_PROJECT_VERSION "${LLDB_VERSION_MAJOR}.${LLDB_VERSION_MINOR}.${LLDB_VERSION_PATCH}")
-  set(LLDB_SUITE_TARGET lldb-framework)
-
-  set(LLDB_FRAMEWORK_DIR
-    ${CMAKE_BINARY_DIR}/${CMAKE_CFG_INTDIR}/${LLDB_FRAMEWORK_INSTALL_DIR})
-  include(LLDBFramework)
-endif()
-
 add_subdirectory(docs)
 if (NOT LLDB_DISABLE_PYTHON)
-  if(LLDB_USE_SYSTEM_SIX)
-    set(SIX_EXTRA_ARGS "--useSystemSix")
-  endif()
-
-  set(LLDB_PYTHON_TARGET_DIR ${LLDB_BINARY_DIR}/scripts)
-  set(LLDB_WRAP_PYTHON ${LLDB_BINARY_DIR}/scripts/LLDBWrapPython.cpp)
-  if(LLDB_BUILD_FRAMEWORK)
-    set(LLDB_PYTHON_TARGET_DIR ${LLDB_FRAMEWORK_DIR})
-    set(LLDB_WRAP_PYTHON ${LLDB_PYTHON_TARGET_DIR}/LLDBWrapPython.cpp)
-  else()
-    # Don't set -m when building the framework.
-    set(FINISH_EXTRA_ARGS "-m")
-  endif()
-
-
   add_subdirectory(scripts)
 endif ()
-
 add_subdirectory(source)
 add_subdirectory(tools)
 
 option(LLDB_INCLUDE_TESTS "Generate build targets for the LLDB unit tests."
   ${LLVM_INCLUDE_TESTS})
 option(LLDB_TEST_USE_CUSTOM_C_COMPILER "Use the C compiler provided via LLDB_TEST_C_COMPILER for building test inferiors (instead of the just-built compiler). Defaults to OFF." OFF)
 option(LLDB_TEST_USE_CUSTOM_CXX_COMPILER "Use the C++ compiler provided via LLDB_TEST_CXX_COMPILER for building test inferiors (instead of the just-built compiler). Defaults to OFF." OFF)
 if(LLDB_INCLUDE_TESTS)
if(LLDB_INCLUDE_TESTS)
   endif()
 
   add_subdirectory(test)
   add_subdirectory(unittests)
   add_subdirectory(lit)
   add_subdirectory(utils/lldb-dotest)
 endif()
 
-
 if (NOT LLDB_DISABLE_PYTHON)
+    if(NOT LLDB_BUILD_FRAMEWORK)
+      set(use_python_wrapper_from_src_dir -m)
+    endif()
+    if(LLDB_USE_SYSTEM_SIX)
+      set(use_six_py_from_system --useSystemSix)
+    endif()
+
     # Add a Post-Build Event to copy over Python files and create the symlink
     # to liblldb.so for the Python API(hardlink on Windows)
     add_custom_target(finish_swig ALL
         COMMAND
            ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/scripts/finishSwigWrapperClasses.py
                --srcRoot=${LLDB_SOURCE_DIR}
                --targetDir=${LLDB_PYTHON_TARGET_DIR}
                --cfgBldDir=${LLDB_PYTHON_TARGET_DIR}
                --prefix=${CMAKE_BINARY_DIR}
                --cmakeBuildConfiguration=${CMAKE_CFG_INTDIR}
                --lldbLibDir=lib${LLVM_LIBDIR_SUFFIX}
-               ${SIX_EXTRA_ARGS}
-               ${FINISH_EXTRA_ARGS}
+               ${use_python_wrapper_from_src_dir}
+               ${use_six_py_from_system}
         VERBATIM
         DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/scripts/finishSwigWrapperClasses.py
         DEPENDS ${LLDB_PYTHON_TARGET_DIR}/lldb.py
         COMMENT "Python script sym-linking LLDB Python API")
 
-    # We depend on liblldb and lldb-argdumper being built before we can do this step.
-    add_dependencies(finish_swig ${LLDB_SUITE_TARGET})
 
-    # If we build the readline module, we depend on that happening
-    # first.
     if (TARGET readline)
-        add_dependencies(finish_swig readline)
+      set(readline_dep readline)
     endif()
+    add_dependencies(finish_swig swig_wrapper liblldb lldb-argdumper ${readline_dep})
 
     # Ensure we do the python post-build step when building lldb.
     add_dependencies(lldb finish_swig)
 
-    if (LLDB_BUILD_FRAMEWORK)
-      # The target to install libLLDB needs to depend on finish_swig so that the
-      # framework build properly copies over the Python files.
-      add_dependencies(install-liblldb finish_swig)
+    if(LLDB_BUILD_FRAMEWORK)
+      add_dependencies(lldb-framework finish_swig)
     endif()
 
     # Add a Post-Build Event to copy the custom Python DLL to the lldb binaries dir so that Windows can find it when launching
     # lldb.exe or any other executables that were linked with liblldb.
     if (WIN32 AND NOT "${PYTHON_DLL}" STREQUAL "")
         # When using the Visual Studio CMake generator the lldb binaries end up in Release/bin, Debug/bin etc.
         file(TO_NATIVE_PATH "${CMAKE_BINARY_DIR}/${CMAKE_CFG_INTDIR}/bin" LLDB_BIN_DIR)
         file(TO_NATIVE_PATH "${PYTHON_DLL}" PYTHON_DLL_NATIVE_PATH)
         add_custom_command(
             TARGET finish_swig
             POST_BUILD
             COMMAND ${CMAKE_COMMAND} -E copy ${PYTHON_DLL_NATIVE_PATH} ${LLDB_BIN_DIR} VERBATIM
             COMMENT "Copying Python DLL to LLDB binaries directory.")
     endif ()
 endif ()

cmake/modules/AddLLDB.cmake

if (PARAM_OBJECT)
     add_library(${name} ${libkind} ${srcs})
   else()
     llvm_add_library(${name} ${libkind} ${srcs} LINK_LIBS
                                 ${PARAM_LINK_LIBS}
                                 DEPENDS ${PARAM_DEPENDS})
 
     if (NOT LLVM_INSTALL_TOOLCHAIN_ONLY OR ${name} STREQUAL "liblldb")
       if (PARAM_SHARED)
-        set(out_dir lib${LLVM_LIBDIR_SUFFIX})
         if(${name} STREQUAL "liblldb" AND LLDB_BUILD_FRAMEWORK)
-          set(out_dir ${LLDB_FRAMEWORK_INSTALL_DIR})
-          # The framework that is generated will install with install-liblldb
-          # because we enable CMake's framework support. CMake will copy all the
-          # headers and resources for us.
-          add_dependencies(install-lldb-framework install-${name})
-          add_dependencies(install-lldb-framework-stripped install-${name}-stripped)
+          if(LLDB_FRAMEWORK_INSTALL_DIR)
+            set(install_dir ${LLDB_FRAMEWORK_INSTALL_DIR})
+          else()
+            set(install_dir ".")
+          endif()
+        else()
+          set(install_dir lib${LLVM_LIBDIR_SUFFIX})
         endif()
         install(TARGETS ${name}
           COMPONENT ${name}
           RUNTIME DESTINATION bin
-          LIBRARY DESTINATION ${out_dir}
-          ARCHIVE DESTINATION ${out_dir})
+          LIBRARY DESTINATION ${install_dir}
+          ARCHIVE DESTINATION ${install_dir})
       else()
         install(TARGETS ${name}
           COMPONENT ${name}
           LIBRARY DESTINATION lib${LLVM_LIBDIR_SUFFIX}
           ARCHIVE DESTINATION lib${LLVM_LIBDIR_SUFFIX})
       endif()
       if (NOT CMAKE_CONFIGURATION_TYPES)
         add_llvm_install_targets(install-${name}
                                  DEPENDS $<TARGET_FILE:${name}>
                                  COMPONENT ${name})
-
-        # install-liblldb{,-stripped} is the actual target that will install the
-        # framework, so it must rely on the framework being fully built first.
-        if (LLDB_BUILD_FRAMEWORK AND ${name} STREQUAL "liblldb")
-          add_dependencies(install-${name} lldb-framework)
-          add_dependencies(install-${name}-stripped lldb-framework)
-        endif()
       endif()
     endif()
   endif()
 
 
   # Hack: only some LLDB libraries depend on the clang autogenerated headers,
   # but it is simple enough to make all of LLDB depend on some of those
   # headers without negatively impacting much of anything.
   add_dependencies(${name} clang-tablegen-targets)
 
   # Add in any extra C++ compilation flags for this library.
   target_compile_options(${name} PRIVATE ${PARAM_EXTRA_CXXFLAGS})
 
   set_target_properties(${name} PROPERTIES FOLDER "lldb libraries")
 endfunction(add_lldb_library)
 
 function(add_lldb_executable name)
   cmake_parse_arguments(ARG
-    "INCLUDE_IN_SUITE;GENERATE_INSTALL"
+    "GENERATE_INSTALL"
     "ENTITLEMENTS"
     "LINK_LIBS;LINK_COMPONENTS"
     ${ARGN}
     )
 
   list(APPEND LLVM_LINK_COMPONENTS ${ARG_LINK_COMPONENTS})
   add_llvm_executable(${name} ${ARG_UNPARSED_ARGUMENTS} ENTITLEMENTS ${ARG_ENTITLEMENTS})
 
   target_link_libraries(${name} PRIVATE ${ARG_LINK_LIBS})
-  set_target_properties(${name} PROPERTIES
-    FOLDER "lldb executables")
-
-  if(ARG_INCLUDE_IN_SUITE)
-    add_dependencies(lldb-suite ${name})
-    if(LLDB_BUILD_FRAMEWORK)
-      if(NOT IOS)
-        set(resource_dir "/Resources")
-        set(resource_dots "../")
-      endif()
-      string(REGEX REPLACE "[^/]+" ".." _dots ${LLDB_FRAMEWORK_INSTALL_DIR})
-      set_target_properties(${name} PROPERTIES
-            RUNTIME_OUTPUT_DIRECTORY $<TARGET_FILE_DIR:liblldb>${resource_dir}
-            BUILD_WITH_INSTALL_RPATH On
-            INSTALL_RPATH "@loader_path/../../../${resource_dots}${_dots}/${LLDB_FRAMEWORK_INSTALL_DIR}")
-    endif()
-  endif()
-
-  if(LLDB_BUILD_FRAMEWORK AND NOT ARG_INCLUDE_IN_SUITE)
-    set_target_properties(${name} PROPERTIES
-          BUILD_WITH_INSTALL_RPATH On
-          INSTALL_RPATH "@loader_path/../${LLDB_FRAMEWORK_INSTALL_DIR}")
-  endif()
+  set_target_properties(${name} PROPERTIES FOLDER "lldb executables")
 
   if(ARG_GENERATE_INSTALL)
-    set(out_dir "bin")
-    if (LLDB_BUILD_FRAMEWORK AND ARG_INCLUDE_IN_SUITE)
-      set(out_dir ${LLDB_FRAMEWORK_INSTALL_DIR}/${LLDB_FRAMEWORK_RESOURCE_DIR})
-      # While install-liblldb-stripped will handle copying the tools, it will
-      # not strip them. We depend on this target to guarantee a stripped version
-      # will get installed in the framework.
-      add_dependencies(install-lldb-framework-stripped install-${name}-stripped)
-    endif()
     install(TARGETS ${name}
             COMPONENT ${name}
-          RUNTIME DESTINATION ${out_dir})
+            RUNTIME DESTINATION bin)
     if (NOT CMAKE_CONFIGURATION_TYPES)
       add_llvm_install_targets(install-${name}
                                DEPENDS ${name}
                                COMPONENT ${name})
     endif()
   endif()
-
-  if(ARG_INCLUDE_IN_SUITE AND LLDB_BUILD_FRAMEWORK)
-    add_llvm_tool_symlink(${name} ${name} ALWAYS_GENERATE SKIP_INSTALL
-                            OUTPUT_DIR ${LLVM_RUNTIME_OUTPUT_INTDIR})
-  endif()
 endfunction(add_lldb_executable)
 
 function(add_lldb_tool name)
   add_lldb_executable(${name} GENERATE_INSTALL ${ARGN})
 endfunction()
 
 # Support appending linker flags to an existing target.
 # This will preserve the existing linker flags on the

cmake/modules/LLDBConfig.cmake

 include(CheckCXXSymbolExists)
 
 set(LLDB_PROJECT_ROOT ${CMAKE_CURRENT_SOURCE_DIR})
 set(LLDB_SOURCE_ROOT "${CMAKE_CURRENT_SOURCE_DIR}/source")
 set(LLDB_INCLUDE_ROOT "${CMAKE_CURRENT_SOURCE_DIR}/include")
 
+set(LLDB_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR})
+set(LLDB_BINARY_DIR ${CMAKE_CURRENT_BINARY_DIR})
+
+if (CMAKE_SOURCE_DIR STREQUAL CMAKE_BINARY_DIR)
+  message(FATAL_ERROR
+    "In-source builds are not allowed. CMake would overwrite the makefiles "
+    "distributed with LLDB. Please create a directory and run cmake from "
+    "there, passing the path to this source directory as the last argument. "
+    "This process created the file `CMakeCache.txt' and the directory "
+    "`CMakeFiles'. Please delete them.")
+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_disable_curses OFF)

 option(LLDB_DISABLE_PYTHON "Disable Python scripting integration." ${default_disable_python})
 option(LLDB_DISABLE_CURSES "Disable Curses integration." ${default_disable_curses})
 option(LLDB_DISABLE_LIBEDIT "Disable the use of editline." ${default_disable_libedit})
 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_BUILD_FRAMEWORK "Build LLDB.framework (Darwin only)" OFF)
 option(LLDB_USE_ENTITLEMENTS "When codesigning, use entitlements if available" ON)
 
+set(LLDB_CODESIGN_IDENTITY lldb_codesign CACHE STRING
+    "Identity for code signing debugserver (Darwin only)")
+
+if(LLDB_CODESIGN_IDENTITY)
+  set(LLVM_CODESIGNING_IDENTITY ${LLDB_CODESIGN_IDENTITY} CACHE STRING "" FORCE)
+endif()
+
 if(LLDB_BUILD_FRAMEWORK)
   if(NOT APPLE)
     message(FATAL_ERROR "LLDB.framework can only be generated when targeting Apple platforms")
   endif()
   # CMake 3.6 did not correctly emit POST_BUILD commands for Apple Framework targets
   if(CMAKE_VERSION VERSION_LESS 3.7)
     message(FATAL_ERROR "LLDB_BUILD_FRAMEWORK is not supported on CMake < 3.7")
   endif()
+
+  set(LLDB_FRAMEWORK_VERSION A CACHE STRING "LLDB.framework version (default is A)")
+  set(LLDB_FRAMEWORK_BUILD_DIR bin CACHE STRING "Output directory for LLDB.framework")
+  set(LLDB_FRAMEWORK_INSTALL_DIR Library/Frameworks CACHE STRING "Install directory for LLDB.framework")
+  set(LLDB_FRAMEWORK_TOOLS darwin-debug;debugserver;lldb-argdumper;lldb-server CACHE INTERNAL
+      "List of tools to include in LLDB.framework/Resources")
+
+  # Set decicated directory for all dSYMs. Essentially, this emits the
+  # framework's dSYM outside of the framework directory.
+  if(LLVM_EXTERNALIZE_DEBUGINFO)
+    set(LLVM_EXTERNALIZE_DEBUGINFO_OUTPUT_DIR ${CMAKE_BINARY_DIR}/${CMAKE_CFG_INTDIR}/bin CACHE STRING
+        "Directory to emit dSYM files stripped from executables and libraries (Darwin Only)")
+  endif()
 endif()
 
 if (NOT CMAKE_SYSTEM_NAME MATCHES "Windows")
   set(LLDB_EXPORT_ALL_SYMBOLS 0 CACHE BOOL
     "Causes lldb to export all symbols when building liblldb.")
 else()
   # Windows doesn't support toggling this, so don't bother making it a
   # cache variable.
   set(LLDB_EXPORT_ALL_SYMBOLS 0)
 endif()
 
 if ((NOT MSVC) OR MSVC12)
   add_definitions( -DHAVE_ROUND )
 endif()
 
 if (LLDB_DISABLE_CURSES)
   add_definitions( -DLLDB_DISABLE_CURSES )
 endif()
 
-option(LLDB_USE_ENTITLEMENTS "When code signing, use entitlements if available" ON)
-set(LLDB_CODESIGN_IDENTITY lldb_codesign CACHE STRING
-    "Identity for code signing debugserver (Darwin only)")
-
-if(LLDB_CODESIGN_IDENTITY)
-  set(LLVM_CODESIGNING_IDENTITY ${LLDB_CODESIGN_IDENTITY} CACHE STRING "" FORCE)
-endif()
-
 # On Windows, we can't use the normal FindPythonLibs module that comes with CMake,
 # for a number of reasons.
 # 1) Prior to MSVC 2015, it is only possible to embed Python if python itself was
 #    compiled with an identical version (and build configuration) of MSVC as LLDB.
 #    The standard algorithm does not take into account the differences between
 #    a binary release distribution of python and a custom built distribution.
 # 2) From MSVC 2015 and onwards, it is only possible to use Python 3.5 or later.
 # 3) FindPythonLibs queries the registry to locate Python, and when looking for a
if( MSVC )
   )
 endif()
 
 # Use the Unicode (UTF-16) APIs by default on Win32
 if (CMAKE_SYSTEM_NAME MATCHES "Windows")
     add_definitions( -D_UNICODE -DUNICODE )
 endif()
 
-set(LLDB_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR})
-set(LLDB_BINARY_DIR ${CMAKE_CURRENT_BINARY_DIR})
-
-if (CMAKE_SOURCE_DIR STREQUAL CMAKE_BINARY_DIR)
-  message(FATAL_ERROR "In-source builds are not allowed. CMake would overwrite "
-"the makefiles distributed with LLDB. Please create a directory and run cmake "
-"from there, passing the path to this source directory as the last argument. "
-"This process created the file `CMakeCache.txt' and the directory "
-"`CMakeFiles'. Please delete them.")
-endif()
-
 # If LLDB_VERSION_* is specified, use it, if not use LLVM_VERSION_*.
 if(NOT DEFINED LLDB_VERSION_MAJOR)
   set(LLDB_VERSION_MAJOR ${LLVM_VERSION_MAJOR})
 endif()
 if(NOT DEFINED LLDB_VERSION_MINOR)
   set(LLDB_VERSION_MINOR ${LLVM_VERSION_MINOR})
 endif()
 if(NOT DEFINED LLDB_VERSION_PATCH)
if(NOT IOS)
     find_library(CARBON_LIBRARY Carbon)
     find_library(CORE_SERVICES_LIBRARY CoreServices)
     find_library(DEBUG_SYMBOLS_LIBRARY DebugSymbols PATHS "/System/Library/PrivateFrameworks")
   endif()
   find_library(FOUNDATION_LIBRARY Foundation)
   find_library(CORE_FOUNDATION_LIBRARY CoreFoundation)
   find_library(SECURITY_LIBRARY Security)
 
-  set(LLDB_FRAMEWORK_INSTALL_DIR Library/Frameworks CACHE STRING "Output directory for LLDB.framework")
-  set(LLDB_FRAMEWORK_VERSION A CACHE STRING "LLDB.framework version (default is A)")
-  set(LLDB_FRAMEWORK_RESOURCE_DIR
-    LLDB.framework/Versions/${LLDB_FRAMEWORK_VERSION}/Resources)
-
   add_definitions( -DLIBXML2_DEFINED )
   list(APPEND system_libs xml2
        ${CURSES_LIBRARIES}
        ${FOUNDATION_LIBRARY}
        ${CORE_FOUNDATION_LIBRARY}
        ${CORE_SERVICES_LIBRARY}
        ${SECURITY_LIBRARY}
        ${DEBUG_SYMBOLS_LIBRARY})

cmake/modules/LLDBFramework.cmake

+# Path relative to the root binary directory
+get_filename_component(
+  framework_target_dir ${LLDB_FRAMEWORK_BUILD_DIR} ABSOLUTE
+  BASE_DIR ${CMAKE_BINARY_DIR}/${CMAKE_CFG_INTDIR}
+)
+
+message(STATUS "LLDB.framework: build path is '${framework_target_dir}'")
+message(STATUS "LLDB.framework: install path is '${LLDB_FRAMEWORK_INSTALL_DIR}'")
+message(STATUS "LLDB.framework: resources subdirectory is 'Versions/${LLDB_FRAMEWORK_VERSION}/Resources'")
+
+# Configure liblldb as a framework bundle
+set_target_properties(liblldb PROPERTIES
+  FRAMEWORK ON
+  FRAMEWORK_VERSION ${LLDB_FRAMEWORK_VERSION}
+
+  OUTPUT_NAME LLDB
+  VERSION ${LLDB_VERSION}
+  LIBRARY_OUTPUT_DIRECTORY ${framework_target_dir}
+
+  # Compatibility version
+  SOVERSION "1.0.0"
+
+  MACOSX_FRAMEWORK_IDENTIFIER com.apple.LLDB.framework
+  MACOSX_FRAMEWORK_BUNDLE_VERSION ${LLDB_VERSION}
+  MACOSX_FRAMEWORK_SHORT_VERSION_STRING ${LLDB_VERSION}
+  MACOSX_FRAMEWORK_INFO_PLIST ${LLDB_SOURCE_DIR}/resources/LLDB-Info.plist.in
+)
+
+# Affects the layout of the framework bundle (default is macOS layout).
+if(IOS)
+  set_target_properties(liblldb PROPERTIES
+    XCODE_ATTRIBUTE_IPHONEOS_DEPLOYMENT_TARGET "${IPHONEOS_DEPLOYMENT_TARGET}")
+else()
+  set_target_properties(liblldb PROPERTIES
+    XCODE_ATTRIBUTE_MACOSX_DEPLOYMENT_TARGET "${MACOSX_DEPLOYMENT_TARGET}")
+endif()
+
+# Target to capture extra steps for a fully functional framework bundle.
+add_custom_target(lldb-framework)
+
+# Dependencies are defined once tools are added (see AddLLDB.cmake)
+if(LLDB_FRAMEWORK_TOOLS)
+  foreach(tool ${LLDB_FRAMEWORK_TOOLS})
+    add_custom_command(TARGET lldb-framework POST_BUILD
+      COMMAND ${CMAKE_COMMAND} -E copy $<TARGET_FILE:${tool}> $<TARGET_FILE_DIR:liblldb>/Resources
+      COMMENT "LLDB.framework: copy additional tool ${tool}"
+    )
+  endforeach()
+else()
+  message(WARNING "LLDB.framework: no additional tools configured (set via LLDB_FRAMEWORK_TOOLS)")
+endif()
+
+# Apart from this one, CMake creates all required symlinks in the framework bundle.
+add_custom_command(TARGET lldb-framework POST_BUILD
+  COMMAND ${CMAKE_COMMAND} -E create_symlink
+          $<TARGET_FILE_DIR:liblldb>/Headers
+          ${framework_target_dir}/LLDB.framework/Headers
+  COMMENT "LLDB.framework: create Headers symlink"
+)
+
+# At configuration time, collect headers for the framework bundle and copy them
+# into a staging directory. Later we can copy over the entire folder.
 file(GLOB public_headers ${LLDB_SOURCE_DIR}/include/lldb/API/*.h)
 file(GLOB root_public_headers ${LLDB_SOURCE_DIR}/include/lldb/lldb-*.h)
 file(GLOB root_private_headers ${LLDB_SOURCE_DIR}/include/lldb/lldb-private*.h)
 list(REMOVE_ITEM root_public_headers ${root_private_headers})
+
+set(lldb_header_staging ${CMAKE_CURRENT_BINARY_DIR}/FrameworkHeaders)
 foreach(header
     ${public_headers}
     ${root_public_headers}
     ${LLDB_SOURCE_DIR}/include/lldb/Utility/SharingPtr.h)
+
   get_filename_component(basename ${header} NAME)
-  add_custom_command(OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/FrameworkHeaders/${basename}
-                     DEPENDS ${header}
-                     COMMAND ${CMAKE_COMMAND} -E copy ${header} ${CMAKE_CURRENT_BINARY_DIR}/FrameworkHeaders/${basename})
-  list(APPEND framework_headers ${CMAKE_CURRENT_BINARY_DIR}/FrameworkHeaders/${basename})
+  set(staged_header ${lldb_header_staging}/${basename})
+
+  add_custom_command(
+    DEPENDS ${header} OUTPUT ${staged_header}
+    COMMAND ${CMAKE_COMMAND} -E copy ${header} ${staged_header}
+    COMMENT "LLDB.framework: collect framework header")
+
+  list(APPEND lldb_staged_headers ${staged_header})
 endforeach()
 
-add_custom_target(lldb-framework-headers DEPENDS ${framework_headers})
+# Wrap output in a target, so lldb-framework can depend on it.
+add_custom_target(lldb-framework-headers DEPENDS ${lldb_staged_headers})
 
-add_custom_command(TARGET lldb-framework POST_BUILD
-  COMMAND ${CMAKE_COMMAND} -E copy_directory ${CMAKE_CURRENT_BINARY_DIR}/FrameworkHeaders $<TARGET_FILE_DIR:liblldb>/Headers
+# At build time, copy the staged headers into the framework bundle (and do
+# some post-processing in-place).
+add_custom_command(TARGET lldb-framework-headers POST_BUILD
+  COMMAND ${CMAKE_COMMAND} -E copy_directory ${lldb_header_staging} $<TARGET_FILE_DIR:liblldb>/Headers
   COMMAND ${LLDB_SOURCE_DIR}/scripts/framework-header-fix.sh $<TARGET_FILE_DIR:liblldb>/Headers ${LLDB_VERSION}
+  COMMENT "LLDB.framework: copy framework headers"
 )
 
-if (NOT IOS)
-  if (NOT LLDB_BUILT_STANDALONE)
-    add_dependencies(lldb-framework clang-headers)
-  endif()
-  add_custom_command(TARGET lldb-framework POST_BUILD
-    COMMAND ${CMAKE_COMMAND} -E create_symlink Versions/Current/Headers ${LLDB_FRAMEWORK_DIR}/LLDB.framework/Headers
-    COMMAND ${CMAKE_COMMAND} -E create_symlink ${LLDB_FRAMEWORK_VERSION} ${LLDB_FRAMEWORK_DIR}/LLDB.framework/Versions/Current
-    COMMAND ${CMAKE_COMMAND} -E copy_directory ${CMAKE_BINARY_DIR}/lib${LLVM_LIBDIR_SUFFIX}/clang/${LLVM_VERSION_MAJOR}.${LLVM_VERSION_MINOR}.${LLVM_VERSION_PATCH} $<TARGET_FILE_DIR:liblldb>/Resources/Clang
+# Also collect vendor-specific headers from clang and copy them into a
+# staging directory. Later we can copy over the entire folder.
+if(NOT IOS AND NOT LLDB_BUILT_STANDALONE)
+  get_target_property(clang_include_dir clang-headers RUNTIME_OUTPUT_DIRECTORY)
+  file(GLOB_RECURSE clang_vendor_headers RELATIVE ${clang_include_dir} "${clang_include_dir}/*")
+
+  set(clang_header_staging ${CMAKE_CURRENT_BINARY_DIR}/ClangHeaders)
+  foreach(header ${clang_vendor_headers})
+    set(source_header ${clang_include_dir}/${header})
+    set(staged_header ${clang_header_staging}/${header})
+
+    add_custom_command(
+      DEPENDS ${source_header} OUTPUT ${staged_header}
+      COMMAND ${CMAKE_COMMAND} -E copy ${source_header} ${staged_header}
+      COMMENT "LLDB.framework: collect clang vendor-specific headers")
+
+    list(APPEND clang_staged_headers ${staged_header})
+  endforeach()
+
+  # Wrap output in a target, so lldb-framework can depend on it.
+  add_custom_target(lldb-framework-clang-headers DEPENDS ${clang_staged_headers})
+  add_dependencies(lldb-framework-clang-headers clang-headers)
+
+  # At build time, copy the staged headers into the framework bundle.
+  add_custom_command(TARGET lldb-framework-clang-headers POST_BUILD
+    COMMAND ${CMAKE_COMMAND} -E copy_directory
+            ${clang_header_staging} $<TARGET_FILE_DIR:liblldb>/Resources/Clang/include
   )
-endif()
 
+  # liblldb creates the binary.
+  # lldb-framework adds extra steps for a fully functional framework bundle.
   add_dependencies(lldb-framework
+    liblldb
     lldb-framework-headers
-  lldb-suite)
-
-add_custom_target(install-lldb-framework)
-add_custom_target(install-lldb-framework-stripped)
+    lldb-framework-clang-headers
+  )
+endif()

resources/LLDB-Info.plist.in

+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>CFBundleDevelopmentRegion</key>
+  <string>English</string>
+  <key>CFBundleExecutable</key>
+  <string>LLDB</string>
+  <key>CFBundleIdentifier</key>
+  <string>${MACOSX_FRAMEWORK_IDENTIFIER}</string>
+  <key>CFBundleInfoDictionaryVersion</key>
+  <string>6.0</string>
+  <key>CFBundlePackageType</key>
+  <string>FMWK</string>
+  <key>CFBundleShortVersionString</key>
+  <string>${MACOSX_FRAMEWORK_SHORT_VERSION_STRING}</string>
+  <key>CFBundleSignature</key>
+  <string>????</string>
+  <key>CFBundleVersion</key>
+  <string>${MACOSX_FRAMEWORK_BUNDLE_VERSION}</string>
+  <key>CFBundleName</key>
+  <string>LLDB</string>
+</dict>
+</plist>

source/API/CMakeLists.txt

LINK_LIBS
     lldbSymbol
     lldbTarget
     lldbUtility
     ${LLDB_ALL_PLUGINS}
   LINK_COMPONENTS
     Support
   )
 
-add_dependencies(lldb-suite liblldb)
+if(LLDB_WRAP_PYTHON)
+  add_dependencies(liblldb swig_wrapper)
 
   if (MSVC)
     set_property(SOURCE ${LLDB_WRAP_PYTHON} APPEND_STRING PROPERTY COMPILE_FLAGS " /W0")
   else()
     set_property(SOURCE ${LLDB_WRAP_PYTHON} APPEND_STRING PROPERTY COMPILE_FLAGS " -w")
   endif()
 
-set_source_files_properties(${LLDB_WRAP_PYTHON} PROPERTIES GENERATED 1)
   if (CLANG_CL)
     set_property(SOURCE ${LLDB_WRAP_PYTHON} APPEND_STRING
       PROPERTY COMPILE_FLAGS " -Wno-unused-function")
   endif()
   if (LLVM_COMPILER_IS_GCC_COMPATIBLE AND
       NOT "${CMAKE_SYSTEM_NAME}" MATCHES "Darwin")
     set_property(SOURCE ${LLDB_WRAP_PYTHON} APPEND_STRING
       PROPERTY COMPILE_FLAGS " -Wno-sequence-point -Wno-cast-qual")
   endif ()
+endif()
 
 set_target_properties(liblldb
   PROPERTIES
   VERSION ${LLDB_VERSION}
 )
 
 if (NOT CMAKE_SYSTEM_NAME MATCHES "Windows")
   if (NOT LLDB_EXPORT_ALL_SYMBOLS)
if ( CMAKE_SYSTEM_NAME MATCHES "Windows" )
   endif()
 else()
   set_target_properties(liblldb
     PROPERTIES
     OUTPUT_NAME lldb
   )
 endif()
 
-if (LLDB_BUILD_FRAMEWORK)
-  set_target_properties(liblldb
-    PROPERTIES
-    SOVERSION "1.0.0"
-    OUTPUT_NAME LLDB
-    FRAMEWORK On
-    FRAMEWORK_VERSION ${LLDB_FRAMEWORK_VERSION}
-    MACOSX_FRAMEWORK_INFO_PLIST ${LLDB_SOURCE_DIR}/resources/LLDB-Info.plist
-    LIBRARY_OUTPUT_DIRECTORY ${LLDB_FRAMEWORK_DIR}
-  )
-endif()
-
-if (LLDB_WRAP_PYTHON)
-  add_dependencies(liblldb swig_wrapper)
+if(LLDB_BUILD_FRAMEWORK)
+  include(LLDBFramework)
 endif()

test/CMakeLists.txt

if ( CMAKE_SYSTEM_NAME MATCHES "Windows" )
   endif()
 endif()
 
 if(LLDB_CODESIGN_IDENTITY)
   list(APPEND LLDB_TEST_COMMON_ARGS --codesign-identity "${LLDB_CODESIGN_IDENTITY}")
 endif()
 
 if(LLDB_BUILD_FRAMEWORK)
-  list(APPEND LLDB_TEST_COMMON_ARGS --framework ${LLDB_FRAMEWORK_DIR}/LLDB.framework)
+  # The $<TARGET_PROPERTY:liblldb,LIBRARY_OUTPUT_DIRECTORY> generator expression
+  # provides this value, but LLDB_DOTEST_ARGS needs it at configuration-time.
+  get_filename_component(
+    framework_target_dir ${LLDB_FRAMEWORK_BUILD_DIR} ABSOLUTE
+    BASE_DIR ${CMAKE_BINARY_DIR}/${CMAKE_CFG_INTDIR}
+  )
+  list(APPEND LLDB_TEST_COMMON_ARGS --framework ${framework_target_dir}/LLDB.framework)
 endif()
 
 if (NOT ${CMAKE_SYSTEM_NAME} MATCHES "Windows|Darwin")
   list(APPEND LLDB_TEST_COMMON_ARGS
     --env ARCHIVER=${CMAKE_AR} --env OBJCOPY=${CMAKE_OBJCOPY})
 endif()
 
 if (NOT "${LLDB_LIT_TOOLS_DIR}" STREQUAL "")

tools/argdumper/CMakeLists.txt

-add_lldb_tool(lldb-argdumper INCLUDE_IN_SUITE
+add_lldb_tool(lldb-argdumper
   argdumper.cpp
 
   LINK_LIBS
     lldbUtility
   )

tools/darwin-debug/CMakeLists.txt

-add_lldb_tool(darwin-debug INCLUDE_IN_SUITE
+add_lldb_tool(darwin-debug
   darwin-debug.cpp
   )

tools/debugserver/CMakeLists.txt

set(CMAKE_MODULE_PATH
     )
 
   include(LLDBStandalone)
   include(debugserverConfig)
   include(AddLLDB)
 
   set(LLDB_SOURCE_DIR "${CMAKE_SOURCE_DIR}/../../")
   include_directories(${LLDB_SOURCE_DIR}/include)
-
-  # lldb-suite is a dummy target that encompasses all the necessary tools and
-  # libraries for building a fully-functioning liblldb.
-  add_custom_target(lldb-suite)
-  set(LLDB_SUITE_TARGET lldb-suite)
 endif()
 
 add_subdirectory(source)

tools/debugserver/source/CMakeLists.txt

target_link_libraries(lldbDebugserverCommon
                         lldbDebugserverArchSupport
                         lldbDebugserverDarwin_DarwinLog
                         ${LIBCOMPRESSION})
   if(HAVE_LIBCOMPRESSION)
     set_property(TARGET lldbDebugserverCommon APPEND PROPERTY
                  COMPILE_DEFINITIONS HAVE_LIBCOMPRESSION)
   endif()
   set(LLVM_OPTIONAL_SOURCES ${lldbDebugserverCommonSources})
-  add_lldb_tool(debugserver INCLUDE_IN_SUITE
+  add_lldb_tool(debugserver
     debugserver.cpp
 
     LINK_LIBS
       lldbDebugserverCommon
 
     ENTITLEMENTS
       ${entitlements}
     )

tools/driver/CMakeLists.txt

LINK_COMPONENTS
     Support
   )
 
 if ( CMAKE_SYSTEM_NAME MATCHES "Windows" )
   add_definitions( -DIMPORT_LIBLLDB )
 endif()
 
 add_dependencies(lldb
-  ${LLDB_SUITE_TARGET}
   LLDBOptionsTableGen
   ${tablegen_deps}
 )

tools/lldb-server/CMakeLists.txt

 if(CMAKE_SYSTEM_NAME MATCHES "Darwin")
   list(APPEND LLDB_PLUGINS lldbPluginObjectFileMachO)
 elseif(CMAKE_SYSTEM_NAME MATCHES "Windows")
   list(APPEND LLDB_PLUGINS lldbPluginObjectFilePECOFF)
 else()
   list(APPEND LLDB_PLUGINS lldbPluginObjectFileELF)
 endif()
 
-add_lldb_tool(lldb-server INCLUDE_IN_SUITE
+add_lldb_tool(lldb-server
     Acceptor.cpp
     lldb-gdbserver.cpp
     lldb-platform.cpp
     lldb-server.cpp
     LLDBServerUtilities.cpp
     SystemInitializerLLGS.cpp
 
     LINK_LIBS