[runtimes] Introduce object libraries

[ldionne]

Summary

This is a variant of D116689 rebased on top of the new (proposed) ABI
refactoring in D120727. It should conserve the basic properties of the
original patch by @phosek, except it also allows cleaning up the merging
of libc++abi into libc++ from the libc++ side.

[mstorsjo]

Thanks! Overall, this looks like it can work for me. The same two issues as I still had with D116689 (as discussed with @phosek there) exists here too:

• For mingw, I can't build cxxabi_shared, but I do need cxxabi_shared_objects for cxx_shared. @phosek suggested fixing this by always creating the cxxabi_shared_objects target, but adding the EXCLUDE_FROM_ALL property on it.

• As the line target_link_libraries(cxx_shared PUBLIC unwind_shared) is removed from cxx, builds with LIBCXXABI_USE_LLVM_UNWINDER, without LIBCXXABI_STATICALLY_LINK_UNWINDER_IN_SHARED_LIBRARY fail. This can be fixed (at least for my case, didn't test other cases) by moving that dependency from cxxabi_shared to cxxabi_shared_objects - so that it propagates to either cxxabi_shared or cxx_shared later.

I.e., to make it work for me, I made this change on top of it:

diff --git a/libcxxabi/src/CMakeLists.txt b/libcxxabi/src/CMakeLists.txt
index 6e22432759e6..04bee47deee7 100644
--- a/libcxxabi/src/CMakeLists.txt
+++ b/libcxxabi/src/CMakeLists.txt
@@ -152,10 +152,13 @@ if (NOT TARGET pstl::ParallelSTL)
 endif()
 
 # Build the shared library.
-if (LIBCXXABI_ENABLE_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>)
+  if (LIBCXXABI_USE_LLVM_UNWINDER)
+    if (LIBCXXABI_STATICALLY_LINK_UNWINDER_IN_SHARED_LIBRARY)
+      target_sources(cxxabi_shared_objects PUBLIC $<TARGET_OBJECTS:unwind_shared_objects>)
+    else()
+      target_link_libraries(cxxabi_shared_objects PUBLIC unwind_shared)
+    endif()
   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)
@@ -166,12 +169,11 @@ if (LIBCXXABI_ENABLE_SHARED)
       CXX_STANDARD_REQUIRED OFF
       COMPILE_FLAGS "${LIBCXXABI_COMPILE_FLAGS}"
       DEFINE_SYMBOL ""
+      EXCLUDE_FROM_ALL ON
   )
 
+if (LIBCXXABI_ENABLE_SHARED)
   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}"

(I guess the same change for always creating the cxxabi_static_objects, but with EXCLUDE_FROM_ALL, should be made too, but I just tested with the bare minimums for making this work for me.)

[phosek]

In D125393#3507367, @mstorsjo wrote:

Thanks! Overall, this looks like it can work for me. The same two issues as I still had with D116689 (as discussed with @phosek there) exists here too:

• For mingw, I can't build cxxabi_shared, but I do need cxxabi_shared_objects for cxx_shared. @phosek suggested fixing this by always creating the cxxabi_shared_objects target, but adding the EXCLUDE_FROM_ALL property on it.

• As the line target_link_libraries(cxx_shared PUBLIC unwind_shared) is removed from cxx, builds with LIBCXXABI_USE_LLVM_UNWINDER, without LIBCXXABI_STATICALLY_LINK_UNWINDER_IN_SHARED_LIBRARY fail. This can be fixed (at least for my case, didn't test other cases) by moving that dependency from cxxabi_shared to cxxabi_shared_objects - so that it propagates to either cxxabi_shared or cxx_shared later.

I.e., to make it work for me, I made this change on top of it:

diff --git a/libcxxabi/src/CMakeLists.txt b/libcxxabi/src/CMakeLists.txt
index 6e22432759e6..04bee47deee7 100644
--- a/libcxxabi/src/CMakeLists.txt
+++ b/libcxxabi/src/CMakeLists.txt
@@ -152,10 +152,13 @@ if (NOT TARGET pstl::ParallelSTL)
 endif()
 
 # Build the shared library.
-if (LIBCXXABI_ENABLE_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>)
+  if (LIBCXXABI_USE_LLVM_UNWINDER)
+    if (LIBCXXABI_STATICALLY_LINK_UNWINDER_IN_SHARED_LIBRARY)
+      target_sources(cxxabi_shared_objects PUBLIC $<TARGET_OBJECTS:unwind_shared_objects>)
+    else()
+      target_link_libraries(cxxabi_shared_objects PUBLIC unwind_shared)
+    endif()
   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)
@@ -166,12 +169,11 @@ if (LIBCXXABI_ENABLE_SHARED)
       CXX_STANDARD_REQUIRED OFF
       COMPILE_FLAGS "${LIBCXXABI_COMPILE_FLAGS}"
       DEFINE_SYMBOL ""
+      EXCLUDE_FROM_ALL ON
   )
 
+if (LIBCXXABI_ENABLE_SHARED)
   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}"

(I guess the same change for always creating the cxxabi_static_objects, but with EXCLUDE_FROM_ALL, should be made too, but I just tested with the bare minimums for making this work for me.)

As mentioned in D116689, the EXCLUDE_FROM_ALL is going to require more cleanup throughout LLVM so I'd suggest making that change as a follow up.

[mstorsjo]

In D125393#3507435, @phosek wrote:

As mentioned in D116689, the EXCLUDE_FROM_ALL is going to require more cleanup throughout LLVM so I'd suggest making that change as a follow up.

Ah, sorry, I missed to pick up that detail there. As we do have the mingw-dll configuration in libcxx CI (which gets broken by this patch as-is), we need to fix this in one way or another before we can land this though.

[phosek]

libcxx/src/CMakeLists.txt

309

Note that this is a potential regression. Specifically, today you can merge static ABI libraries other than libcxxabi, but after this change only libcxxabi will be supported. I don't know if there are any users and if anyone is going to notice, but we should probably give an error when someone tries to use LIBCXX_STATICALLY_LINK_ABI_IN_STATIC_LIBRARY with ABI library other than libcxxabi (we might also consider renaming that option to LIBCXX_STATICALLY_LINK_LIBCXXABI_IN_STATIC_LIBRARY).

[ldionne]

Thanks a lot both @mstorsjo and @phosek for the comments. I've applied @mstorsjo's change (and made a similar change for static libraries). I also did it for libunwind.

@phosek I'm not sure I follow when you say that marking the object libraries as EXCLUDE_FROM_ALL is going to require some reworking elsewhere in LLVM. We are only marking the object libraries as EXCLUDE_FROM_ALL, and nobody outside the runtimes will be using them. The normal cxxabi_shared & friends targets will still be there, and they will still be built by default unless LIBCXXABI_ENABLE_SHARED=OFF.

libcxx/src/CMakeLists.txt

309

Hmm, good catch. After this change, they would get an error saying that the libcxx-abi-static-objects target does not exist, and they would have to go define it in HandleLibCXXABI.cmake. Honestly, I think that is reasonable, since I suspect nobody is doing that anyways.

Also, this comment got me thinking that perhaps it would be even better to replace the LIBCXX_STATICALLY_LINK_ABI_IN_STATIC_LIBRARY option by a new "ABI" library choice in HandleLibCXXABI.cmake where libcxx-abi-static and libcxx-abi-shared are the object libraries. So, for example, you'd specify LIBCXX_CXX_ABI=libcxxabi-objects instead of LIBCXX_CXX_ABI=libcxxabi LIBCXX_STATICALLY_LINK_ABI_IN_STATIC_LIBRARY =ON. We could make that change separately.

Do you have thoughts on removing LIBCXX_STATICALLY_LINK_ABI_IN_STATIC_LIBRARY in favour of a new "flavor" of libcxxabi in HandleLibCXXABI.cmake? I think it might be quite nice since it would remove even more logic.

[ldionne]

This should address review comments. Please LMK what you think.

[ldionne]

Fix issue with fPIC not being passed due to the usage of object libraries

[ldionne]

Hopefully fix libunwind issue.

[mstorsjo]

In D125393#3511412, @ldionne wrote:

This should address review comments. Please LMK what you think.

I’ll try to have a closer look tonight; until then, the mingw ci configs should test the most important bits at least.

[phosek]

LGTM

In D125393#3511394, @ldionne wrote:

Thanks a lot both @mstorsjo and @phosek for the comments. I've applied @mstorsjo's change (and made a similar change for static libraries). I also did it for libunwind.

@phosek I'm not sure I follow when you say that marking the object libraries as EXCLUDE_FROM_ALL is going to require some reworking elsewhere in LLVM. We are only marking the object libraries as EXCLUDE_FROM_ALL, and nobody outside the runtimes will be using them. The normal cxxabi_shared & friends targets will still be there, and they will still be built by default unless LIBCXXABI_ENABLE_SHARED=OFF.

See the discussion on D116689. What @mstorsjo would like to do is to build with LIBCXXABI_ENABLE_SHARED=OFF and LIBCXXABI_ENABLE_STATIC=OFF, but still merge libcxxabi into libcxx. I have since realized that this mode would make most sense for our build as well. Problem is that some parts of the build assume that if LLVM_ENABLE_RUNTIMES contains libcxxabi, either LIBCXXABI_ENABLE_SHARED=ON or LIBCXXABI_ENABLE_STATIC=ON is going to be set and fail if both are OFF. This is the case even for libcxxabi tests and makes sense, if there's no library being built, then there's nothing to link against. However, if libcxxabi objects are linked into libcxx, then you should be able to use libcxx in place of libcxxabi, but that's not supported today.

libcxx/src/CMakeLists.txt

309

I like that idea, treating the combined libcxxabi+libcxx as a dedicated build-mode is going to be cleaner then using a combination of different flags as is the case today.

[ldionne]

In D125393#3512071, @phosek wrote:

LGTM

In D125393#3511394, @ldionne wrote:

Thanks a lot both @mstorsjo and @phosek for the comments. I've applied @mstorsjo's change (and made a similar change for static libraries). I also did it for libunwind.

@phosek I'm not sure I follow when you say that marking the object libraries as EXCLUDE_FROM_ALL is going to require some reworking elsewhere in LLVM. We are only marking the object libraries as EXCLUDE_FROM_ALL, and nobody outside the runtimes will be using them. The normal cxxabi_shared & friends targets will still be there, and they will still be built by default unless LIBCXXABI_ENABLE_SHARED=OFF.

See the discussion on D116689. What @mstorsjo would like to do is to build with LIBCXXABI_ENABLE_SHARED=OFF and LIBCXXABI_ENABLE_STATIC=OFF, but still merge libcxxabi into libcxx. I have since realized that this mode would make most sense for our build as well. Problem is that some parts of the build assume that if LLVM_ENABLE_RUNTIMES contains libcxxabi, either LIBCXXABI_ENABLE_SHARED=ON or LIBCXXABI_ENABLE_STATIC=ON is going to be set and fail if both are OFF. This is the case even for libcxxabi tests and makes sense, if there's no library being built, then there's nothing to link against. However, if libcxxabi objects are linked into libcxx, then you should be able to use libcxx in place of libcxxabi, but that's not supported today.

Oh, got it. I did read D116689 but didn't see that. Anyways, yeah I guess what you describe would make sense. In fact, I think we should define cxxabi_static and cxxabi_shared, but mark them as EXCLUDE_FROM_ALL. Then we can make them dependents of cxxabi (which is not EXCLUDE_FROM_ALL) only when LIBCXXABI_ENABLE_SHARED=ON (etc.). I can look into that once this patch is landed.

libcxx/src/CMakeLists.txt

309

Awesome, I have a patch ready to go locally once this one lands.

[ldionne]

Try to fix the build on armv8 & friends.

Disregard the CI changes, I'm just trying to target the bots that failed previously.

[ldionne]

Try to fix linker script generation.

[mstorsjo]

In D125393#3511412, @ldionne wrote:

This should address review comments. Please LMK what you think.

This seems to work fine for me, thanks! (But please check that the full CI run works of course.) I didn't do a full review in detail, but from what I've looked at, it seems good to me!

In D125393#3512071, @phosek wrote:

See the discussion on D116689. What @mstorsjo would like to do is to build with LIBCXXABI_ENABLE_SHARED=OFF and LIBCXXABI_ENABLE_STATIC=OFF, but still merge libcxxabi into libcxx.

Well so far I do build with LIBCXXABI_ENABLE_STATIC=ON (otherwise I wouldn't have a static library to merge into libcxx) - it's just LIBCXXABI_ENABLE_SHARED which I have to disable because it's not possible to link. But as I don't need the static libcxxabi library as a final build product, I guess being able to disable both "product parts" of libcxxabi would be nice!

[ldionne]

AIX failure is a timeout.

[mgorny]

How can we link against installed libunwind.so now when building libcxxabi stand-alone?

libcxx/cmake/Modules/HandleLibCXXABI.cmake

 #===============================================================================
 # Define targets for linking against the selected ABI library
 #
 # After including this file, the following targets are defined:
 # - libcxx-abi-headers: An interface target that allows getting access to the
 #                       headers of the selected ABI library.
 # - libcxx-abi-shared: A target representing the selected shared ABI library.
 # - libcxx-abi-static: A target representing the selected static ABI library.
+#
+# Furthermore, some ABI libraries also define the following target:
+# - libcxx-abi-shared-objects: An object library representing a set of object files
+#                              constituting the ABI library, suitable for bundling
+#                              into a shared library.
+# - libcxx-abi-static-objects: An object library representing a set of object files
+#                              constituting the ABI library, suitable for bundling
+#                              into a static library.
 #===============================================================================
 
 include(GNUInstallDirs)
 
 # This function copies the provided headers to a private directory and adds that
 # path to the given INTERFACE target. That target can then be linked against to
 # get access to those headers (and only those).
 #
elseif ("${LIBCXX_CXX_ABI}" STREQUAL "libcxxabi")
   if (TARGET cxxabi_shared)
     add_library(libcxx-abi-shared ALIAS cxxabi_shared)
   endif()
 
   if (TARGET cxxabi_static)
     add_library(libcxx-abi-static ALIAS cxxabi_static)
   endif()
 
+  if (TARGET cxxabi_shared_objects)
+    add_library(libcxx-abi-shared-objects ALIAS cxxabi_shared_objects)
+  endif()
+
+  if (TARGET cxxabi_static_objects)
+    add_library(libcxx-abi-static-objects ALIAS cxxabi_static_objects)
+  endif()
+
 # Link against a system-provided libc++abi
 elseif ("${LIBCXX_CXX_ABI}" STREQUAL "system-libcxxabi")
   add_library(libcxx-abi-headers INTERFACE)
   import_private_headers(libcxx-abi-headers "${LIBCXX_CXX_ABI_INCLUDE_PATHS}" "cxxabi.h;__cxxabi_config.h")
   target_compile_definitions(libcxx-abi-headers INTERFACE "-DLIBCXX_BUILDING_LIBCXXABI")
 
   imported_library(libcxx-abi-shared SHARED "${LIBCXX_CXX_ABI_LIBRARY_PATH}" c++abi)
   target_link_libraries(libcxx-abi-shared INTERFACE libcxx-abi-headers)

libcxx/src/CMakeLists.txt

PROPERTIES
       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
+  # Note that we do need to link against libunwind directly to ensure that the correct
+  # dependencies are recorded when creating a linker script.
+  # TODO: Look into modifying the linker script creation to recursively consider interface libraries
   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" "$<TARGET_LINKER_FILE:libcxx-abi-static>")
-    else()
-      target_link_libraries(cxx_shared PRIVATE "-Wl,--whole-archive,-Bstatic" "$<TARGET_LINKER_FILE:libcxx-abi-static>" "-Wl,-Bdynamic,--no-whole-archive")
-    endif()
+    target_link_libraries(cxx_shared PRIVATE libcxx-abi-shared-objects)
   else()
     target_link_libraries(cxx_shared PUBLIC libcxx-abi-shared)
   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 STREQUAL "libcxxabi"
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)
-    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>"
-      "$<TARGET_LINKER_FILE:libcxx-abi-static>"
-      ""
-    WORKING_DIRECTORY ${LIBCXX_BUILD_DIR}
-    DEPENDS ${MERGE_ARCHIVES_ABI_TARGET}
-    )
+    target_link_libraries(cxx_static PRIVATE libcxx-abi-static-objects)
   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

libcxx/utils/merge_archives.py

-#!/usr/bin/env python
-#===----------------------------------------------------------------------===##
-#
-# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-# See https://llvm.org/LICENSE.txt for license information.
-# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-#
-#===----------------------------------------------------------------------===##
-
-from argparse import ArgumentParser
-import distutils.spawn
-import tempfile
-import os
-import shutil
-import subprocess
-import signal
-import sys
-
-temp_directory_root = None
-def exit_with_cleanups(status):
-    if temp_directory_root is not None:
-        shutil.rmtree(temp_directory_root)
-    sys.exit(status)
-
-def print_and_exit(msg):
-    sys.stderr.write(msg + '\n')
-    exit_with_cleanups(1)
-
-def find_and_diagnose_missing(lib, search_paths):
-    if os.path.exists(lib):
-        return os.path.abspath(lib)
-    if not lib.startswith('lib') or not lib.endswith('.a'):
-        print_and_exit(("input file '%s' not not name a static library. "
-                       "It should start with 'lib' and end with '.a") % lib)
-    for sp in search_paths:
-        assert type(sp) is list and len(sp) == 1
-        path = os.path.join(sp[0], lib)
-        if os.path.exists(path):
-            return os.path.abspath(path)
-    print_and_exit("input '%s' does not exist" % lib)
-
-
-def execute_command(cmd, cwd=None):
-    """
-    Execute a command, capture and return its output.
-    """
-    kwargs = {
-        'stdin': subprocess.PIPE,
-        'stdout': subprocess.PIPE,
-        'stderr': subprocess.PIPE,
-        'cwd': cwd,
-        'universal_newlines': True
-    }
-    p = subprocess.Popen(cmd, **kwargs)
-    out, err = p.communicate()
-    exitCode = p.wait()
-    if exitCode == -signal.SIGINT:
-        raise KeyboardInterrupt
-    return out, err, exitCode
-
-
-def execute_command_verbose(cmd, cwd=None, verbose=False):
-    """
-    Execute a command and print its output on failure.
-    """
-    out, err, exitCode = execute_command(cmd, cwd=cwd)
-    if exitCode != 0 or verbose:
-        report = "Command: %s\n" % ' '.join(["'%s'" % a for a in cmd])
-        if exitCode != 0:
-            report += "Exit Code: %d\n" % exitCode
-        if out:
-            report += "Standard Output:\n--\n%s--" % out
-        if err:
-            report += "Standard Error:\n--\n%s--" % err
-        if exitCode != 0:
-            report += "\n\nFailed!"
-        sys.stderr.write('%s\n' % report)
-        if exitCode != 0:
-            exit_with_cleanups(exitCode)
-    return out
-
-def main():
-    parser = ArgumentParser(
-        description="Merge multiple archives into a single library")
-    parser.add_argument(
-        '-v', '--verbose', dest='verbose', action='store_true', default=False)
-    parser.add_argument(
-        '-o', '--output', dest='output', required=True,
-        help='The output file. stdout is used if not given',
-        type=str, action='store')
-    parser.add_argument(
-        '-L', dest='search_paths',
-        help='Paths to search for the libraries along', action='append',
-        nargs=1, default=[])
-    parser.add_argument(
-        '--ar', dest='ar_exe', required=False,
-        help='The ar executable to use, finds \'ar\' in the path if not given',
-        type=str, action='store')
-    parser.add_argument(
-        '--use-libtool', dest='use_libtool', action='store_true', default=False)
-    parser.add_argument(
-        '--libtool', dest='libtool_exe', required=False,
-        help='The libtool executable to use, finds \'libtool\' in the path if not given',
-        type=str, action='store')
-    parser.add_argument(
-        'archives', metavar='archives',  nargs='+',
-        help='The archives to merge')
-
-    args = parser.parse_args()
-
-    ar_exe = args.ar_exe
-    if not ar_exe:
-        ar_exe = distutils.spawn.find_executable('ar')
-    if not ar_exe:
-        print_and_exit("failed to find 'ar' executable")
-
-    if args.use_libtool:
-        libtool_exe = args.libtool_exe
-        if not libtool_exe:
-            libtool_exe = distutils.spawn.find_executable('libtool')
-        if not libtool_exe:
-            print_and_exit("failed to find 'libtool' executable")
-
-    if len(args.archives) < 2:
-        print_and_exit('fewer than 2 inputs provided')
-    archives = [find_and_diagnose_missing(ar, args.search_paths)
-                for ar in args.archives]
-    print ('Merging archives: %s' % archives)
-    if not os.path.exists(os.path.dirname(args.output)):
-        print_and_exit("output path doesn't exist: '%s'" % args.output)
-
-    global temp_directory_root
-    temp_directory_root = tempfile.mkdtemp('.libcxx.merge.archives')
-
-    files = []
-    for arc in archives:
-        execute_command_verbose([ar_exe, 'x', arc],
-                                cwd=temp_directory_root, verbose=args.verbose)
-        out = execute_command_verbose([ar_exe, 't', arc])
-        files.extend(out.splitlines())
-
-    if args.use_libtool:
-        files = [f for f in files if not f.startswith('__.SYMDEF')]
-        execute_command_verbose([libtool_exe, '-static', '-o', args.output] + files,
-                                cwd=temp_directory_root, verbose=args.verbose)
-    else:
-        execute_command_verbose([ar_exe, 'rcs', args.output] + files,
-                                cwd=temp_directory_root, verbose=args.verbose)
-
-
-if __name__ == '__main__':
-    main()
-    exit_with_cleanups(0)

libcxxabi/cmake/Modules/HandleLibcxxabiFlags.cmake

if(${condition})
     add_library_flags(${ARGN})
   endif()
 endmacro()
 
 # Turn a comma separated CMake list into a space separated string.
 macro(split_list listname)
   string(REPLACE ";" " " ${listname} "${${listname}}")
 endmacro()
+
+# For each specified flag, add that compile flag to the provided target.
+# The flags are added with the given visibility, i.e. PUBLIC|PRIVATE|INTERFACE.
+function(target_add_compile_flags_if_supported target visibility)
+  foreach(flag ${ARGN})
+    mangle_name("${flag}" flagname)
+    check_cxx_compiler_flag("${flag}" "CXX_SUPPORTS_${flagname}_FLAG")
+    if (CXX_SUPPORTS_${flagname}_FLAG)
+      target_compile_options(${target} ${visibility} ${flag})
+    endif()
+  endforeach()
+endfunction()

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 )
if (LLVM_ENABLE_MODULES)
   string(REPLACE "-Wl,-z,defs" "" CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS}")
 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)
+add_library(cxxabi_shared_objects OBJECT EXCLUDE_FROM_ALL ${LIBCXXABI_SOURCES} ${LIBCXXABI_HEADERS})
+if (LIBCXXABI_USE_LLVM_UNWINDER)
+  if (LIBCXXABI_STATICALLY_LINK_UNWINDER_IN_SHARED_LIBRARY)
+    target_sources(cxxabi_shared_objects PUBLIC $<TARGET_OBJECTS:unwind_shared_objects>)
+  else()
+    target_link_libraries(cxxabi_shared_objects PUBLIC unwind_shared)
   endif()
-  set_target_properties(cxxabi_shared
-    PROPERTIES
-      CXX_EXTENSIONS OFF
-      CXX_STANDARD 20
-      CXX_STANDARD_REQUIRED OFF
-      COMPILE_FLAGS "${LIBCXXABI_COMPILE_FLAGS}"
+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
+    DEFINE_SYMBOL ""
+)
+if (CMAKE_POSITION_INDEPENDENT_CODE OR NOT DEFINED CMAKE_POSITION_INDEPENDENT_CODE)
+  set_target_properties(cxxabi_shared_objects PROPERTIES POSITION_INDEPENDENT_CODE ON) # must set manually because it's an object library
+endif()
+
+if (LIBCXXABI_ENABLE_SHARED)
+  add_library(cxxabi_shared SHARED)
+  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
+    PUBLIC cxxabi_shared_objects
+    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)
       else()
         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)
-  endif()
-  set_target_properties(cxxabi_static
-    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"
-    )
+add_library(cxxabi_static_objects OBJECT EXCLUDE_FROM_ALL ${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>)
+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
 
-  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
-      PRIVATE
-        _LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS
-        _LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS)
-  endif()
+  target_add_compile_flags_if_supported(cxxabi_static_objects PRIVATE -fvisibility=hidden)
+    target_add_compile_flags_if_supported(cxxabi_static_objects PRIVATE -fvisibility-global-new-delete-hidden)
+  target_compile_definitions(cxxabi_static_objects
 
-  list(APPEND LIBCXXABI_BUILD_TARGETS "cxxabi_static")
-  if (LIBCXXABI_INSTALL_STATIC_LIBRARY)
-    list(APPEND LIBCXXABI_INSTALL_TARGETS "cxxabi_static")
+if (LIBCXXABI_ENABLE_STATIC)
+  add_library(cxxabi_static STATIC)
+  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
+    PUBLIC cxxabi_static_objects
+    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/cmake/Modules/HandleLibunwindFlags.cmake

if(${condition})
     add_library_flags(${ARGN})
   endif()
 endmacro()
 
 # Turn a comma separated CMake list into a space separated string.
 macro(split_list listname)
   string(REPLACE ";" " " ${listname} "${${listname}}")
 endmacro()
+
+# For each specified flag, add that compile flag to the provided target.
+# The flags are added with the given visibility, i.e. PUBLIC|PRIVATE|INTERFACE.
+function(target_add_compile_flags_if_supported target visibility)
+  foreach(flag ${ARGN})
+    mangle_name("${flag}" flagname)
+    check_cxx_compiler_flag("${flag}" "CXX_SUPPORTS_${flagname}_FLAG")
+    if (CXX_SUPPORTS_${flagname}_FLAG)
+      target_compile_options(${target} ${visibility} ${flag})
+    endif()
+  endforeach()
+endfunction()

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})
-  if(CMAKE_C_COMPILER_ID STREQUAL MSVC)
-    target_compile_options(unwind_shared PRIVATE /GR-)
-  else()
-    target_compile_options(unwind_shared PRIVATE -fno-rtti)
-  endif()
-  target_link_libraries(unwind_shared PRIVATE ${LIBUNWIND_LIBRARIES}
-                                      PRIVATE unwind-headers)
-  set_target_properties(unwind_shared
-    PROPERTIES
-      CXX_EXTENSIONS OFF
-      CXX_STANDARD 11
-      CXX_STANDARD_REQUIRED ON
-      COMPILE_FLAGS "${LIBUNWIND_COMPILE_FLAGS}"
+add_library(unwind_shared_objects OBJECT EXCLUDE_FROM_ALL ${LIBUNWIND_SOURCES} ${LIBUNWIND_HEADERS})
+  target_compile_options(unwind_shared_objects PRIVATE /GR-)
+  target_compile_options(unwind_shared_objects PRIVATE -fno-rtti)
+target_link_libraries(unwind_shared_objects PRIVATE unwind-headers ${LIBUNWIND_LIBRARIES})
+set_target_properties(unwind_shared_objects
+)
+if (CMAKE_POSITION_INDEPENDENT_CODE OR NOT DEFINED CMAKE_POSITION_INDEPENDENT_CODE)
+  set_target_properties(unwind_shared_objects PROPERTIES POSITION_INDEPENDENT_CODE ON) # must set manually because it's an object library
+endif()
+
+if (LIBUNWIND_ENABLE_SHARED)
+  add_library(unwind_shared SHARED)
+  target_link_libraries(unwind_shared PUBLIC unwind_shared_objects)
+  set_target_properties(unwind_shared
+    PROPERTIES
       LINK_FLAGS "${LIBUNWIND_LINK_FLAGS}"
       LINKER_LANGUAGE C
       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})
-  if(CMAKE_C_COMPILER_ID STREQUAL MSVC)
-    target_compile_options(unwind_static PRIVATE /GR-)
-  else()
-    target_compile_options(unwind_static PRIVATE -fno-rtti)
-  endif()
-  target_link_libraries(unwind_static PRIVATE ${LIBUNWIND_LIBRARIES}
-                                      PRIVATE unwind-headers)
-  set_target_properties(unwind_static
-    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"
-  )
+add_library(unwind_static_objects OBJECT EXCLUDE_FROM_ALL ${LIBUNWIND_SOURCES} ${LIBUNWIND_HEADERS})
+  target_compile_options(unwind_static_objects PRIVATE /GR-)
+  target_compile_options(unwind_static_objects PRIVATE -fno-rtti)
+target_link_libraries(unwind_static_objects PRIVATE unwind-headers ${LIBUNWIND_LIBRARIES})
+set_target_properties(unwind_static_objects
 
-  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)
-  endif()
+  target_add_compile_flags_if_supported(unwind_static_objects PRIVATE -fvisibility=hidden)
+  target_add_compile_flags_if_supported(unwind_static_objects PRIVATE -fvisibility-global-new-delete-hidden)
+  target_compile_definitions(unwind_static_objects PRIVATE _LIBUNWIND_HIDE_SYMBOLS)
 
+if (LIBUNWIND_ENABLE_STATIC)
+  add_library(unwind_static STATIC)
+  target_link_libraries(unwind_static PUBLIC unwind_static_objects)
+  set_target_properties(unwind_static
+    PROPERTIES
+      LINK_FLAGS "${LIBUNWIND_LINK_FLAGS}"
+      LINKER_LANGUAGE C
+      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})