[libunwind][libcxxabi] Use object libraries in the build

[phosek]

Summary

This simplifies merging of libunwind and libcxxabi into libcxx since
we don't need to extract and merge archives and can simply use CMake
depednencies. That's also a prerequisite for using OSX_ARCHITECTURES
in CMake to build libcxx as universal library

[compnerd]

Using the TARGET_OBJECTS: generator seems better. However, I also have concerns over using the shared library objects. At least for Windows, reuse of the objects meant for a shared object is not really correct. This is non-portable at best, and incorrect at worse. I would rather that we just introduce a proper target that we use can for embedding into another library (which may or may not expose its interfaces from the library that integrates it).

libcxx/src/CMakeLists.txt

230

Why not use TARGET_OBJECTS:unwind> instead?

[smeenai]

The build used to be set up with object libraries, and then @ldionne explicitly changed it to not do so, so that e.g. the shared library is built as PIC by default and the static library isn't. This change would regress that.

[ldionne]

That's also a prerequisite for using OSX_ARCHITECTURES in CMake to build libcxx as universal library

I'm especially curious about this -- why does that require using object libraries?

[phosek]

In D116689#3223513, @smeenai wrote:

The build used to be set up with object libraries, and then @ldionne explicitly changed it to not do so, so that e.g. the shared library is built as PIC by default and the static library isn't. This change would regress that.

To clarify, I'm not trying to reuse object library between static and shared library as was the case in the past, that's undesirable for the reason you mentioned. I'm just adding an intermediate step: before we would build static library directly, now we build object library first and then archive it into static library. The reason for doing that is now we can depend on the object library from other targets (for example, libc++ can directly link libc++abi object library).

In D116689#3306237, @ldionne wrote:

That's also a prerequisite for using OSX_ARCHITECTURES in CMake to build libcxx as universal library

I'm especially curious about this -- why does that require using object libraries?

https://github.com/llvm/llvm-project/blob/bbddd19ec723a15ea1558cce5e47cb2460fa8e24/libcxx/utils/merge_archives.py script we use for merging archives (this is used when combining libc++abi.a into libc++.a) uses ar to extract archives into a temporary directory and then repackage them into a new combined archive. That doesn't work for universal static libraries since those aren't traditional UNIX archives (at least I haven't found a way to do that with existing tooling).

This change skips the extraction and repackaging step altogether and instead packages all objects that should go into the final library directly (through CMake dependencies). I think that approach is also more efficient (no extraction and repackaging) and explicit (CMake and Ninja know exactly which files form the final archive) at slight increase in CMake code complexity which IMO is a good tradeoff.

[phosek]

In D116689#3306286, @phosek wrote:

This change skips the extraction and repackaging step altogether and instead packages all objects that should go into the final library directly (through CMake dependencies). I think that approach is also more efficient (no extraction and repackaging) and explicit (CMake and Ninja know exactly which files form the final archive) at slight increase in CMake code complexity which IMO is a good tradeoff.

I also want to point out that I tried to minimize the number of changes in this patch, but I plan to do additional cleanup as a follow up which should simplify the build.

[smeenai]

In D116689#3306286, @phosek wrote:

In D116689#3223513, @smeenai wrote:

The build used to be set up with object libraries, and then @ldionne explicitly changed it to not do so, so that e.g. the shared library is built as PIC by default and the static library isn't. This change would regress that.

To clarify, I'm not trying to reuse object library between static and shared library as was the case in the past, that's undesirable for the reason you mentioned. I'm just adding an intermediate step: before we would build static library directly, now we build object library first and then archive it into static library. The reason for doing that is now we can depend on the object library from other targets (for example, libc++ can directly link libc++abi object library).

In D116689#3306237, @ldionne wrote:

That's also a prerequisite for using OSX_ARCHITECTURES in CMake to build libcxx as universal library

I'm especially curious about this -- why does that require using object libraries?

https://github.com/llvm/llvm-project/blob/bbddd19ec723a15ea1558cce5e47cb2460fa8e24/libcxx/utils/merge_archives.py script we use for merging archives (this is used when combining libc++abi.a into libc++.a) uses ar to extract archives into a temporary directory and then repackage them into a new combined archive. That doesn't work for universal static libraries since those aren't traditional UNIX archives (at least I haven't found a way to do that with existing tooling).

I agree with your reasoning and I'm not suggesting you go this route, but just as a generate note, libtool (and the LLVM version llvm-libtool-darwin) should be able to handle universal archives pretty transparently; in particular, you can tell libtool to construct a static library from multiple existing static libraries directly (and it'll handle universal archives as expected) instead of having to do a manual extraction and repackaging.

[phosek]

In D116689#3306294, @smeenai wrote:

In D116689#3306286, @phosek wrote:

In D116689#3223513, @smeenai wrote:

The build used to be set up with object libraries, and then @ldionne explicitly changed it to not do so, so that e.g. the shared library is built as PIC by default and the static library isn't. This change would regress that.

To clarify, I'm not trying to reuse object library between static and shared library as was the case in the past, that's undesirable for the reason you mentioned. I'm just adding an intermediate step: before we would build static library directly, now we build object library first and then archive it into static library. The reason for doing that is now we can depend on the object library from other targets (for example, libc++ can directly link libc++abi object library).

In D116689#3306237, @ldionne wrote:

That's also a prerequisite for using OSX_ARCHITECTURES in CMake to build libcxx as universal library

I'm especially curious about this -- why does that require using object libraries?

https://github.com/llvm/llvm-project/blob/bbddd19ec723a15ea1558cce5e47cb2460fa8e24/libcxx/utils/merge_archives.py script we use for merging archives (this is used when combining libc++abi.a into libc++.a) uses ar to extract archives into a temporary directory and then repackage them into a new combined archive. That doesn't work for universal static libraries since those aren't traditional UNIX archives (at least I haven't found a way to do that with existing tooling).

I agree with your reasoning and I'm not suggesting you go this route, but just as a generate note, libtool (and the LLVM version llvm-libtool-darwin) should be able to handle universal archives pretty transparently; in particular, you can tell libtool to construct a static library from multiple existing static libraries directly (and it'll handle universal archives as expected) instead of having to do a manual extraction and repackaging.

Good to know, thanks for pointing that out. I also found out that llvm-ar recently gained L option that allows appending to an archive without having to extract it.

The problem is that these are extensions only supported by LLVM tools, so if we started relying on those unconditionally, we would break compatibility with non-LLVM tools which may undesirable.

We could also have conditional logic: if you're using LLVM tools, use the LLVM-specific options, otherwise use a fallback, but that's going to result in even more complexity.

[ldionne]

In D116689#3306286, @phosek wrote:

In D116689#3223513, @smeenai wrote:

The build used to be set up with object libraries, and then @ldionne explicitly changed it to not do so, so that e.g. the shared library is built as PIC by default and the static library isn't. This change would regress that.

To clarify, I'm not trying to reuse object library between static and shared library as was the case in the past, that's undesirable for the reason you mentioned. I'm just adding an intermediate step: before we would build static library directly, now we build object library first and then archive it into static library. The reason for doing that is now we can depend on the object library from other targets (for example, libc++ can directly link libc++abi object library).

Ahh, looking at the patch with this in mind, I think I understand what you're doing now. This seems fine at a high level, but I have some questions.

Also, this is going to merge conflict downstream in crazy ways, but that's my problem :-(.

libcxx/src/CMakeLists.txt

230

I have the same question.

303

Do we really mean to use LIBCXXABI_foo variables here?

313

Why do we need this at all now? I must have misunderstood something, but I thought we were handling the merging of archives via those object libraries now.

[phosek]

libcxx/src/CMakeLists.txt

230

AFAIK I can only use TARGET_OBJECTS against object library so I need to do $<TARGET_OBJECTS:unwind_shared_objects> which works but doesn't simplify things much. Did you have something else in mind?

313

I left this for other C++ABI libraries such as libcxxrt where we cannot use archives directly as object libraries and have to fallback to archive merging. I'm not sure if that's a use case we want to support, but we do support it now.

[ldionne]

libcxx/src/CMakeLists.txt

230

I think this answers my question.

303

Ping on this question.

[mstorsjo]

libcxx/src/CMakeLists.txt

303

This naming is preexisting; the options for choosing how to link in the unwind library are sorted under libcxxabi (iirc there’s no corresponding option for libcxx), but in practice, the option is acted upon in both libcxxabi and libcxx, depending on what configuration is used for linking them together.

[mstorsjo]

Ping @phosek, do you have time to pick up this patch again? It seems to align very much with something I'd like to do, too.

[mstorsjo]

@phosek Do you have time to pick this up and complete it? It'd be essential for a build cleanup for Windows - but the patch itself is a bit too far outside of my cmake-fu.

For the mingw builds, the essential component is that cxx_shared uses cxxabi_objects_shared. However, the tricky thing is that cxxabi_shared isn't built (it's disabled, as it can't be linked as it has inverse dependencies on symbols provided by libcxx), but the cxxabi_objects_shared component still would need to be built).

[phosek]

In D116689#3497481, @mstorsjo wrote:

@phosek Do you have time to pick this up and complete it? It'd be essential for a build cleanup for Windows - but the patch itself is a bit too far outside of my cmake-fu.

I have uploaded an updated version which simplifies the implementation and seems to be working for me locally although I haven't done extensive testing yet.

For the mingw builds, the essential component is that cxx_shared uses cxxabi_objects_shared. However, the tricky thing is that cxxabi_shared isn't built (it's disabled, as it can't be linked as it has inverse dependencies on symbols provided by libcxx), but the cxxabi_objects_shared component still would need to be built).

Is the current implementation sufficient for your needs?

[mstorsjo]

In D116689#3498081, @phosek wrote:

In D116689#3497481, @mstorsjo wrote:

@phosek Do you have time to pick this up and complete it? It'd be essential for a build cleanup for Windows - but the patch itself is a bit too far outside of my cmake-fu.

I have uploaded an updated version which simplifies the implementation and seems to be working for me locally although I haven't done extensive testing yet.

This version breaks things for me; I'm building with LIBCXX_ENABLE_STATIC_ABI_LIBRARY and LIBCXXABI_USE_LLVM_UNWINDER but not LIBCXXABI_STATICALLY_LINK_UNWINDER_IN_SHARED_LIBRARY. In this case, there's no shared libcxxabi (I build with LIBCXXABI_ENABLE_SHARED=OFF), so libcxx would need to retain the code to link against the libunwind cmake target, it can't be carried transitively via libcxxabi (cxxabi_shared_objects). I.e. this case gets lost:

if(LIBCXXABI_USE_LLVM_UNWINDER AND NOT LIBCXXABI_STATICALLY_LINK_UNWINDER_IN_SHARED_LIBRARY)
   target_link_libraries(cxxabi_shared PUBLIC unwind_shared)
 endif()

For the mingw builds, the essential component is that cxx_shared uses cxxabi_objects_shared. However, the tricky thing is that cxxabi_shared isn't built (it's disabled, as it can't be linked as it has inverse dependencies on symbols provided by libcxx), but the cxxabi_objects_shared component still would need to be built).

Is the current implementation sufficient for your needs?

No - to make it work, I currently apply this diff:

diff --git a/libcxxabi/src/CMakeLists.txt b/libcxxabi/src/CMakeLists.txt
index 52d9c8046f9a..c2cce23c25b2 100644
--- a/libcxxabi/src/CMakeLists.txt
+++ b/libcxxabi/src/CMakeLists.txt
@@ -176,7 +176,7 @@ if (NOT TARGET pstl::ParallelSTL)
 endif()
 
 # Build the shared library.
-if (LIBCXXABI_ENABLE_SHARED)
+if (LIBCXXABI_ENABLE_SHARED OR ((LIBCXX_ENABLE_SHARED OR NOT DEFINED LIBCXX_ENABLE_SHARED) AND LIBCXX_ENABLE_STATIC_ABI_LIBRARY))
   add_library(cxxabi_shared_objects OBJECT ${LIBCXXABI_SOURCES} ${LIBCXXABI_HEADERS})
   target_link_libraries(cxxabi_shared_objects PRIVATE cxx-headers ${LIBCXXABI_SHARED_LIBRARIES} ${LIBCXXABI_LIBRARIES})
   target_link_libraries(cxxabi_shared_objects PUBLIC cxxabi-headers)
@@ -188,7 +188,9 @@ if (LIBCXXABI_ENABLE_SHARED)
       COMPILE_FLAGS "${LIBCXXABI_COMPILE_FLAGS}"
       DEFINE_SYMBOL ""
   )
+endif()
 
+if (LIBCXXABI_ENABLE_SHARED)
   add_library(cxxabi_shared SHARED $<TARGET_OBJECTS:cxxabi_shared_objects>)
   set_target_properties(cxxabi_shared 
     PROPERTIES

I.e. I need to build cxxabi_shared_objects (as those are needed to be merged into cxx_shared) but I can't build cxxabi_shared (because that's impossible to link when Windows shared libraries can't have undefined references).

[mstorsjo]

Or put differently; the thing that really would simplify the situation on Windows, would be to be able to just omit libcxxabi as its own entity altogether, and just optionally include the cxxabi source files as part of libcxx.

[phosek]

In D116689#3500263, @mstorsjo wrote:

This version breaks things for me; I'm building with LIBCXX_ENABLE_STATIC_ABI_LIBRARY and LIBCXXABI_USE_LLVM_UNWINDER but not LIBCXXABI_STATICALLY_LINK_UNWINDER_IN_SHARED_LIBRARY. In this case, there's no shared libcxxabi (I build with LIBCXXABI_ENABLE_SHARED=OFF), so libcxx would need to retain the code to link against the libunwind cmake target, it can't be carried transitively via libcxxabi (cxxabi_shared_objects). I.e. this case gets lost:

if(LIBCXXABI_USE_LLVM_UNWINDER AND NOT LIBCXXABI_STATICALLY_LINK_UNWINDER_IN_SHARED_LIBRARY)
   target_link_libraries(cxxabi_shared PUBLIC unwind_shared)
 endif()

The part I don't like is referring to LIBCXXABI_USE_LLVM_UNWINDER from within the libcxx build.

No - to make it work, I currently apply this diff:

diff --git a/libcxxabi/src/CMakeLists.txt b/libcxxabi/src/CMakeLists.txt
index 52d9c8046f9a..c2cce23c25b2 100644
--- a/libcxxabi/src/CMakeLists.txt
+++ b/libcxxabi/src/CMakeLists.txt
@@ -176,7 +176,7 @@ if (NOT TARGET pstl::ParallelSTL)
 endif()
 
 # Build the shared library.
-if (LIBCXXABI_ENABLE_SHARED)
+if (LIBCXXABI_ENABLE_SHARED OR ((LIBCXX_ENABLE_SHARED OR NOT DEFINED LIBCXX_ENABLE_SHARED) AND LIBCXX_ENABLE_STATIC_ABI_LIBRARY))
   add_library(cxxabi_shared_objects OBJECT ${LIBCXXABI_SOURCES} ${LIBCXXABI_HEADERS})
   target_link_libraries(cxxabi_shared_objects PRIVATE cxx-headers ${LIBCXXABI_SHARED_LIBRARIES} ${LIBCXXABI_LIBRARIES})
   target_link_libraries(cxxabi_shared_objects PUBLIC cxxabi-headers)
@@ -188,7 +188,9 @@ if (LIBCXXABI_ENABLE_SHARED)
       COMPILE_FLAGS "${LIBCXXABI_COMPILE_FLAGS}"
       DEFINE_SYMBOL ""
   )
+endif()
 
+if (LIBCXXABI_ENABLE_SHARED)
   add_library(cxxabi_shared SHARED $<TARGET_OBJECTS:cxxabi_shared_objects>)
   set_target_properties(cxxabi_shared 
     PROPERTIES

I.e. I need to build cxxabi_shared_objects (as those are needed to be merged into cxx_shared) but I can't build cxxabi_shared (because that's impossible to link when Windows shared libraries can't have undefined references).

I wonder if we could simplify things by always building cxxabi_static_objects and cxxabi_shared_objects but marking them as EXCLUDE_FROM_ALL?

[mstorsjo]

In D116689#3502026, @phosek wrote:

In D116689#3500263, @mstorsjo wrote:

This version breaks things for me; I'm building with LIBCXX_ENABLE_STATIC_ABI_LIBRARY and LIBCXXABI_USE_LLVM_UNWINDER but not LIBCXXABI_STATICALLY_LINK_UNWINDER_IN_SHARED_LIBRARY. In this case, there's no shared libcxxabi (I build with LIBCXXABI_ENABLE_SHARED=OFF), so libcxx would need to retain the code to link against the libunwind cmake target, it can't be carried transitively via libcxxabi (cxxabi_shared_objects). I.e. this case gets lost:

if(LIBCXXABI_USE_LLVM_UNWINDER AND NOT LIBCXXABI_STATICALLY_LINK_UNWINDER_IN_SHARED_LIBRARY)
   target_link_libraries(cxxabi_shared PUBLIC unwind_shared)
 endif()

The part I don't like is referring to LIBCXXABI_USE_LLVM_UNWINDER from within the libcxx build.

Yep. But apparently it does work to pass such dependencies along for an object library, within cmake, like this:

if(LIBCXXABI_USE_LLVM_UNWINDER AND NOT LIBCXXABI_STATICALLY_LINK_UNWINDER_IN_SHARED_LIBRARY)
  target_link_libraries(cxxabi_shared_objects PUBLIC unwind_shared)
endif()

I.e. I need to build cxxabi_shared_objects (as those are needed to be merged into cxx_shared) but I can't build cxxabi_shared (because that's impossible to link when Windows shared libraries can't have undefined references).

I wonder if we could simplify things by always building cxxabi_static_objects and cxxabi_shared_objects but marking them as EXCLUDE_FROM_ALL?

That's probably the best solution for that - thanks!

[phosek]

In D116689#3502709, @mstorsjo wrote:

In D116689#3502026, @phosek wrote:

I wonder if we could simplify things by always building cxxabi_static_objects and cxxabi_shared_objects but marking them as EXCLUDE_FROM_ALL?

That's probably the best solution for that - thanks!

I've realized that this also going to simplify our build so I like that direction. It's not entirely straightforward though because there are currently various parts of the build that assume that either static or shared libcxxabi is being built which need to be reworked.

[ldionne]

Since this conflicts heavily with D120727, I proposed a way forward that implements this patch on top of D120727. See D125393

[phosek]

In D116689#3504337, @phosek wrote:

In D116689#3502709, @mstorsjo wrote:

In D116689#3502026, @phosek wrote:

I wonder if we could simplify things by always building cxxabi_static_objects and cxxabi_shared_objects but marking them as EXCLUDE_FROM_ALL?

That's probably the best solution for that - thanks!

I've realized that this also going to simplify our build so I like that direction. It's not entirely straightforward though because there are currently various parts of the build that assume that either static or shared libcxxabi is being built which need to be reworked.

I got everything to build, but there are some open questions. For example, if we only build libcxxabi objects and neither of the libraries, should we skip libcxxabi tests, or shall we run them but use libcxx (if libcxxabi objects are being linked into libcxx)?

In D116689#3506393, @ldionne wrote:

Since this conflicts heavily with D120727, I proposed a way forward that implements this patch on top of D120727. See D125393

I'm fine going with your change if we can land it shortly after D120727 since there's other follow up work I'd like to do that I mentioned above.

[phosek]

Superseded by D125393.

libcxx/cmake/Modules/HandleLibCXXABI.cmake

elseif ("${LIBCXX_CXX_ABI_LIBNAME}" STREQUAL "libcxxabi")
   if(NOT LIBCXX_CXX_ABI_INCLUDE_PATHS)
     set(LIBCXX_CXX_ABI_INCLUDE_PATHS "${LIBCXX_SOURCE_DIR}/../libcxxabi/include")
   endif()
 
   if(LIBCXX_STANDALONE_BUILD AND NOT (LIBCXX_CXX_ABI_INTREE OR HAVE_LIBCXXABI))
     set(shared c++abi)
     set(static c++abi)
   else()
+    if (LIBCXX_STATICALLY_LINK_ABI_IN_SHARED_LIBRARY)
+      set(shared cxxabi_shared_objects)
+    else()
       set(shared cxxabi_shared)
+    endif()
+    if (LIBCXX_STATICALLY_LINK_ABI_IN_STATIC_LIBRARY)
+      set(static cxxabi_static_objects)
+    else()
       set(static cxxabi_static)
     endif()
+  endif()
 
   setup_abi_lib(
     "-DLIBCXX_BUILDING_LIBCXXABI"
     "${shared}" "${static}" "cxxabi.h;__cxxabi_config.h" "")
 elseif ("${LIBCXX_CXX_ABI_LIBNAME}" STREQUAL "system-libcxxabi")
   setup_abi_lib(
     "-DLIBCXX_BUILDING_LIBCXXABI"
     "c++abi" "c++abi" "cxxabi.h;__cxxabi_config.h" "")

libcxx/src/CMakeLists.txt

PROPERTIES
       OUTPUT_NAME   "c++"
       VERSION       "${LIBCXX_ABI_VERSION}.0"
       SOVERSION     "${LIBCXX_ABI_VERSION}"
       DEFINE_SYMBOL ""
   )
   cxx_add_common_build_flags(cxx_shared)
   cxx_set_common_defines(cxx_shared)
 
-  # Link against LLVM libunwind
-  if (LIBCXXABI_USE_LLVM_UNWINDER)
-    if (NOT LIBCXXABI_STATICALLY_LINK_UNWINDER_IN_SHARED_LIBRARY AND (TARGET unwind_shared OR HAVE_LIBUNWIND))
-      target_link_libraries(cxx_shared PUBLIC unwind_shared)
-    elseif (LIBCXXABI_STATICALLY_LINK_UNWINDER_IN_SHARED_LIBRARY AND (TARGET unwind_static OR HAVE_LIBUNWIND))
-      # libunwind is already included in libc++abi
-    else()
-      target_link_libraries(cxx_shared PUBLIC unwind)
-    endif()
-  endif()
-
   # Link against libc++abi
   if (LIBCXX_STATICALLY_LINK_ABI_IN_SHARED_LIBRARY)
-    if (APPLE)
-      target_link_libraries(cxx_shared PRIVATE "-Wl,-force_load" "${LIBCXX_CXX_STATIC_ABI_LIBRARY}")
-    else()
-      target_link_libraries(cxx_shared PRIVATE "-Wl,--whole-archive,-Bstatic" "${LIBCXX_CXX_STATIC_ABI_LIBRARY}" "-Wl,-Bdynamic,--no-whole-archive")
-    endif()
+    target_link_libraries(cxx_shared PRIVATE "${LIBCXX_CXX_SHARED_ABI_LIBRARY}")
   else()
     target_link_libraries(cxx_shared PUBLIC "${LIBCXX_CXX_SHARED_ABI_LIBRARY}")
   endif()
 
   # Maybe re-export symbols from libc++abi
   # In particular, we don't re-export the symbols if libc++abi is merged statically
   # into libc++ because in that case there's no dylib to re-export from.
   if (APPLE AND (LIBCXX_CXX_ABI_LIBNAME STREQUAL "libcxxabi" OR
set_target_properties(cxx_static
     PROPERTIES
       COMPILE_FLAGS "${LIBCXX_COMPILE_FLAGS}"
       LINK_FLAGS    "${LIBCXX_LINK_FLAGS}"
       OUTPUT_NAME   "c++"
   )
   cxx_add_common_build_flags(cxx_static)
   cxx_set_common_defines(cxx_static)
 
-  if (LIBCXXABI_USE_LLVM_UNWINDER)
-    # If we intend to use the just-built unwinder, add a dependency so that it
-    # gets built, even if we technically aren't going to link it in at this
-    # stage.
-    add_dependencies(cxx_static unwind)
-  endif()
-
   if (LIBCXX_HERMETIC_STATIC_LIBRARY)
     # If the hermetic library doesn't define the operator new/delete functions
     # then its code shouldn't declare them with hidden visibility.  They might
     # actually be provided by a shared library at link time.
     if (LIBCXX_ENABLE_NEW_DELETE_DEFINITIONS)
       append_flags_if_supported(CXX_STATIC_LIBRARY_FLAGS -fvisibility-global-new-delete-hidden)
     endif()
     target_compile_options(cxx_static PRIVATE ${CXX_STATIC_LIBRARY_FLAGS})
     target_compile_definitions(cxx_static PRIVATE _LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS)
   endif()
 
   list(APPEND LIBCXX_BUILD_TARGETS "cxx_static")
   # Attempt to merge the libc++.a archive and the ABI library archive into one.
   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_STATIC_ABI_LIBRARY}" OR HAVE_LIBCXXABI)
-      set(MERGE_ARCHIVES_ABI_TARGET "$<TARGET_LINKER_FILE:${LIBCXX_CXX_STATIC_ABI_LIBRARY}>")
+      target_link_libraries(cxx_static PRIVATE "${LIBCXX_CXX_STATIC_ABI_LIBRARY}")
     else()
       set(MERGE_ARCHIVES_ABI_TARGET
         "${CMAKE_STATIC_LIBRARY_PREFIX}${LIBCXX_CXX_STATIC_ABI_LIBRARY}${CMAKE_STATIC_LIBRARY_SUFFIX}")
       if (LIBCXX_CXX_ABI_LIBRARY_PATH)
         set(MERGE_ARCHIVES_ABI_TARGET "${LIBCXX_CXX_ABI_LIBRARY_PATH}/${MERGE_ARCHIVES_ABI_TARGET}")
       endif ()
+
+      set(MERGE_ARCHIVES_SEARCH_PATHS "")
+      if (LIBCXX_CXX_ABI_LIBRARY_PATH)
+        set(MERGE_ARCHIVES_SEARCH_PATHS "-L${LIBCXX_CXX_ABI_LIBRARY_PATH}")
       endif()
+
       if (APPLE)
         set(MERGE_ARCHIVES_LIBTOOL "--use-libtool" "--libtool" "${CMAKE_LIBTOOL}")
       endif()
       add_custom_command(TARGET cxx_static POST_BUILD
       COMMAND
         ${Python3_EXECUTABLE} ${LIBCXX_SOURCE_DIR}/utils/merge_archives.py
       ARGS
         -o $<TARGET_LINKER_FILE:cxx_static>
         --ar "${CMAKE_AR}"
         ${MERGE_ARCHIVES_LIBTOOL}
         "$<TARGET_LINKER_FILE:cxx_static>"
         "${MERGE_ARCHIVES_ABI_TARGET}"
         "${MERGE_ARCHIVES_SEARCH_PATHS}"
       WORKING_DIRECTORY ${LIBCXX_BUILD_DIR}
       DEPENDS ${MERGE_ARCHIVES_ABI_TARGET}
       )
     endif()
   endif()
+endif()
 
 # Add a meta-target for both libraries.
 add_custom_target(cxx DEPENDS ${LIBCXX_BUILD_TARGETS})
 
 if (LIBCXX_ENABLE_EXPERIMENTAL_LIBRARY)
   set(LIBCXX_EXPERIMENTAL_SOURCES
     experimental/memory_resource.cpp
     )

libcxxabi/src/CMakeLists.txt

 else()
   if (LIBCXXABI_ENABLE_THREADS)
     add_library_flags_if(LIBCXXABI_HAS_PTHREAD_LIB pthread)
   endif()
 
   add_library_flags_if(LIBCXXABI_HAS_C_LIB c)
 endif()
 
-if (LIBCXXABI_USE_COMPILER_RT)
-  find_compiler_rt_library(builtins LIBCXXABI_BUILTINS_LIBRARY)
-  list(APPEND LIBCXXABI_SHARED_LIBRARIES "${LIBCXXABI_BUILTINS_LIBRARY}")
-endif ()
-
-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_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_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()
+if (NOT LIBCXXABI_USE_COMPILER_RT)
+  add_library_flags_if(LIBCXXABI_HAS_GCC_LIB gcc)
+if (NOT LIBCXXABI_USE_LLVM_UNWINDER)
   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})
 endif()
 if (ANDROID AND ANDROID_PLATFORM_LEVEL LESS 21)
   list(APPEND LIBCXXABI_LIBRARIES android_support)
 endif()
 
-if (NOT LIBCXXABI_USE_COMPILER_RT)
-  add_library_flags_if(LIBCXXABI_HAS_GCC_LIB gcc)
-endif ()
-
 # Setup flags.
 if (CXX_SUPPORTS_NOSTDLIBXX_FLAG)
   add_link_flags_if_supported(-nostdlib++)
 else()
   add_link_flags_if_supported(-nodefaultlibs)
 endif()
 
 if ( APPLE )

 endif()
 
 if (NOT TARGET pstl::ParallelSTL)
   message(STATUS "Could not find ParallelSTL, libc++abi will not attempt to use it but the build may fail if the libc++ in use needs it to be available.")
 endif()
 
 # Build the shared library.
 if (LIBCXXABI_ENABLE_SHARED)
-  add_library(cxxabi_shared SHARED ${LIBCXXABI_SOURCES} ${LIBCXXABI_HEADERS})
-  target_link_libraries(cxxabi_shared PRIVATE cxx-headers ${LIBCXXABI_SHARED_LIBRARIES} ${LIBCXXABI_LIBRARIES})
-  target_link_libraries(cxxabi_shared PUBLIC cxxabi-headers)
-  if (TARGET pstl::ParallelSTL)
-    target_link_libraries(cxxabi_shared PUBLIC pstl::ParallelSTL)
-  endif()
-  set_target_properties(cxxabi_shared
+  add_library(cxxabi_shared_objects OBJECT ${LIBCXXABI_SOURCES} ${LIBCXXABI_HEADERS})
+  if (LIBCXXABI_USE_LLVM_UNWINDER AND LIBCXXABI_STATICALLY_LINK_UNWINDER_IN_SHARED_LIBRARY)
+    target_sources(cxxabi_shared_objects PUBLIC $<TARGET_OBJECTS:unwind_shared_objects>)
+  endif()
+  target_link_libraries(cxxabi_shared_objects PRIVATE cxx-headers ${LIBCXXABI_BUILTINS_LIBRARY} ${LIBCXXABI_SHARED_LIBRARIES} ${LIBCXXABI_LIBRARIES})
+  target_link_libraries(cxxabi_shared_objects PUBLIC cxxabi-headers)
+  set_target_properties(cxxabi_shared_objects
     PROPERTIES
       CXX_EXTENSIONS OFF
       CXX_STANDARD 20
       CXX_STANDARD_REQUIRED OFF
       COMPILE_FLAGS "${LIBCXXABI_COMPILE_FLAGS}"
+      DEFINE_SYMBOL ""
+  )
+
+  add_library(cxxabi_shared SHARED $<TARGET_OBJECTS:cxxabi_shared_objects>)
+  if(LIBCXXABI_USE_LLVM_UNWINDER AND NOT LIBCXXABI_STATICALLY_LINK_UNWINDER_IN_SHARED_LIBRARY)
+    target_link_libraries(cxxabi_shared PUBLIC unwind_shared)
+  endif()
+  set_target_properties(cxxabi_shared
+    PROPERTIES
       LINK_FLAGS "${LIBCXXABI_LINK_FLAGS}"
       OUTPUT_NAME "c++abi"
       SOVERSION "1"
       VERSION "${LIBCXXABI_LIBRARY_VERSION}"
-      DEFINE_SYMBOL ""
   )
+  target_link_libraries(cxxabi_shared PRIVATE ${LIBCXXABI_SHARED_LIBRARIES} ${LIBCXXABI_LIBRARIES})
+  if (TARGET pstl::ParallelSTL)
+    target_link_libraries(cxxabi_shared PUBLIC pstl::ParallelSTL)
+  endif()
 
   list(APPEND LIBCXXABI_BUILD_TARGETS "cxxabi_shared")
   if (LIBCXXABI_INSTALL_SHARED_LIBRARY)
     list(APPEND LIBCXXABI_INSTALL_TARGETS "cxxabi_shared")
   endif()
 
   add_library(cxxabi-reexports INTERFACE)
 
if (LIBCXXABI_ENABLE_EXCEPTIONS)
         reexport_symbols("${CMAKE_CURRENT_SOURCE_DIR}/../lib/personality-v0.exp")
       endif()
     endif()
   endif()
 endif()
 
 # Build the static library.
 if (LIBCXXABI_ENABLE_STATIC)
-  add_library(cxxabi_static STATIC ${LIBCXXABI_SOURCES} ${LIBCXXABI_HEADERS})
-  target_link_libraries(cxxabi_static PRIVATE cxx-headers ${LIBCXXABI_STATIC_LIBRARIES} ${LIBCXXABI_LIBRARIES})
-  target_link_libraries(cxxabi_static PUBLIC cxxabi-headers)
-  if (TARGET pstl::ParallelSTL)
-    target_link_libraries(cxxabi_static PUBLIC pstl::ParallelSTL)
+  add_library(cxxabi_static_objects OBJECT ${LIBCXXABI_SOURCES} ${LIBCXXABI_HEADERS})
+  if (LIBCXXABI_USE_LLVM_UNWINDER AND LIBCXXABI_STATICALLY_LINK_UNWINDER_IN_STATIC_LIBRARY)
+    target_sources(cxxabi_static_objects PUBLIC $<TARGET_OBJECTS:unwind_static_objects>)
   endif()
-  set_target_properties(cxxabi_static
+  target_link_libraries(cxxabi_static_objects PRIVATE cxx-headers ${LIBCXXABI_STATIC_LIBRARIES} ${LIBCXXABI_LIBRARIES})
+  target_link_libraries(cxxabi_static_objects PUBLIC cxxabi-headers)
+  set_target_properties(cxxabi_static_objects
     PROPERTIES
       CXX_EXTENSIONS OFF
       CXX_STANDARD 20
       CXX_STANDARD_REQUIRED OFF
       COMPILE_FLAGS "${LIBCXXABI_COMPILE_FLAGS}"
-      LINK_FLAGS "${LIBCXXABI_LINK_FLAGS}"
-      OUTPUT_NAME "c++abi"
     )
 
   if(LIBCXXABI_HERMETIC_STATIC_LIBRARY)
     append_flags_if_supported(CXXABI_STATIC_LIBRARY_FLAGS -fvisibility=hidden)
     # If the hermetic library doesn't define the operator new/delete functions
     # then its code shouldn't declare them with hidden visibility.  They might
     # actually be provided by a shared library at link time.
     if (LIBCXXABI_ENABLE_NEW_DELETE_DEFINITIONS)
       append_flags_if_supported(CXXABI_STATIC_LIBRARY_FLAGS -fvisibility-global-new-delete-hidden)
     endif()
-    target_compile_options(cxxabi_static PRIVATE ${CXXABI_STATIC_LIBRARY_FLAGS})
-    target_compile_definitions(cxxabi_static
+    target_compile_options(cxxabi_static_objects PRIVATE ${CXXABI_STATIC_LIBRARY_FLAGS})
+    target_compile_definitions(cxxabi_static_objects
       PRIVATE
         _LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS
         _LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS)
   endif()
 
-  list(APPEND LIBCXXABI_BUILD_TARGETS "cxxabi_static")
-  if (LIBCXXABI_INSTALL_STATIC_LIBRARY)
-    list(APPEND LIBCXXABI_INSTALL_TARGETS "cxxabi_static")
+  add_library(cxxabi_static STATIC $<TARGET_OBJECTS:cxxabi_static_objects>)
+  if (LIBCXXABI_USE_LLVM_UNWINDER AND NOT LIBCXXABI_STATICALLY_LINK_UNWINDER_IN_STATIC_LIBRARY)
+    target_link_libraries(cxxabi_static PUBLIC unwind_static)
   endif()
-
-  if (APPLE)
-    set(MERGE_ARCHIVES_LIBTOOL "--use-libtool" "--libtool" "${CMAKE_LIBTOOL}")
+  set_target_properties(cxxabi_static
+    PROPERTIES
+      LINK_FLAGS "${LIBCXXABI_LINK_FLAGS}"
+      OUTPUT_NAME "c++abi"
+    )
+  target_link_libraries(cxxabi_static PRIVATE ${LIBCXXABI_STATIC_LIBRARIES} ${LIBCXXABI_LIBRARIES})
+  if (TARGET pstl::ParallelSTL)
+    target_link_libraries(cxxabi_static PUBLIC pstl::ParallelSTL)
   endif()
 
-  # Merge the libc++abi.a and libunwind.a into one.
-  if(LIBCXXABI_USE_LLVM_UNWINDER AND LIBCXXABI_STATICALLY_LINK_UNWINDER_IN_STATIC_LIBRARY)
-    add_custom_command(TARGET cxxabi_static POST_BUILD
-      COMMAND ${Python3_EXECUTABLE} ${LIBCXXABI_LIBCXX_PATH}/utils/merge_archives.py
-      ARGS
-        -o "$<TARGET_LINKER_FILE:cxxabi_static>"
-        --ar "${CMAKE_AR}"
-        ${MERGE_ARCHIVES_LIBTOOL}
-        "$<TARGET_LINKER_FILE:cxxabi_static>"
-        "$<TARGET_LINKER_FILE:unwind_static>"
-      WORKING_DIRECTORY ${LIBCXXABI_BUILD_DIR}
-      DEPENDS unwind_static
-    )
+  list(APPEND LIBCXXABI_BUILD_TARGETS "cxxabi_static")
+  if (LIBCXXABI_INSTALL_STATIC_LIBRARY)
+    list(APPEND LIBCXXABI_INSTALL_TARGETS "cxxabi_static")
   endif()
 endif()
 
 # Add a meta-target for both libraries.
 add_custom_target(cxxabi DEPENDS ${LIBCXXABI_BUILD_TARGETS})
 
 if (LIBCXXABI_INSTALL_LIBRARY)
   install(TARGETS ${LIBCXXABI_INSTALL_TARGETS}

libunwind/src/CMakeLists.txt

set_property(SOURCE ${LIBUNWIND_C_SOURCES}
              APPEND_STRING PROPERTY COMPILE_FLAGS " ${LIBUNWIND_C_FLAGS}")
 
 # NOTE: avoid implicit dependencies on C++ runtimes.  libunwind uses C++ for
 # ease, but does not rely on C++ at runtime.
 set(CMAKE_CXX_IMPLICIT_LINK_LIBRARIES "")
 
 # Build the shared library.
 if (LIBUNWIND_ENABLE_SHARED)
-  add_library(unwind_shared SHARED ${LIBUNWIND_SOURCES} ${LIBUNWIND_HEADERS})
+  add_library(unwind_shared_objects OBJECT ${LIBUNWIND_SOURCES} ${LIBUNWIND_HEADERS})
   if(CMAKE_C_COMPILER_ID STREQUAL MSVC)
-    target_compile_options(unwind_shared PRIVATE /GR-)
+    target_compile_options(unwind_shared_objects PRIVATE /GR-)
   else()
-    target_compile_options(unwind_shared PRIVATE -fno-rtti)
+    target_compile_options(unwind_shared_objects PRIVATE -fno-rtti)
   endif()
-  target_link_libraries(unwind_shared PRIVATE ${LIBUNWIND_LIBRARIES}
-                                      PRIVATE unwind-headers)
-  set_target_properties(unwind_shared
+  target_link_libraries(unwind_shared_objects PRIVATE unwind-headers ${LIBUNWIND_LIBRARIES})
+  set_target_properties(unwind_shared_objects
     PROPERTIES
       CXX_EXTENSIONS OFF
       CXX_STANDARD 11
       CXX_STANDARD_REQUIRED ON
       COMPILE_FLAGS "${LIBUNWIND_COMPILE_FLAGS}"
-      LINK_FLAGS "${LIBUNWIND_LINK_FLAGS}"
       LINKER_LANGUAGE C
+  )
+
+  add_library(unwind_shared SHARED $<TARGET_OBJECTS:unwind_shared_objects>)
+  set_target_properties(unwind_shared
+    PROPERTIES
+      LINK_FLAGS "${LIBUNWIND_LINK_FLAGS}"
       OUTPUT_NAME "unwind"
       VERSION "1.0"
       SOVERSION "1"
   )
+
   list(APPEND LIBUNWIND_BUILD_TARGETS "unwind_shared")
   if (LIBUNWIND_INSTALL_SHARED_LIBRARY)
     list(APPEND LIBUNWIND_INSTALL_TARGETS "unwind_shared")
   endif()
 endif()
 
 # Build the static library.
 if (LIBUNWIND_ENABLE_STATIC)
-  add_library(unwind_static STATIC ${LIBUNWIND_SOURCES} ${LIBUNWIND_HEADERS})
+  add_library(unwind_static_objects OBJECT ${LIBUNWIND_SOURCES} ${LIBUNWIND_HEADERS})
   if(CMAKE_C_COMPILER_ID STREQUAL MSVC)
-    target_compile_options(unwind_static PRIVATE /GR-)
+    target_compile_options(unwind_static_objects PRIVATE /GR-)
   else()
-    target_compile_options(unwind_static PRIVATE -fno-rtti)
+    target_compile_options(unwind_static_objects PRIVATE -fno-rtti)
   endif()
-  target_link_libraries(unwind_static PRIVATE ${LIBUNWIND_LIBRARIES}
-                                      PRIVATE unwind-headers)
-  set_target_properties(unwind_static
+  target_link_libraries(unwind_static_objects PRIVATE unwind-headers ${LIBUNWIND_LIBRARIES})
+  set_target_properties(unwind_static_objects
     PROPERTIES
       CXX_EXTENSIONS OFF
       CXX_STANDARD 11
       CXX_STANDARD_REQUIRED ON
       COMPILE_FLAGS "${LIBUNWIND_COMPILE_FLAGS}"
-      LINK_FLAGS "${LIBUNWIND_LINK_FLAGS}"
       LINKER_LANGUAGE C
-      OUTPUT_NAME "unwind"
   )
 
   if(LIBUNWIND_HIDE_SYMBOLS)
     append_flags_if_supported(UNWIND_STATIC_LIBRARY_FLAGS -fvisibility=hidden)
     append_flags_if_supported(UNWIND_STATIC_LIBRARY_FLAGS -fvisibility-global-new-delete-hidden)
-    target_compile_options(unwind_static PRIVATE ${UNWIND_STATIC_LIBRARY_FLAGS})
-    target_compile_definitions(unwind_static PRIVATE _LIBUNWIND_HIDE_SYMBOLS)
+    target_compile_options(unwind_static_objects PRIVATE ${UNWIND_STATIC_LIBRARY_FLAGS})
+    target_compile_definitions(unwind_static_objects PRIVATE _LIBUNWIND_HIDE_SYMBOLS)
   endif()
 
+  add_library(unwind_static STATIC $<TARGET_OBJECTS:unwind_static_objects>)
+  set_target_properties(unwind_static
+    PROPERTIES
+      LINK_FLAGS "${LIBUNWIND_LINK_FLAGS}"
+      OUTPUT_NAME "unwind"
+  )
+
   list(APPEND LIBUNWIND_BUILD_TARGETS "unwind_static")
   if (LIBUNWIND_INSTALL_STATIC_LIBRARY)
     list(APPEND LIBUNWIND_INSTALL_TARGETS "unwind_static")
   endif()
 endif()
 
 # Add a meta-target for both libraries.
 add_custom_target(unwind DEPENDS ${LIBUNWIND_BUILD_TARGETS})