[CMake] Support statically linking dependencies only to shared or static library

[phosek]

Summary

Currently it's possible to select whether to statically link unwinder
or the C++ ABI library, but this option applies to both the shared
and static library. However, in some scenarios it may be desirable to
only statically link unwinder and C++ ABI library into static C++
library since for shared C++ library we can rely on dynamic linking
and linker scripts. This change enables selectively enabling or
disabling statically linking only to shared or static library.

[phosek]

This came up in Fuchsia. Clang driver, add -lc++ as a dependency. This is sufficient for shared libc++, but for static user has to manually pass -lc++abi -lunwind, so for static libc++ we would actually like to combine both libc++abi and libunwind into a single archive.

[phosek]

libcxx/CMakeLists.txt

158 ↗

(On Diff #156127)

Maybe LIBCXX_ENABLE_STATIC_ABI_LIBRARY_IN_STATIC_LIBRARY would be more accurate?

[ldionne]

libcxx/CMakeLists.txt

158 ↗

(On Diff #156127)

LIBCXX_STATICALLY_LINK_ABI_IN_STATIC_LIBRARY and LIBCXX_STATICALLY_LINK_ABI_IN_SHARED_LIBRARY?

And then LIBCXXABI_STATICALLY_LINK_UNWINDER_IN_STATIC_LIBRARY/LIBCXXABI_STATICALLY_LINK_UNWINDER_IN_SHARED_LIBRARY.

libcxx/lib/CMakeLists.txt

269 ↗

(On Diff #156127)

I don't understand why any of this needs to change -- can you please explain? Also, you probably didn't mean to leave the commented-out lines.

[phosek]

libcxx/lib/CMakeLists.txt

269 ↗

(On Diff #156127)

The reason this change is needed the case when we're linking shared libc++abi into shared libc++ in which case ${LIBCXX_CXX_ABI_LIBRARY} will be set to cxxabi_shared in HandleLibCXXABI.cmake but we cannot merge libc++abi.so into libc++.a, so instead we force the use of cxxabi_static here.

Alternatively, we could modify HandleLibCXXABI.cmake to set two dependencies, one for the static case and one for the shared case and use the former one here.

Removed the commented out lines.

[ldionne]

libcxx/lib/CMakeLists.txt

269 ↗

(On Diff #156127)

Thanks. There's something I still don't understand. If you are linking the ABI library dynamically, why would you want to merge it (well, the static version of it) into libc++.a? It seems like this is somewhat defeating the purpose of dynamically linking against the ABI library, no?

libcxxabi/src/CMakeLists.txt

64 ↗

(On Diff #156201)

Does this not need to change anymore? I think we'd have to set different flags for cxxabi_shared and cxxabi_static.

[phosek]

libcxx/lib/CMakeLists.txt

269 ↗

(On Diff #156127)

In our case, we want to link shared library dynamically and merge all static libraries, so LIBCXX_STATICALLY_LINK_ABI_IN_SHARED_LIBRARY=OFF and LIBCXX_STATICALLY_LINK_ABI_IN_STATIC_LIBRARY=ON. This means that LIBCXX_CXX_ABI_LIBRARY will be set to cxxabi_shared and it's what will be used other places throughout this file as the interface library. However, we cannot merge libc++abi.so into libc++.a so that's why we have to explicitly select cxxabi_static here rather than simply using LIBCXX_CXX_ABI_LIBRARY as before.

Like I mentioned in the previous comment, alternative would be to split this into two variables, e.g. LIBCXX_CXX_SHARED_ABI_LIBRARY and LIBCXX_CXX_STATIC_ABI_LIBRARY, would you prefer that approach?

libcxxabi/src/CMakeLists.txt

64 ↗

(On Diff #156201)

This is relying on the fact that LIBCXXABI_LIBRARIES isn't used for library merging that's done on lines 158-162 and CMake should ignore shared library dependencies passed to target_link_libraries when building static library as done on line 163 (since linking dynamic library target against static library doesn't make sense). This seems to be working fine in my testing, but I'm also OK splitting this into two variables if you want it to be explicit.

[ldionne]

libcxx/lib/CMakeLists.txt

269 ↗

(On Diff #156127)

Yes, I understand why the TARGET_LINKER_FILE must also be cxxabi_static. What I don't understand is why the conditions need to change, i.e. why you're going from

if (TARGET ${LIBCXX_CXX_ABI_LIBRARY} OR
    (${LIBCXX_CXX_ABI_LIBRARY} MATCHES "cxxabi(_static|_shared)?" AND HAVE_LIBCXXABI))

to

if (${LIBCXX_CXX_ABI_LIBRARY} MATCHES "cxxabi(_static|_shared)?"
        AND (TARGET cxxabi_static OR HAVE_LIBCXXABI))

Note that I do think your new condition make more sense (since if the ABI library is not a target, we should fall back on the else() branch). I just want to understand why you're changing it.

Like I mentioned in the previous comment, alternative would be to split this into two variables, e.g. LIBCXX_CXX_SHARED_ABI_LIBRARY and LIBCXX_CXX_STATIC_ABI_LIBRARY, would you prefer that approach?

I don't think that is necessary at this point.

libcxxabi/src/CMakeLists.txt

64 ↗

(On Diff #156201)

I would rather see it handled explicitly.

[phosek]

libcxx/lib/CMakeLists.txt

269 ↗

(On Diff #156127)

You're right, that's a leftover from previous iterations.

[ldionne]

LGTM

libcxx/trunk/CMakeLists.txt

 else()
   set(LIBCXX_CXX_ABI_LIBNAME "${LIBCXX_CXX_ABI}")
 endif()
 
 # Use a static copy of the ABI library when linking libc++. This option
 # cannot be used with LIBCXX_ENABLE_ABI_LINKER_SCRIPT.
 option(LIBCXX_ENABLE_STATIC_ABI_LIBRARY "Statically link the ABI library" OFF)
 
+cmake_dependent_option(LIBCXX_STATICALLY_LINK_ABI_IN_STATIC_LIBRARY
+  "Statically link the ABI library to static library" ON
+  "LIBCXX_ENABLE_STATIC_ABI_LIBRARY;LIBCXX_ENABLE_STATIC" OFF)
+
+cmake_dependent_option(LIBCXX_STATICALLY_LINK_ABI_IN_SHARED_LIBRARY
+  "Statically link the ABI library to shared library" ON
+  "LIBCXX_ENABLE_STATIC_ABI_LIBRARY;LIBCXX_ENABLE_STATIC" OFF)
+
 # Generate and install a linker script inplace of libc++.so. The linker script
 # will link libc++ to the correct ABI library. This option is on by default
 # on UNIX platforms other than Apple unless 'LIBCXX_ENABLE_STATIC_ABI_LIBRARY'
 # is on. This option is also disabled when the ABI library is not specified
 # or is specified to be "none".
 set(ENABLE_LINKER_SCRIPT_DEFAULT_VALUE OFF)
 if (LLVM_HAVE_LINK_VERSION_SCRIPT AND NOT LIBCXX_ENABLE_STATIC_ABI_LIBRARY
       AND NOT LIBCXX_CXX_ABI_LIBNAME STREQUAL "none"

libcxx/trunk/cmake/Modules/HandleLibCXXABI.cmake

if ("${LIBCXX_CXX_ABI_LIBNAME}" STREQUAL "libstdc++" OR
   endif()
   setup_abi_lib(
     "-D__GLIBCXX__ ${_LIBSUPCXX_DEFINES}"
     "${_LIBSUPCXX_LIBNAME}" "${_LIBSUPCXX_INCLUDE_FILES}" "bits"
     )
 elseif ("${LIBCXX_CXX_ABI_LIBNAME}" STREQUAL "libcxxabi")
   if (LIBCXX_CXX_ABI_INTREE)
     # Link against just-built "cxxabi" target.
-    if (LIBCXX_ENABLE_STATIC_ABI_LIBRARY)
-        set(CXXABI_LIBNAME cxxabi_static)
+    if (LIBCXX_STATICALLY_LINK_ABI_IN_SHARED_LIBRARY)
     else()
-        set(CXXABI_LIBNAME cxxabi_shared)
     endif()
     set(LIBCXX_LIBCPPABI_VERSION "2" PARENT_SCOPE)
   else()
     # Assume c++abi is installed in the system, rely on -lc++abi link flag.
     set(CXXABI_LIBNAME "c++abi")
   endif()
   set(HEADERS "cxxabi.h;__cxxabi_config.h")
   if (LIBCXX_CXX_ABI_SYSTEM)

libcxx/trunk/lib/CMakeLists.txt

 endif()
 add_library_flags_if(LIBCXX_COVERAGE_LIBRARY "${LIBCXX_COVERAGE_LIBRARY}")
 
 if (APPLE AND (LIBCXX_CXX_ABI_LIBNAME STREQUAL "libcxxabi" OR
                LIBCXX_CXX_ABI_LIBNAME STREQUAL "default"))
   set(LIBCXX_OSX_REEXPORT_SYSTEM_ABI_LIBRARY ON)
 endif()
 
-if (LIBCXX_ENABLE_STATIC_ABI_LIBRARY)
+if (LIBCXX_STATICALLY_LINK_ABI_IN_SHARED_LIBRARY)
   add_library_flags("-Wl,--whole-archive" "-Wl,-Bstatic")
   add_library_flags("${LIBCXX_CXX_ABI_LIBRARY}")
   add_library_flags("-Wl,-Bdynamic" "-Wl,--no-whole-archive")
 elseif (LIBCXX_OSX_REEXPORT_SYSTEM_ABI_LIBRARY)
   add_library_flags("${LIBCXX_CXX_ABI_LIBRARY}")
 else ()
  add_interface_library("${LIBCXX_CXX_ABI_LIBRARY}")
 endif()
if (LIBCXX_ENABLE_STATIC)
   set_target_properties(cxx_static
     PROPERTIES
       LINK_FLAGS    "${LIBCXX_LINK_FLAGS}"
       OUTPUT_NAME   "c++"
   )
 
   list(APPEND LIBCXX_TARGETS "cxx_static")
   # Attempt to merge the libc++.a archive and the ABI library archive into one.
-  if (LIBCXX_ENABLE_STATIC_ABI_LIBRARY)
+  if (LIBCXX_STATICALLY_LINK_ABI_IN_STATIC_LIBRARY)
     set(MERGE_ARCHIVES_SEARCH_PATHS "")
     if (LIBCXX_CXX_ABI_LIBRARY_PATH)
       set(MERGE_ARCHIVES_SEARCH_PATHS "-L${LIBCXX_CXX_ABI_LIBRARY_PATH}")
     endif()
     if ((TARGET ${LIBCXX_CXX_ABI_LIBRARY}) OR
         (${LIBCXX_CXX_ABI_LIBRARY} MATCHES "cxxabi(_static|_shared)?" AND HAVE_LIBCXXABI))
-      set(MERGE_ARCHIVES_ABI_TARGET "$<TARGET_LINKER_FILE:${LIBCXX_CXX_ABI_LIBRARY}>")
+      set(MERGE_ARCHIVES_ABI_TARGET "$<TARGET_LINKER_FILE:cxxabi_static>")
     else()
       set(MERGE_ARCHIVES_ABI_TARGET
           "${CMAKE_STATIC_LIBRARY_PREFIX}${LIBCXX_CXX_ABI_LIBRARY}${CMAKE_STATIC_LIBRARY_SUFFIX}")
     endif()
     add_custom_command(TARGET cxx_static POST_BUILD
     COMMAND
       ${PYTHON_EXECUTABLE} ${LIBCXX_SOURCE_DIR}/utils/merge_archives.py
     ARGS

libcxxabi/trunk/CMakeLists.txt

 # the libc++abi that is being built. There are two problems with testing a
 # static libc++abi. In the case of a standalone build, the tests will link the
 # system's libc++, which might not have been built against our libc++abi. In the
 # case of an in tree build, libc++ will prefer a dynamic libc++abi from the
 # system over a static libc++abi from the output directory.
 option(LIBCXXABI_ENABLE_SHARED "Build libc++abi as a shared library." ON)
 option(LIBCXXABI_ENABLE_STATIC "Build libc++abi as a static library." ON)
 
+cmake_dependent_option(LIBCXXABI_STATICALLY_LINK_UNWINDER_IN_STATIC_LIBRARY
+  "Statically link the LLVM unwinder to static library" ON
+  "LIBCXXABI_ENABLE_STATIC_UNWINDER;LIBCXXABI_ENABLE_STATIC" OFF)
+cmake_dependent_option(LIBCXXABI_STATICALLY_LINK_UNWINDER_IN_SHARED_LIBRARY
+  "Statically link the LLVM unwinder to shared library" ON
+  "LIBCXXABI_ENABLE_STATIC_UNWINDER;LIBCXXABI_ENABLE_SHARED" OFF)
+
 option(LIBCXXABI_BAREMETAL "Build libc++abi for baremetal targets." OFF)
 # The default terminate handler attempts to demangle uncaught exceptions, which
 # causes extra I/O and demangling code to be pulled in.
 option(LIBCXXABI_SILENT_TERMINATE "Set this to make the terminate handler default to a silent alternative" OFF)
 
 if (NOT LIBCXXABI_ENABLE_SHARED AND NOT LIBCXXABI_ENABLE_STATIC)
   message(FATAL_ERROR "libc++abi must be built as either a shared or static library.")
 endif()

libcxxabi/trunk/src/CMakeLists.txt

if (LIBCXXABI_ENABLE_THREADS)
   add_library_flags_if(LIBCXXABI_HAS_PTHREAD_LIB pthread)
 endif()
 
 add_library_flags_if(LIBCXXABI_HAS_C_LIB c)
 if (LIBCXXABI_USE_LLVM_UNWINDER)
   # Prefer using the in-tree version of libunwind, either shared or static. If
   # none are found fall back to using -lunwind.
   # FIXME: Is it correct to prefer the static version of libunwind?
-  if (NOT LIBCXXABI_ENABLE_STATIC_UNWINDER AND (TARGET unwind_shared OR HAVE_LIBUNWIND))
-    list(APPEND LIBCXXABI_LIBRARIES unwind_shared)
-  elseif (LIBCXXABI_ENABLE_STATIC_UNWINDER AND (TARGET unwind_static OR HAVE_LIBUNWIND))
-    list(APPEND LIBCXXABI_LIBRARIES unwind_static)
+  if (NOT LIBCXXABI_STATICALLY_LINK_UNWINDER_IN_SHARED_LIBRARY AND (TARGET unwind_shared OR HAVE_LIBUNWIND))
+    list(APPEND LIBCXXABI_SHARED_LIBRARIES unwind_shared)
+  elseif (LIBCXXABI_STATICALLY_LINK_UNWINDER_IN_SHARED_LIBRARY AND (TARGET unwind_static OR HAVE_LIBUNWIND))
+    list(APPEND LIBCXXABI_SHARED_LIBRARIES unwind_static)
   else()
-    list(APPEND LIBCXXABI_LIBRARIES unwind)
+    list(APPEND LIBCXXABI_SHARED_LIBRARIES unwind)
+  endif()
+  if (NOT LIBCXXABI_STATICALLY_LINK_UNWINDER_IN_STATIC_LIBRARY AND (TARGET unwind_shared OR HAVE_LIBUNWIND))
+    list(APPEND LIBCXXABI_STATIC_LIBRARIES unwind_shared)
+  elseif (LIBCXXABI_STATICALLY_LINK_UNWINDER_IN_STATIC_LIBRARY AND (TARGET unwind_static OR HAVE_LIBUNWIND))
+      # We handle this by directly merging libunwind objects into libc++abi.
+  else()
+    list(APPEND LIBCXXABI_STATIC_LIBRARIES unwind)
   endif()
 else()
   add_library_flags_if(LIBCXXABI_HAS_GCC_S_LIB gcc_s)
 endif()
 if (MINGW)
   # MINGW_LIBRARIES is defined in config-ix.cmake
-  list(APPEND LIBCXXABI_LIBRARIES ${MINGW_LIBRARIES})
+  list(APPEND LIBCXXABI_SHARED_LIBRARIES ${MINGW_LIBRARIES})
+  list(APPEND LIBCXXABI_STATIC_LIBRARIES ${MINGW_LIBRARIES})
 endif()
 
 # Setup flags.
 add_link_flags_if_supported(-nodefaultlibs)
 
 set(LIBCXXABI_SHARED_LINK_FLAGS)
 
 if ( APPLE )

 set(LIBCXXABI_TARGETS)
 
 # Build the shared library.
 if (LIBCXXABI_ENABLE_SHARED)
   add_library(cxxabi_shared SHARED $<TARGET_OBJECTS:cxxabi_objects>)
   if(COMMAND llvm_setup_rpath)
     llvm_setup_rpath(cxxabi_shared)
   endif()
-  target_link_libraries(cxxabi_shared ${LIBCXXABI_LIBRARIES})
+  target_link_libraries(cxxabi_shared ${LIBCXXABI_SHARED_LIBRARIES})
   set_target_properties(cxxabi_shared
                         PROPERTIES
                           CXX_EXTENSIONS
                             OFF
                           CXX_STANDARD
                             11
                           CXX_STANDARD_REQUIRED
                             ON
                           LINK_FLAGS
                             "${LIBCXXABI_LINK_FLAGS} ${LIBCXXABI_SHARED_LINK_FLAGS}"
                           OUTPUT_NAME
                             "c++abi"
                           POSITION_INDEPENDENT_CODE
                             ON
                           SOVERSION
                             "1"
                           VERSION
                             "1.0")
   list(APPEND LIBCXXABI_TARGETS "cxxabi_shared")
 endif()
 
 # Build the static library.
 if (LIBCXXABI_ENABLE_STATIC)
   set(cxxabi_static_sources $<TARGET_OBJECTS:cxxabi_objects>)
-  if (LIBCXXABI_USE_LLVM_UNWINDER AND LIBCXXABI_ENABLE_STATIC_UNWINDER)
+  if (LIBCXXABI_USE_LLVM_UNWINDER AND LIBCXXABI_STATICALLY_LINK_UNWINDER_IN_STATIC_LIBRARY)
     if (TARGET unwind_static OR HAVE_LIBUNWIND)
       list(APPEND cxxabi_static_sources $<TARGET_OBJECTS:unwind_objects>)
     endif()
   endif()
   add_library(cxxabi_static STATIC ${cxxabi_static_sources})
-  target_link_libraries(cxxabi_static ${LIBCXXABI_LIBRARIES})
+  target_link_libraries(cxxabi_static ${LIBCXXABI_STATIC_LIBRARIES})
   set_target_properties(cxxabi_static
                         PROPERTIES
                           CXX_EXTENSIONS
                             OFF
                           CXX_STANDARD
                             11
                           CXX_STANDARD_REQUIRED
                             ON