[libc++abi] Install the libc++abi headers from libc++abi

[ldionne]

Summary

libc++abi should be responsible for installing its own headers, it
doesn't make sense for libc++ to be responsible for it.

[ldionne]

llvm/utils/gn/secondary/libcxx/include/BUILD.gn

271–281 ↗

(On Diff #341195)

Trying to save you a headache @thakis, but I'd like you to double-check this is OK.

[phosek]

LGTM

libcxx/cmake/Modules/HandleLibCXXABI.cmake

15

We should also consider inlining this macro, I don't think it's getting us anything and I always have to lookup what each argument does so at least in my experience it harms readability.

[thakis]

Makes sense to me.

Just to confirm: Even back when clang assumed that libc++ headers shipped with the compiler instead of the sdk on macOS (which I think is still the case in currently shipping xcode), it didn't assume that the libc++abi headers ship with the compiler, right? (I patched this in and clang still seems to compile a program that includes <iostream> fine, so it looks like it.)

Is there anything else that installs this header? We don't need it, but someone might?

[ldionne]

In D101458#2723626, @thakis wrote:

Makes sense to me.

Just to confirm: Even back when clang assumed that libc++ headers shipped with the compiler instead of the sdk on macOS (which I think is still the case in currently shipping xcode), it didn't assume that the libc++abi headers ship with the compiler, right? (I patched this in and clang still seems to compile a program that includes <iostream> fine, so it looks like it.)

Fact: Clang used to assume that libc++ was shipped in <toolchain>/include/c++/v1, and nowadays it looks in <sdk>/include/c++/v1 first, and only falls back to <toolchain>/include/c++/v1.
Fact: Recent SDKs have the libc++ headers in <sdk>/usr/include/c++/v1.
Fact: The <cxxabi.h> header is present in both <sdk>/usr/include/c++/v1 and <sdk>/usr/include (and also in <toolchain>/usr/include/c++/v1 until we remove all traces of libc++/libc++abi from the toolchain). It looks like they are always the same thing. It's harmless but silly, since we should really have only one copy. It turns out I don't understand how the copy in <sdk>/usr/include ends up there, so I'll investigate that.

Your main question: I'm pretty sure Clang used to expect <cxxabi.h> in <toolchain>/usr/include/c++/v1, alongside the rest of libc++.

I actually hadn't realized that, and it does change what I was going to do. Instead of always installing <cxxabi.h> to <install>/usr/include, I think the correct thing to do would be to always install it to <install>/usr/include/c++/v1, but to do that directly from libc++abi. My next update will reflect that.

Edit I just found out where <sdk>/usr/include/cxxabi.h comes from. We copy it explicitly here: https://github.com/llvm/llvm-project/blob/main/libcxx/utils/ci/apple-install-libcxx.sh#L159. I wrote that code, I should have known!

libcxx/cmake/Modules/HandleLibCXXABI.cmake

15

Oh yeah, totally, I want to clean up this mess, one step at a time.

[ldionne]

Install <cxxabi.h> from libc++abi.

Pinging @dim since I think you folks use a different ABI library - you should make
sure that your ABI library is installing <cxxabi.h> in a place where users can find
it on its own.

[ldionne]

Drop the gn changes.

llvm/utils/gn/secondary/libcxx/include/BUILD.gn

271–281 ↗

(On Diff #341195)

@thakis I suspect you'll have more fixing up to do since you need to install the libc++abi headers from the libc++abi build. I'll just drop this GN change to avoid muddying the waters, but I'm still giving you this heads up.

[ldionne]

Link cxx_static against libc++abi to get the header dependency.

[ldionne]

Rebase onto main, and don't touch any logic inside libc++. In other words, only start installing
the headers from libc++abi. I'll keep any potentially-breaking change in a separate patch.

[ldionne]

Rebase onto main -- I am unable to reproduce the CI issue with GCC, and it looks like a fluke to me.

libcxx/cmake/Modules/HandleLibCXXABI.cmake

 
 #===============================================================================
 # Add an ABI library if appropriate
 #===============================================================================
 
 #
 # _setup_abi: Set up the build to use an ABI library
 #
 # Parameters:
 #   abidefines: A list of defines needed to compile libc++ with the ABI library
 #   abishared : The shared ABI library to link against.
 #   abistatic : The static ABI library to link against.
-#   abifiles  : A list of files (which may be relative paths) to copy into the
-#               libc++ build tree for the build.  These files will be copied
-#               twice: once into include/, so the libc++ build itself can find
-#               them, and once into include/c++/v1, so that a clang built into
-#               the same build area will find them.  These files will also be
-#               installed alongside the libc++ headers.
-#   abidirs   : A list of relative paths to create under an include directory
-#               in the libc++ build directory.
 #
 
-macro(setup_abi_lib abidefines abishared abistatic abifiles abidirs)
+macro(setup_abi_lib abidefines abishared abistatic)
   list(APPEND LIBCXX_COMPILE_FLAGS ${abidefines})
   set(LIBCXX_CXX_ABI_INCLUDE_PATHS "${LIBCXX_CXX_ABI_INCLUDE_PATHS}"
     CACHE PATH
     "Paths to C++ ABI header directories separated by ';'." FORCE
     )
   set(LIBCXX_CXX_ABI_LIBRARY_PATH "${LIBCXX_CXX_ABI_LIBRARY_PATH}"
     CACHE PATH
     "Paths to C++ ABI library directory"
     )
   set(LIBCXX_CXX_SHARED_ABI_LIBRARY ${abishared})
   set(LIBCXX_CXX_STATIC_ABI_LIBRARY ${abistatic})
-  set(LIBCXX_ABILIB_FILES ${abifiles})
-
-  foreach(fpath ${LIBCXX_ABILIB_FILES})
-    set(found FALSE)
-    foreach(incpath ${LIBCXX_CXX_ABI_INCLUDE_PATHS})
-      message(STATUS "Looking for ${fpath} in ${incpath}")
-      if (EXISTS "${incpath}/${fpath}")
-        set(found TRUE)
-        message(STATUS "Looking for ${fpath} in ${incpath} - found")
-        get_filename_component(dstdir ${fpath} PATH)
-        get_filename_component(ifile ${fpath} NAME)
-        set(src ${incpath}/${fpath})
-
-        set(dst ${LIBCXX_BINARY_INCLUDE_DIR}/${dstdir}/${ifile})
-        add_custom_command(OUTPUT ${dst}
-            DEPENDS ${src}
-            COMMAND ${CMAKE_COMMAND} -E copy_if_different ${src} ${dst}
-            COMMENT "Copying C++ ABI header ${fpath}...")
-        list(APPEND abilib_headers "${dst}")
-
-        # TODO: libc++ shouldn't be responsible for copying the libc++abi
-        # headers into the right location.
-        set(dst "${LIBCXX_GENERATED_INCLUDE_DIR}/${dstdir}/${fpath}")
-        add_custom_command(OUTPUT ${dst}
-            DEPENDS ${src}
-            COMMAND ${CMAKE_COMMAND} -E copy_if_different ${src} ${dst}
-            COMMENT "Copying C++ ABI header ${fpath}...")
-        list(APPEND abilib_headers "${dst}")
-
-        if (LIBCXX_INSTALL_HEADERS)
-          install(FILES "${LIBCXX_BINARY_INCLUDE_DIR}/${fpath}"
-            DESTINATION include/c++/v1/${dstdir}
-            COMPONENT cxx-headers
-            PERMISSIONS OWNER_READ OWNER_WRITE GROUP_READ WORLD_READ
-            )
-        endif()
-      else()
-        message(STATUS "Looking for ${fpath} in ${incpath} - not found")
-      endif()
-    endforeach()
-    if (NOT found)
-      message(WARNING "Failed to find ${fpath} in ${LIBCXX_CXX_ABI_INCLUDE_PATHS}")
-    endif()
-  endforeach()
-
-  include_directories("${LIBCXX_BINARY_INCLUDE_DIR}")
-  add_custom_target(cxx_abi_headers ALL DEPENDS ${abilib_headers})
-  set(LIBCXX_CXX_ABI_HEADER_TARGET "cxx_abi_headers")
 endmacro()
 
 
 # Configure based on the selected ABI library.
 if ("${LIBCXX_CXX_ABI_LIBNAME}" STREQUAL "libstdc++" OR
     "${LIBCXX_CXX_ABI_LIBNAME}" STREQUAL "libsupc++")
   set(_LIBSUPCXX_INCLUDE_FILES
     cxxabi.h bits/c++config.h bits/os_defines.h bits/cpu_defines.h
     bits/cxxabi_tweaks.h bits/cxxabi_forced.h
     )
   if ("${LIBCXX_CXX_ABI_LIBNAME}" STREQUAL "libstdc++")
     set(_LIBSUPCXX_DEFINES "-DLIBSTDCXX")
     set(_LIBSUPCXX_LIBNAME stdc++)
   else()
     set(_LIBSUPCXX_DEFINES "")
     set(_LIBSUPCXX_LIBNAME supc++)
   endif()
   setup_abi_lib(
     "-D__GLIBCXX__ ${_LIBSUPCXX_DEFINES}"
-    "${_LIBSUPCXX_LIBNAME}" "${_LIBSUPCXX_LIBNAME}" "${_LIBSUPCXX_INCLUDE_FILES}" "bits"
+    "${_LIBSUPCXX_LIBNAME}" "${_LIBSUPCXX_LIBNAME}"
     )
 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()
     set(shared cxxabi_shared)
     set(static cxxabi_static)
   endif()
 
   setup_abi_lib(
     "-DLIBCXX_BUILDING_LIBCXXABI"
-    "${shared}" "${static}" "cxxabi.h;__cxxabi_config.h" "")
+    "${shared}" "${static}")
 elseif ("${LIBCXX_CXX_ABI_LIBNAME}" STREQUAL "libcxxrt")
   if(NOT LIBCXX_CXX_ABI_INCLUDE_PATHS)
     set(LIBCXX_CXX_ABI_INCLUDE_PATHS "/usr/include/c++/v1")
   endif()
   # libcxxrt does not provide aligned new and delete operators
   set(LIBCXX_ENABLE_NEW_DELETE_DEFINITIONS ON)
   setup_abi_lib(
     "-DLIBCXXRT"
-    "cxxrt" "cxxrt" "cxxabi.h;unwind.h;unwind-arm.h;unwind-itanium.h" ""
+    "cxxrt" "cxxrt"
     )
 elseif ("${LIBCXX_CXX_ABI_LIBNAME}" STREQUAL "vcruntime")
  # Nothing to do
 elseif ("${LIBCXX_CXX_ABI_LIBNAME}" STREQUAL "none")
   list(APPEND LIBCXX_COMPILE_FLAGS "-D_LIBCPP_BUILDING_HAS_NO_ABI_LIBRARY")
 elseif ("${LIBCXX_CXX_ABI_LIBNAME}" STREQUAL "default")
   # Nothing to do
 else()
   message(FATAL_ERROR
     "Unsupported c++ abi: '${LIBCXX_CXX_ABI_LIBNAME}'. \
      Currently libstdc++, libsupc++, libcxxabi, libcxxrt, default and none are
      supported for c++ abi."
     )
 endif ()

libcxx/include/CMakeLists.txt

add_custom_command(OUTPUT ${dst}
     COMMAND ${CMAKE_COMMAND} -E copy_if_different ${src} ${dst}
     COMMENT "Copying CXX header ${f}")
   list(APPEND _all_includes "${dst}")
 endforeach()
 
 add_custom_target(generate-cxx-headers ALL DEPENDS ${_all_includes})
 
 add_library(cxx-headers INTERFACE)
-add_dependencies(cxx-headers generate-cxx-headers ${LIBCXX_CXX_ABI_HEADER_TARGET})
+add_dependencies(cxx-headers generate-cxx-headers)
 # TODO: Use target_include_directories once we figure out why that breaks the runtimes build
 if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC" OR "${CMAKE_CXX_SIMULATE_ID}" STREQUAL "MSVC")
   target_compile_options(cxx-headers INTERFACE /I${LIBCXX_GENERATED_INCLUDE_DIR}
                                      INTERFACE /I${LIBCXX_GENERATED_INCLUDE_TARGET_DIR})
 else()
   target_compile_options(cxx-headers INTERFACE -I${LIBCXX_GENERATED_INCLUDE_DIR}
                                      INTERFACE -I${LIBCXX_GENERATED_INCLUDE_TARGET_DIR})
 endif()

libcxx/src/CMakeLists.txt

if (APPLE AND LLVM_USE_SANITIZER)
   endif()
 endif()
 
 if (LIBCXX_ENABLE_PARALLEL_ALGORITHMS AND NOT TARGET pstl::ParallelSTL)
   message(FATAL_ERROR "Could not find ParallelSTL")
 endif()
 
 function(cxx_set_common_defines name)
-  if(LIBCXX_CXX_ABI_HEADER_TARGET)
-    add_dependencies(${name} ${LIBCXX_CXX_ABI_HEADER_TARGET})
-  endif()
-
   if (LIBCXX_ENABLE_PARALLEL_ALGORITHMS)
     target_link_libraries(${name} PUBLIC pstl::ParallelSTL)
   endif()
 endfunction()
 
 split_list(LIBCXX_COMPILE_FLAGS)
 split_list(LIBCXX_LINK_FLAGS)
 

 endif()
 
 set(CMAKE_STATIC_LIBRARY_PREFIX "lib")
 
 # Build the static library.
 if (LIBCXX_ENABLE_STATIC)
   add_library(cxx_static STATIC ${exclude_from_all} ${LIBCXX_SOURCES} ${LIBCXX_HEADERS})
   target_link_libraries(cxx_static PUBLIC cxx-headers
-                                   PRIVATE ${LIBCXX_LIBRARIES})
+                                   PRIVATE ${LIBCXX_LIBRARIES}
+                                   PRIVATE ${LIBCXX_CXX_STATIC_ABI_LIBRARY})
   set_target_properties(cxx_static
     PROPERTIES
       COMPILE_FLAGS "${LIBCXX_COMPILE_FLAGS}"
       LINK_FLAGS    "${LIBCXX_LINK_FLAGS}"
       OUTPUT_NAME   "c++"
       POSITION_INDEPENDENT_CODE ON
   )
   cxx_add_common_build_flags(cxx_static)

libcxx/utils/ci/apple-install-libcxx.sh

 (cd "${install_dir}/usr/lib" && ln -s "libc++.1.dylib" libc++.dylib)
 
 # Install the headers by copying the headers from one of the built architectures
 # into the install directory. Headers from all architectures should be the same.
 step "Installing the libc++ and libc++abi headers to ${install_dir}/usr/include"
 any_arch=$(echo ${architectures} | cut -d ' ' -f 1)
 mkdir -p "${install_dir}/usr/include"
 ditto "${build_dir}/${any_arch}-install/include" "${install_dir}/usr/include"
-ditto "${llvm_root}/libcxxabi/include" "${install_dir}/usr/include" # TODO: libcxxabi should install its headers in CMake
 if [[ $EUID -eq 0 ]]; then # Only chown if we're running as root
     chown -R root:wheel "${install_dir}/usr/include"
 fi
 
 step "Installing the libc++ and libc++abi licenses"
 mkdir -p "${install_dir}/usr/local/OpenSourceLicenses"
 cp "${llvm_root}/libcxx/LICENSE.TXT" "${install_dir}/usr/local/OpenSourceLicenses/libcxx.txt"
 cp "${llvm_root}/libcxxabi/LICENSE.TXT" "${install_dir}/usr/local/OpenSourceLicenses/libcxxabi.txt"
 
 # Also install universal static archives for libc++ and libc++abi
 libcxx_archives=$(for arch in ${architectures}; do echo "${build_dir}/${arch}-install/lib/libc++.a"; done)
 libcxxabi_archives=$(for arch in ${architectures}; do echo "${build_dir}/${arch}-install/lib/libc++abi.a"; done)
 step "Creating universal static archives for libc++ and libc++abi from the static archives for each architecture"
 mkdir -p "${install_dir}/usr/local/lib/libcxx"
 xcrun --sdk "${sdk}" libtool -static ${libcxx_archives} -o "${install_dir}/usr/local/lib/libcxx/libc++-static.a"
 xcrun --sdk "${sdk}" libtool -static ${libcxxabi_archives} -o "${install_dir}/usr/local/lib/libcxx/libc++abi-static.a"

libcxxabi/CMakeLists.txt

 option(LIBCXXABI_ENABLE_NEW_DELETE_DEFINITIONS
   "Build libc++abi with definitions for operator new/delete. These are normally
    defined in libc++abi, but it is also possible to define them in libc++, in
    which case the definition in libc++abi should be turned off." ON)
 option(LIBCXXABI_BUILD_32_BITS "Build 32 bit libc++abi." ${LLVM_BUILD_32_BITS})
 option(LIBCXXABI_INCLUDE_TESTS "Generate build targets for the libc++abi unit tests." ${LLVM_INCLUDE_TESTS})
 set(LIBCXXABI_LIBDIR_SUFFIX "${LLVM_LIBDIR_SUFFIX}" CACHE STRING
     "Define suffix of library directory name (32/64)")
+option(LIBCXXABI_INSTALL_HEADERS "Install the libc++abi headers." ON)
 option(LIBCXXABI_INSTALL_LIBRARY "Install the libc++abi library." ON)
+set(LIBCXXABI_INSTALL_INCLUDE_DIR "include/c++/v1" CACHE PATH "Path to install the libc++abi headers at.")
 set(LIBCXXABI_TARGET_TRIPLE "${LLVM_DEFAULT_TARGET_TRIPLE}" CACHE STRING "Target triple for cross compiling.")
 set(LIBCXXABI_GCC_TOOLCHAIN "" CACHE PATH "GCC toolchain for cross compiling.")
 set(LIBCXXABI_SYSROOT "" CACHE PATH "Sysroot for cross compiling.")
 set(LIBCXXABI_LIBCXX_LIBRARY_PATH "" CACHE PATH "The path to libc++ library.")
 set(LIBCXXABI_LIBRARY_VERSION "1.0" CACHE STRING
 "Version of libc++abi. This will be reflected in the name of the shared \
 library produced. For example, -DLIBCXXABI_LIBRARY_VERSION=x.y will \
 result in the library being named libc++abi.x.y.dylib, along with the \

 # Setup Source Code
 #===============================================================================
 
 set(LIBCXXABI_LIBUNWIND_INCLUDES "${LIBCXXABI_LIBUNWIND_INCLUDES}" CACHE PATH
     "Specify path to libunwind includes." FORCE)
 set(LIBCXXABI_LIBUNWIND_PATH "${LIBCXXABI_LIBUNWIND_PATH}" CACHE PATH
     "Specify path to libunwind source." FORCE)
 
-include_directories(include)
 if (LIBCXXABI_USE_LLVM_UNWINDER OR LLVM_NATIVE_ARCH MATCHES ARM)
   find_path(LIBCXXABI_LIBUNWIND_INCLUDES_INTERNAL libunwind.h
     PATHS ${LIBCXXABI_LIBUNWIND_INCLUDES}
           ${LIBCXXABI_LIBUNWIND_PATH}/include
           ${CMAKE_BINARY_DIR}/${LIBCXXABI_LIBUNWIND_INCLUDES}
           ${LLVM_MAIN_SRC_DIR}/projects/libunwind/include
           ${LLVM_MAIN_SRC_DIR}/runtimes/libunwind/include
           ${LLVM_MAIN_SRC_DIR}/../libunwind/include
     NO_DEFAULT_PATH
     NO_CMAKE_FIND_ROOT_PATH
   )
 
   if (LIBCXXABI_LIBUNWIND_INCLUDES_INTERNAL STREQUAL "LIBCXXABI_LIBUNWIND_INCLUDES_INTERNAL-NOTFOUND")
     set(LIBCXXABI_LIBUNWIND_INCLUDES_INTERNAL "")
   endif()
 
   if (NOT LIBCXXABI_LIBUNWIND_INCLUDES_INTERNAL STREQUAL "")
     include_directories("${LIBCXXABI_LIBUNWIND_INCLUDES_INTERNAL}")
   endif()
 endif()
 
 # Add source code. This also contains all of the logic for deciding linker flags
 # soname, etc...
+add_subdirectory(include)
 add_subdirectory(src)
 
 if (LIBCXXABI_INCLUDE_TESTS)
   add_subdirectory(test)
   add_subdirectory(fuzz)
 endif()

libcxxabi/include/CMakeLists.txt

+set(files
+  __cxxabi_config.h
+  cxxabi.h
+  )
+
+add_library(cxxabi-headers INTERFACE)
+target_include_directories(cxxabi-headers INTERFACE "${CMAKE_CURRENT_SOURCE_DIR}")
+
+if (LIBCXXABI_INSTALL_HEADERS)
+  foreach(file ${files})
+    get_filename_component(dir ${file} DIRECTORY)
+    install(FILES ${file}
+      DESTINATION ${LIBCXXABI_INSTALL_INCLUDE_DIR}/${dir}
+      COMPONENT cxxabi-headers
+      PERMISSIONS OWNER_READ OWNER_WRITE GROUP_READ WORLD_READ
+    )
+  endforeach()
+
+  add_custom_target(install-cxxabi-headers
+                    DEPENDS cxxabi-headers
+                    COMMAND "${CMAKE_COMMAND}"
+                            -DCMAKE_INSTALL_COMPONENT=cxxabi-headers
+                            -P "${CMAKE_BINARY_DIR}/cmake_install.cmake")
+  # Stripping is a no-op for headers
+  add_custom_target(install-cxxabi-headers-stripped DEPENDS install-cxxabi-headers)
+endif()

libcxxabi/src/CMakeLists.txt

 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
     PROPERTIES
       CXX_EXTENSIONS OFF
       CXX_STANDARD 20
       CXX_STANDARD_REQUIRED OFF
if (APPLE)
     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
install(TARGETS ${LIBCXXABI_INSTALL_TARGETS}
     LIBRARY DESTINATION ${LIBCXXABI_INSTALL_LIBRARY_DIR} COMPONENT cxxabi
     ARCHIVE DESTINATION ${LIBCXXABI_INSTALL_LIBRARY_DIR} COMPONENT cxxabi
     RUNTIME DESTINATION ${LIBCXXABI_INSTALL_RUNTIME_DIR} COMPONENT cxxabi
     )
 endif()
 
 if (NOT CMAKE_CONFIGURATION_TYPES AND LIBCXXABI_INSTALL_LIBRARY)
   add_custom_target(install-cxxabi
-    DEPENDS cxxabi
+    DEPENDS cxxabi install-cxxabi-headers
     COMMAND "${CMAKE_COMMAND}"
             -DCMAKE_INSTALL_COMPONENT=cxxabi
             -P "${LIBCXXABI_BINARY_DIR}/cmake_install.cmake")
   add_custom_target(install-cxxabi-stripped
     DEPENDS cxxabi
     COMMAND "${CMAKE_COMMAND}"
             -DCMAKE_INSTALL_COMPONENT=cxxabi
             -DCMAKE_INSTALL_DO_STRIP=1
             -P "${LIBCXXABI_BINARY_DIR}/cmake_install.cmake")
 endif()