Stop building liblldb with CMake's framework functionality

[xiaobai]

Summary

CMake has a bug in its ninja generator that prevents you from
installing targets that are built with framework support. Therefore, I want to
not rely on CMake's framework support.

[xiaobai]

Tested this by invoking

cmake .. -G Ninja -DCMAKE_BUILD_TYPE=Debug -DLLDB_BUILD_FRAMEWORK=1 && ninja lldb

The resulting framework appears to be the same as before.

[labath]

Can't say I fully understand what's going on, but the changes seem reasonable to me.

If there is some public cmake bug describing the issue you ran into, it would be nice, for the sake of future archaeologists, to reference it somewhere (commit message and LLDBFramework.cmake?).

[xiaobai]

In D49888#1177929, @labath wrote:

Can't say I fully understand what's going on, but the changes seem reasonable to me.

Let me know if I can clear anything up.

If there is some public cmake bug describing the issue you ran into, it would be nice, for the sake of future archaeologists, to reference it somewhere (commit message and LLDBFramework.cmake?).

I haven't checked to see if a bug has been filed for this specific case but I have a minimal repro. I'll file a bug against CMake and add a link to the report in the commit message and in LLDBFramework.cmake before I actually commit this.

[xiaobai]

Add comment pointing to CMake bug report

lldb/trunk/CMakeLists.txt

 if(LLDB_BUILD_FRAMEWORK)
   if (CMAKE_VERSION VERSION_LESS 3.7)
     message(FATAL_ERROR "LLDB_BUILD_FRAMEWORK is not supported on CMake < 3.7")
   endif()
   if (NOT APPLE)
     message(FATAL_ERROR "LLDB.framework can only be generated when targeting Apple platforms")
   endif()
 
+  add_custom_target(lldb-framework)
+  set(LLDB_SUITE_TARGET lldb-framework)
+  set(LLDB_FRAMEWORK_DIR
+    ${CMAKE_BINARY_DIR}/${CMAKE_CFG_INTDIR}/${LLDB_FRAMEWORK_INSTALL_DIR}/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 "360.99.0")
-  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_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)
if(LLDB_INCLUDE_TESTS)
   endif()
 
   add_subdirectory(test)
   add_subdirectory(unittests)
   add_subdirectory(lit)
   add_subdirectory(utils/lldb-dotest)
 endif()
 
-if (LLDB_BUILD_FRAMEWORK)
-  add_custom_target(lldb-framework)
-  include(LLDBFramework)
-endif()
-
 if (NOT LLDB_DISABLE_PYTHON)
     # 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}

lldb/trunk/cmake/modules/AddLLDB.cmake

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})
+          set(out_dir ${LLDB_FRAMEWORK_INSTALL_DIR}/LLDB.framework/Versions/${LLDB_FRAMEWORK_VERSION})
         endif()
         install(TARGETS ${name}
           COMPONENT ${name}
           RUNTIME DESTINATION bin
           LIBRARY DESTINATION ${out_dir}
           ARCHIVE DESTINATION ${out_dir})
       else()
         install(TARGETS ${name}
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}
+            RUNTIME_OUTPUT_DIRECTORY ${LLDB_FRAMEWORK_DIR}/${LLDB_FRAMEWORK_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()
 
   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})
+      set(out_dir ${LLDB_FRAMEWORK_INSTALL_DIR}/LLDB.framework/${LLDB_FRAMEWORK_RESOURCE_DIR})
     endif()
     install(TARGETS ${name}
           COMPONENT ${name}
           RUNTIME DESTINATION ${out_dir})
     if (NOT CMAKE_CONFIGURATION_TYPES)
       add_llvm_install_targets(install-${name}
                                DEPENDS ${name}
                                COMPONENT ${name})

lldb/trunk/cmake/modules/LLDBConfig.cmake

if (APPLE)
   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)
+    Versions/${LLDB_FRAMEWORK_VERSION}/Resources)
+  set(LLDB_FRAMEWORK_HEADER_DIR
+    Versions/${LLDB_FRAMEWORK_VERSION}/Headers)
 
   add_definitions( -DLIBXML2_DEFINED )
   list(APPEND system_libs xml2
        ${CURSES_LIBRARIES}
        ${FOUNDATION_LIBRARY}
        ${CORE_FOUNDATION_LIBRARY}
        ${CORE_SERVICES_LIBRARY}
        ${SECURITY_LIBRARY}

lldb/trunk/cmake/modules/LLDBFramework.cmake

+# We intentionally do not use CMake's framework support because of a bug in
+# CMake. See: https://gitlab.kitware.com/cmake/cmake/issues/18216
+
+# We set up part of the framework structure first, as some scripts and build
+# rules assume they exist already.
+file(MAKE_DIRECTORY ${LLDB_FRAMEWORK_DIR} ${LLDB_FRAMEWORK_DIR}/${LLDB_FRAMEWORK_RESOURCE_DIR})
+execute_process(
+  COMMAND
+    ${CMAKE_COMMAND} -E create_symlink ${LLDB_FRAMEWORK_VERSION} ${LLDB_FRAMEWORK_DIR}/Versions/Current
+  COMMAND
+    ${CMAKE_COMMAND} -E create_symlink Versions/Current/Resources ${LLDB_FRAMEWORK_DIR}/Resources
+)
+
 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})
 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})
 endforeach()
 
 add_custom_target(lldb-framework-headers DEPENDS ${framework_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
-  COMMAND ${LLDB_SOURCE_DIR}/scripts/framework-header-fix.sh $<TARGET_FILE_DIR:liblldb>/Headers ${LLDB_VERSION}
+  COMMAND ${CMAKE_COMMAND} -E copy_directory ${CMAKE_CURRENT_BINARY_DIR}/FrameworkHeaders ${LLDB_FRAMEWORK_DIR}/${LLDB_FRAMEWORK_HEADER_DIR}
+  COMMAND ${LLDB_SOURCE_DIR}/scripts/framework-header-fix.sh ${LLDB_FRAMEWORK_DIR}/${LLDB_FRAMEWORK_HEADER_DIR} ${LLDB_VERSION}
 )
 
 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/${LLDB_VERSION} $<TARGET_FILE_DIR:liblldb>/Resources/Clang
+    COMMAND ${CMAKE_COMMAND} -E create_symlink Versions/Current/Headers ${LLDB_FRAMEWORK_DIR}/Headers
+    COMMAND ${CMAKE_COMMAND} -E create_symlink Versions/Current/LLDB ${LLDB_FRAMEWORK_DIR}/LLDB
+    COMMAND ${CMAKE_COMMAND} -E create_symlink ${LLDB_FRAMEWORK_VERSION} ${LLDB_FRAMEWORK_DIR}/Versions/Current
+    COMMAND ${CMAKE_COMMAND} -E copy_directory ${CMAKE_BINARY_DIR}/lib${LLVM_LIBDIR_SUFFIX}/clang/${LLDB_VERSION} ${LLDB_FRAMEWORK_DIR}/${LLDB_FRAMEWORK_RESOURCE_DIR}/Clang
   )
 endif()
 
-set_target_properties(liblldb PROPERTIES
-  OUTPUT_NAME LLDB
-  FRAMEWORK On
-  FRAMEWORK_VERSION ${LLDB_FRAMEWORK_VERSION}
-  MACOSX_FRAMEWORK_INFO_PLIST ${LLDB_SOURCE_DIR}/resources/LLDB-Info.plist
-  LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/${LLDB_FRAMEWORK_INSTALL_DIR}
-  PUBLIC_HEADER "${framework_headers}")
+# These are used to fill out LLDB-Info.plist. These are relevant when building
+# the framework, and must be defined before configuring Info.plist.
+set(PRODUCT_NAME "LLDB")
+set(EXECUTABLE_NAME "LLDB")
+set(CURRENT_PROJECT_VERSION "360.99.0")
+configure_file(${LLDB_SOURCE_DIR}/resources/LLDB-Info.plist
+  ${LLDB_FRAMEWORK_DIR}/${LLDB_FRAMEWORK_RESOURCE_DIR}/Info.plist)
 
 add_dependencies(lldb-framework
   lldb-framework-headers
   lldb-suite)

lldb/trunk/scripts/CMakeLists.txt

 
 set(SWIG_INSTALL_DIR lib${LLVM_LIBDIR_SUFFIX})
 
 # Generating the LLDB framework correctly is a bit complicated because the
 # framework depends on the swig output.
 if(LLDB_BUILD_FRAMEWORK)
   set(framework_arg --framework --target-platform Darwin)
   set(SWIG_PYTHON_DIR
-    ${LLDB_PYTHON_TARGET_DIR}/${LLDB_FRAMEWORK_RESOURCE_DIR}/Python)
+    ${LLDB_FRAMEWORK_DIR}/${LLDB_FRAMEWORK_RESOURCE_DIR}/Python)
   set(SWIG_INSTALL_DIR
-    ${LLDB_FRAMEWORK_INSTALL_DIR}/${LLDB_FRAMEWORK_RESOURCE_DIR})
+    ${LLDB_FRAMEWORK_INSTALL_DIR}/LLDB.framework/${LLDB_FRAMEWORK_RESOURCE_DIR})
 endif()
 
 get_filename_component(CFGBLDDIR ${LLDB_WRAP_PYTHON} DIRECTORY)
 
 find_package(SWIG REQUIRED)
 add_custom_command(
   OUTPUT ${LLDB_WRAP_PYTHON}
   OUTPUT ${LLDB_PYTHON_TARGET_DIR}/lldb.py
   DEPENDS ${SWIG_SOURCES}
   DEPENDS ${SWIG_INTERFACES}
   DEPENDS ${SWIG_HEADERS}
   DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/Python/prepare_binding_Python.py
   DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/Python/modify-python-lldb.py
   COMMAND ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/prepare_bindings.py
       ${framework_arg}
       --srcRoot=${LLDB_SOURCE_DIR}
       --targetDir=${LLDB_PYTHON_TARGET_DIR}
       --cfgBldDir=${CFGBLDDIR}
       --prefix=${CMAKE_BINARY_DIR}
       --swigExecutable=${SWIG_EXECUTABLE}
   VERBATIM
   COMMENT "Python script building LLDB Python wrapper")
 add_custom_target(swig_wrapper ALL DEPENDS ${LLDB_WRAP_PYTHON})
 
-set_source_files_properties(${CMAKE_CURRENT_BINARY_DIR}/lldb.py PROPERTIES GENERATED 1)
+set_source_files_properties(${LLDB_PYTHON_TARGET_DIR}/lldb.py PROPERTIES GENERATED 1)
 
 
 # Install the LLDB python module
 install(DIRECTORY ${SWIG_PYTHON_DIR} DESTINATION ${SWIG_INSTALL_DIR})
 
 # build Python modules
 add_subdirectory(Python/modules)

lldb/trunk/source/API/CMakeLists.txt

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 ()
 
+if (LLDB_BUILD_FRAMEWORK)
+  set_target_properties(liblldb
+    PROPERTIES
+    LIBRARY_OUTPUT_DIRECTORY ${LLDB_FRAMEWORK_DIR}/Versions/${LLDB_FRAMEWORK_VERSION}
+    PREFIX ""
+    SUFFIX ""
+    INSTALL_NAME_DIR "@rpath/LLDB.framework"
+    OUTPUT_NAME LLDB)
+else()
   set_target_properties(liblldb
     PROPERTIES
     VERSION ${LLDB_VERSION}
-)
+    OUTPUT_NAME lldb)
+endif()
 
 if (NOT CMAKE_SYSTEM_NAME MATCHES "Windows")
   if (NOT LLDB_EXPORT_ALL_SYMBOLS)
     # If we're not exporting all symbols, we'll want to explicitly set
     # the exported symbols here.  This prevents 'log enable --stack ...'
     # from working on some systems but limits the liblldb size.
     MESSAGE("-- Symbols (liblldb): exporting all symbols from the lldb namespace")
     add_llvm_symbol_exports(liblldb ${CMAKE_CURRENT_SOURCE_DIR}/liblldb.exports)
   else()
     # Don't use an explicit export.  Instead, tell the linker to
     # export all symbols.
     MESSAGE("-- Symbols (liblldb): exporting all symbols from the lldb and lldb_private namespaces")
     add_llvm_symbol_exports(liblldb ${CMAKE_CURRENT_SOURCE_DIR}/liblldb-private.exports)
   endif()
 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)
     target_link_libraries(liblldb PRIVATE ${PYTHON_LIBRARY})
   endif()
-else()
-  set_target_properties(liblldb
-    PROPERTIES
-    OUTPUT_NAME lldb
-  )
 endif()
 
 if (LLDB_WRAP_PYTHON)
   add_dependencies(liblldb swig_wrapper)
 endif()