[runtimes] Replace LIBCXX_ENABLE_STATIC_ABI_LIBRARY & friends by a new LIBCXX_CXX_ABI choice

[ldionne]

Summary

Instead of having complicated options like LIBCXX_ENABLE_STATIC_ABI_LIBRARY
and LIBCXX_STATICALLY_LINK_ABI_IN_STATIC_LIBRARY, introduce the new
libcxxabi-objects choice of ABI library to allow merging the ABI library
objects into libc++.

Note that the same refactoring can be applied to how libc++abi merges
libunwind's objects, however that can be done as a separate step.

[mstorsjo]

It looks like this patch still lacks compatibility handling for all external users that are setting this option, which need to be able to set the option in this way at least until after the 15.0.0 release.

[ldionne]

In D125683#3515675, @mstorsjo wrote:

It looks like this patch still lacks compatibility handling for all external users that are setting this option, which need to be able to set the option in this way at least until after the 15.0.0 release.

What would you think about erroring out if someone is still passing LIBCXX_STATICALLY_LINK_ABI_IN_{SHARED|STATIC}_LIBRARY? Sure, we can try to support both for a while, but I wonder whether there's any actual benefit to balance the added complexity. Concretely, I suspect this impacts very few people, and the fix is really simple. And if we error out during the CMake step, we don't risk breaking anyone silently.

[mstorsjo]

In D125683#3516883, @ldionne wrote:

In D125683#3515675, @mstorsjo wrote:

It looks like this patch still lacks compatibility handling for all external users that are setting this option, which need to be able to set the option in this way at least until after the 15.0.0 release.

What would you think about erroring out if someone is still passing LIBCXX_STATICALLY_LINK_ABI_IN_{SHARED|STATIC}_LIBRARY? Sure, we can try to support both for a while, but I wonder whether there's any actual benefit to balance the added complexity. Concretely, I suspect this impacts very few people, and the fix is really simple. And if we error out during the CMake step, we don't risk breaking anyone silently.

I guess that's better than silently (well, cmake warns, but it's easy to miss) no longer doing what it used to, but it's not ideal IMO. I do my continuous build testing with a build invocation that also works for the latest release - but with the suggested transition, there's no single build invocation that works for both the main branch and the 14.x release. I guess I could manage though, but I'd prefer a smoother upgrade path.

[ldionne]

In D125683#3516911, @mstorsjo wrote:

I guess that's better than silently (well, cmake warns, but it's easy to miss) no longer doing what it used to, but it's not ideal IMO. I do my continuous build testing with a build invocation that also works for the latest release - but with the suggested transition, there's no single build invocation that works for both the main branch and the 14.x release. I guess I could manage though, but I'd prefer a smoother upgrade path.

Understood. I'll make sure it is backwards compatible.

[ldionne]

Don't remove the old options yet for backwards compatibility.

[ldionne]

clang/cmake/caches/Fuchsia-stage2.cmake

126

Note that I am removing these options here because I don't think they are required -- since we specify LIBCXXABI_ENABLE_SHARED=OFF, there is no shared libc++abi to link against, so we should already be linking against libc++abi.a regardless of this change.

[phosek]

clang/cmake/caches/Fuchsia-stage2.cmake

126

This option was set to merge libc++abi.a into libc++.a so to achieve the same effect, presumably we would need to set -DLIBCXX_CXX_ABI=libcxxabi-objects?

[mstorsjo]

libcxx/cmake/caches/MinGW.cmake

3

Unfortunately, setting LIBCXX_CXX_ABI=libcxxabi-objects here in the cache file doesn't have any effect, because the run-buildbot script invokes cmake with a different parameter:

function generate-cmake() {
    generate-cmake-base \
          -DLLVM_ENABLE_RUNTIMES="libcxx;libcxxabi;libunwind" \
          -DLIBCXX_CXX_ABI=libcxxabi \
          "${@}"
}

A cmake parameter explicitly set on the command line always overrides what's set in a cache file.

libcxxabi/CMakeLists.txt

254 ↗

(On Diff #430051)

The fallback handling (checking LIBCXX_ENABLE_STATIC_ABI_LIBRARY, updating LIBCXX_CXX_ABI based on that) in libcxx doesn't have any effect here, since libcxxabi is processed strictly before libcxx, so here we only see the original values of the options.

However, luckily enough, I've posted D125715 a couple days ago, which lets us get rid of this whole problematic piece of code altogether (together with fixing a couple other issues), now that we have object libraries in palce!

llvm/docs/HowToBuildWindowsItaniumPrograms.rst

159

If the example instructions used to say LIBCXX_ENABLE_STATIC_ABI_LIBRARY=ON before, you should update the LIBCXX_CXX_ABI setting here to libcxxabi-objects too.

[ldionne]

Address some comments (but not @phosek's yet).

[ldionne]

clang/cmake/caches/Fuchsia-stage2.cmake

126

I agree this is suspicious, but why is there no LIBCXX_STATICALLY_LINK_ABI_IN_SHARED_LIBRARY specified here then? I can add -DLIBCXX_CXX_ABI=libcxxabi-objects, I just want to make sure we both understand what's going on.

libcxx/cmake/caches/MinGW.cmake

3

I actually don't see why we need to specify the ABI library to use by libc++ manually there, so I'll remove it. It should be just the same for all the CI bots we have anyways, but if we did introduce a CI configuration where we don't want to use libc++abi as our ABI library from libc++, it would make sense not to overwrite it. We are testing the libc++abi code base separately regardless of that setting anyway.

libcxxabi/CMakeLists.txt

254 ↗

(On Diff #430051)

Awesome, thanks! This should go away when I rebase, then.

llvm/docs/HowToBuildWindowsItaniumPrograms.rst

159

Ugh, good catch, thanks. Not sure why I didn't do it that way in the first place.

[phosek]

clang/cmake/caches/Fuchsia-stage2.cmake

126

This is intentional. We are merging libc++abi.a into libc++.a but we ship libc++abi.so and libc++.so as separate (and use the generated linker script to pull in libc++abi.so when you pass -lc++ to linker). I'd be fine merging libc++abi.so into libc++.so as well, but we'll need to figure out a transition plan since there are several places in our build right now that expect libc++abi.so to exist. We cannot land this change as is because that would break the -static-libstdc++ use case, since Clang driver only passes -lc++ to the linker and not -lc++abi and there's nothing that would pull libc++abi.a in.

[ldionne]

clang/cmake/caches/Fuchsia-stage2.cmake

126

I see, so to summarize, basically you want to use libcxxabi-objects for the static libc++.a, but libcxxabi for the dynamic libc++.so. This change as currently laid out does not permit that to happen, since libcxxabi-objects implies that the objects are merged both in the static and in the shared library. I guess we could introduce a new libcxxabi-objects-static option, however that would be kind of strange. We can either do that, or wait for you to stop relying on libc++abi.so existing and switch to libcxxabi-objects wholesale for Fuchsia. WDYT?

[ldionne]

clang/cmake/caches/Fuchsia-stage2.cmake

126

Gentle ping. It would be nice to land this in one form or another. If you don't think Fuchsia can stop relying on libc++abi.so being there, I could add yet another libcxxabi-objects-static -- I still feel like that's better than the status quo.

[ldionne]

Rebase onto main.

[phosek]

clang/cmake/caches/Fuchsia-stage2.cmake

126

We discussed this on our team and we don't have any issues switching towards combined libc++.so, we just need to figure out a transition plan. Let me test this change locally to see if landing this as is will break anything.

[ldionne]

clang/cmake/caches/Fuchsia-stage2.cmake

126

Gentle ping -- did you get any time to investigate this?

[phosek]

clang/cmake/caches/Fuchsia-stage2.cmake

126

I did and we are currently hitting a failure related to our libunwind usage. I have created D127528 which should address it.

[ldionne]

clang/cmake/caches/Fuchsia-stage2.cmake

126

Thanks! Since this has been landed, does it mean we can move forward with this patch?

[phosek]

LGTM

clang/cmake/caches/Fuchsia-stage2.cmake

124

Would it be possible to add set(RUNTIMES_${target}_LIBCXX_CXX_ABI "libcxxabi-objects" CACHE STRING "") here?

193–194

Would it be possible to add set(RUNTIMES_${target}_LIBCXX_CXX_ABI "libcxxabi-objects" CACHE STRING "") here?

[ldionne]

Rebase and address review comments.

[nikic]

I have some concerns about this change:

• It makes it fundamentally impossible to link against a static system-libcxxabi (or any other LIBCXX_CXX_ABI option). This is currently already broken (https://github.com/llvm/llvm-project/issues/57759), but used to work prior to LLVM 15.
• It makes it fundamentally impossible to use a linker script for the shared library while linking the abi library into the static library. I think this currently doesn't work either, but would be trivial to support. (I was going to work on this when I found this revision.)

I think both of these points highlight that LIBCXX_CXX_ABI=libcxxabi-objects is not the correct representation for this functionality.

[ldionne]

In D125683#3811492, @nikic wrote:

I have some concerns about this change:

• It makes it fundamentally impossible to link against a static system-libcxxabi (or any other LIBCXX_CXX_ABI option). This is currently already broken (https://github.com/llvm/llvm-project/issues/57759), but used to work prior to LLVM 15.
• It makes it fundamentally impossible to use a linker script for the shared library while linking the abi library into the static library. I think this currently doesn't work either, but would be trivial to support. (I was going to work on this when I found this revision.)

I think both of these points highlight that LIBCXX_CXX_ABI=libcxxabi-objects is not the correct representation for this functionality.

I don't think these limitations are an inherent property of this approach. What I'm trying to do with this change is eliminate these boolean flags that control how we build the library to instead use a more open-ended selection mechanism that is more flexible, more expressive, and which reduces the need for if(....) within the build.

I think the fundamental problem we have is that the ABI library for the static libc++ and for the shared libc++ are selected in one go. If we could instead specify the choice of the ABI library for each independently (for example -DLIBCXX_CXX_SHARED_ABI=libcxxabi -DLIBCXX_CXX_STATIC_ABI=system-libcxxabi), would that solve your problem? Also, this would actually increase the flexibility of the current build by a significant margin without much complexity on the libc++ CMake side.

[nikic]

In D125683#3815348, @ldionne wrote:

In D125683#3811492, @nikic wrote:

I have some concerns about this change:

• It makes it fundamentally impossible to link against a static system-libcxxabi (or any other LIBCXX_CXX_ABI option). This is currently already broken (https://github.com/llvm/llvm-project/issues/57759), but used to work prior to LLVM 15.
• It makes it fundamentally impossible to use a linker script for the shared library while linking the abi library into the static library. I think this currently doesn't work either, but would be trivial to support. (I was going to work on this when I found this revision.)

I think both of these points highlight that LIBCXX_CXX_ABI=libcxxabi-objects is not the correct representation for this functionality.

I don't think these limitations are an inherent property of this approach. What I'm trying to do with this change is eliminate these boolean flags that control how we build the library to instead use a more open-ended selection mechanism that is more flexible, more expressive, and which reduces the need for if(....) within the build.

I think the fundamental problem we have is that the ABI library for the static libc++ and for the shared libc++ are selected in one go. If we could instead specify the choice of the ABI library for each independently (for example -DLIBCXX_CXX_SHARED_ABI=libcxxabi -DLIBCXX_CXX_STATIC_ABI=system-libcxxabi), would that solve your problem? Also, this would actually increase the flexibility of the current build by a significant margin without much complexity on the libc++ CMake side.

This would indeed address the second point, but not the first. For that, one would have to add additional variations like system-libcxxabi-objects, which would end up increasing the possible abi choices by a factor of two (unless static linking doesn't make sense for some of them).

clang/cmake/caches/Android.cmake

 set(LLVM_TOOL_CLANG_TOOLS_EXTRA_BUILD OFF CACHE BOOL "")
 set(LLVM_TOOL_OPENMP_BUILD OFF CACHE BOOL "")
 set(LLVM_ENABLE_LIBCXX ON CACHE BOOL "")
 
 if (LIBCXX_ENABLE_ABI_LINKER_SCRIPT)
   list(APPEND EXTRA_ARGS -DLIBCXX_ENABLE_ABI_LINKER_SCRIPT=${LIBCXX_ENABLE_ABI_LINKER_SCRIPT})
 endif()
 
-if (LIBCXX_ENABLE_STATIC_ABI_LIBRARY)
-  list(APPEND EXTRA_ARGS -DLIBCXX_ENABLE_STATIC_ABI_LIBRARY=${LIBCXX_ENABLE_STATIC_ABI_LIBRARY})
-endif()
-
 if (LLVM_BUILD_EXTERNAL_COMPILER_RT)
   set(APPEND EXTRA_ARGS -DLLVM_BUILD_EXTERNAL_COMPILER_RT=${LLVM_BUILD_EXTERNAL_COMPILER_RT})
 endif()
 
 get_cmake_property(variableNames VARIABLES)
 foreach(variableName ${variableNames})
   if(variableName MATCHES "^STAGE2_")
     string(REPLACE "STAGE2_" "" new_name ${variableName})
     list(APPEND EXTRA_ARGS "-D${new_name}=${${variableName}}")
   endif()
 endforeach()
 
 set(CLANG_ENABLE_BOOTSTRAP ON CACHE BOOL "")
 set(CLANG_BOOTSTRAP_CMAKE_ARGS
   ${EXTRA_ARGS}
   -C${CMAKE_CURRENT_LIST_DIR}/Android-stage2.cmake CACHE STRING "")

clang/cmake/caches/Fuchsia-stage2.cmake

if(APPLE)
   set(LIBUNWIND_USE_COMPILER_RT ON CACHE BOOL "")
   set(LIBCXXABI_ENABLE_SHARED OFF CACHE BOOL "")
   set(LIBCXXABI_ENABLE_STATIC_UNWINDER ON CACHE BOOL "")
   set(LIBCXXABI_INSTALL_LIBRARY OFF CACHE BOOL "")
   set(LIBCXXABI_USE_COMPILER_RT ON CACHE BOOL "")
   set(LIBCXXABI_USE_LLVM_UNWINDER ON CACHE BOOL "")
   set(LIBCXX_ABI_VERSION 2 CACHE STRING "")
   set(LIBCXX_ENABLE_SHARED OFF CACHE BOOL "")
-  set(LIBCXX_ENABLE_STATIC_ABI_LIBRARY ON CACHE BOOL "")
   set(LIBCXX_USE_COMPILER_RT ON CACHE BOOL "")
   set(RUNTIMES_CMAKE_ARGS "-DCMAKE_OSX_DEPLOYMENT_TARGET=10.13;-DCMAKE_OSX_ARCHITECTURES=arm64|x86_64" CACHE STRING "")
 endif()
 
 if(WIN32)
   set(target "x86_64-pc-windows-msvc")
 
   list(APPEND BUILTIN_TARGETS "${target}")
if(LINUX_${target}_SYSROOT)
     set(RUNTIMES_${target}_COMPILER_RT_CAN_EXECUTE_TESTS ON CACHE BOOL "")
     set(RUNTIMES_${target}_LIBUNWIND_ENABLE_SHARED OFF CACHE BOOL "")
     set(RUNTIMES_${target}_LIBUNWIND_USE_COMPILER_RT ON CACHE BOOL "")
     set(RUNTIMES_${target}_LIBCXXABI_USE_COMPILER_RT ON CACHE BOOL "")
     set(RUNTIMES_${target}_LIBCXXABI_ENABLE_SHARED OFF CACHE BOOL "")
     set(RUNTIMES_${target}_LIBCXXABI_USE_LLVM_UNWINDER ON CACHE BOOL "")
     set(RUNTIMES_${target}_LIBCXXABI_ENABLE_STATIC_UNWINDER ON CACHE BOOL "")
     set(RUNTIMES_${target}_LIBCXXABI_INSTALL_LIBRARY OFF CACHE BOOL "")
+    set(RUNTIMES_${target}_LIBCXX_CXX_ABI "libcxxabi-objects" CACHE STRING "")
     set(RUNTIMES_${target}_LIBCXX_USE_COMPILER_RT ON CACHE BOOL "")
     set(RUNTIMES_${target}_LIBCXX_ENABLE_SHARED OFF CACHE BOOL "")
-    set(RUNTIMES_${target}_LIBCXX_ENABLE_STATIC_ABI_LIBRARY ON CACHE BOOL "")
     set(RUNTIMES_${target}_LIBCXX_ABI_VERSION 2 CACHE STRING "")
     set(RUNTIMES_${target}_LLVM_ENABLE_ASSERTIONS OFF CACHE BOOL "")
     set(RUNTIMES_${target}_SANITIZER_CXX_ABI "libc++" CACHE STRING "")
     set(RUNTIMES_${target}_SANITIZER_CXX_ABI_INTREE ON CACHE BOOL "")
     set(RUNTIMES_${target}_SANITIZER_TEST_CXX "libc++" CACHE STRING "")
     set(RUNTIMES_${target}_SANITIZER_TEST_CXX_INTREE ON CACHE BOOL "")
     set(RUNTIMES_${target}_COMPILER_RT_TEST_COMPILER_CFLAGS "--unwindlib=libunwind -static-libgcc" CACHE STRING "")
     set(RUNTIMES_${target}_SANITIZER_COMMON_TEST_TARGET_CFLAGS "--unwindlib=libunwind -static-libgcc" CACHE STRING "")
foreach(target x86_64-unknown-fuchsia;aarch64-unknown-fuchsia)
     set(RUNTIMES_${target}_LIBUNWIND_HIDE_SYMBOLS ON CACHE BOOL "")
     set(RUNTIMES_${target}_LIBUNWIND_INSTALL_STATIC_LIBRARY OFF CACHE BOOL "")
     set(RUNTIMES_${target}_LIBCXXABI_USE_COMPILER_RT ON CACHE BOOL "")
     set(RUNTIMES_${target}_LIBCXXABI_USE_LLVM_UNWINDER ON CACHE BOOL "")
     set(RUNTIMES_${target}_LIBCXXABI_ENABLE_STATIC_UNWINDER ON CACHE BOOL "")
     set(RUNTIMES_${target}_LIBCXXABI_HERMETIC_STATIC_LIBRARY ON CACHE BOOL "")
     set(RUNTIMES_${target}_LIBCXXABI_INSTALL_STATIC_LIBRARY OFF CACHE BOOL "")
     set(RUNTIMES_${target}_LIBCXXABI_STATICALLY_LINK_UNWINDER_IN_SHARED_LIBRARY OFF CACHE BOOL "")
+    set(RUNTIMES_${target}_LIBCXX_CXX_ABI "libcxxabi-objects" CACHE STRING "")
     set(RUNTIMES_${target}_LIBCXX_USE_COMPILER_RT ON CACHE BOOL "")
-    set(RUNTIMES_${target}_LIBCXX_ENABLE_STATIC_ABI_LIBRARY ON CACHE BOOL "")
     set(RUNTIMES_${target}_LIBCXX_HERMETIC_STATIC_LIBRARY ON CACHE BOOL "")
-    set(RUNTIMES_${target}_LIBCXX_STATICALLY_LINK_ABI_IN_SHARED_LIBRARY OFF CACHE BOOL "")
     set(RUNTIMES_${target}_LIBCXX_ABI_VERSION 2 CACHE STRING "")
     set(RUNTIMES_${target}_LLVM_ENABLE_ASSERTIONS OFF CACHE BOOL "")
     set(RUNTIMES_${target}_LLVM_ENABLE_RUNTIMES "compiler-rt;libcxx;libcxxabi;libunwind" CACHE STRING "")
 
     # Compat multilibs.
     set(RUNTIMES_${target}+compat_LLVM_BUILD_COMPILER_RT OFF CACHE BOOL "")
     set(RUNTIMES_${target}+compat_LIBCXXABI_ENABLE_EXCEPTIONS OFF CACHE BOOL "")
     set(RUNTIMES_${target}+compat_LIBCXX_ENABLE_EXCEPTIONS OFF CACHE BOOL "")

clang/cmake/caches/Fuchsia.cmake

else()
   set(LIBUNWIND_USE_COMPILER_RT ON CACHE BOOL "")
   set(LIBCXXABI_ENABLE_SHARED OFF CACHE BOOL "")
   set(LIBCXXABI_ENABLE_STATIC_UNWINDER ON CACHE BOOL "")
   set(LIBCXXABI_INSTALL_LIBRARY OFF CACHE BOOL "")
   set(LIBCXXABI_USE_COMPILER_RT ON CACHE BOOL "")
   set(LIBCXXABI_USE_LLVM_UNWINDER ON CACHE BOOL "")
   set(LIBCXX_ABI_VERSION 2 CACHE STRING "")
   set(LIBCXX_ENABLE_SHARED OFF CACHE BOOL "")
-  set(LIBCXX_ENABLE_STATIC_ABI_LIBRARY ON CACHE BOOL "")
   set(LIBCXX_USE_COMPILER_RT ON CACHE BOOL "")
   set(LLVM_ENABLE_RUNTIMES "compiler-rt;libcxx;libcxxabi;libunwind" CACHE STRING "")
   set(RUNTIMES_CMAKE_ARGS "-DCMAKE_OSX_DEPLOYMENT_TARGET=10.13;-DCMAKE_OSX_ARCHITECTURES=arm64|x86_64" CACHE STRING "")
 endif()
 
 if(BOOTSTRAP_CMAKE_SYSTEM_NAME)
   set(target "${BOOTSTRAP_CMAKE_CXX_COMPILER_TARGET}")
   if(STAGE2_LINUX_${target}_SYSROOT)
if(STAGE2_LINUX_${target}_SYSROOT)
     set(RUNTIMES_${target}_LIBUNWIND_INSTALL_LIBRARY OFF CACHE BOOL "")
     set(RUNTIMES_${target}_LIBCXXABI_USE_COMPILER_RT ON CACHE BOOL "")
     set(RUNTIMES_${target}_LIBCXXABI_ENABLE_SHARED OFF CACHE BOOL "")
     set(RUNTIMES_${target}_LIBCXXABI_USE_LLVM_UNWINDER ON CACHE BOOL "")
     set(RUNTIMES_${target}_LIBCXXABI_ENABLE_STATIC_UNWINDER ON CACHE BOOL "")
     set(RUNTIMES_${target}_LIBCXXABI_INSTALL_LIBRARY OFF CACHE BOOL "")
     set(RUNTIMES_${target}_LIBCXX_USE_COMPILER_RT ON CACHE BOOL "")
     set(RUNTIMES_${target}_LIBCXX_ENABLE_SHARED OFF CACHE BOOL "")
-    set(RUNTIMES_${target}_LIBCXX_ENABLE_STATIC_ABI_LIBRARY ON CACHE BOOL "")
     set(RUNTIMES_${target}_LIBCXX_ABI_VERSION 2 CACHE STRING "")
     set(RUNTIMES_${target}_LLVM_ENABLE_ASSERTIONS OFF CACHE BOOL "")
     set(RUNTIMES_${target}_LLVM_ENABLE_RUNTIMES "compiler-rt;libcxx;libcxxabi;libunwind" CACHE STRING "")
     set(RUNTIMES_${target}_SANITIZER_CXX_ABI "libc++" CACHE STRING "")
     set(RUNTIMES_${target}_SANITIZER_CXX_ABI_INTREE ON CACHE BOOL "")
   endif()
 endif()
 

compiler-rt/cmake/Modules/AddCompilerRT.cmake

CMAKE_ARGS ${CMAKE_PASSTHROUGH_VARIABLES}
                -DLIBCXXABI_HERMETIC_STATIC_LIBRARY=ON
                -DLIBCXXABI_INCLUDE_TESTS=OFF
                -DLIBCXX_CXX_ABI=libcxxabi
                -DLIBCXX_ENABLE_EXPERIMENTAL_LIBRARY=OFF
                -DLIBCXX_ENABLE_SHARED=OFF
                -DLIBCXX_HERMETIC_STATIC_LIBRARY=ON
                -DLIBCXX_INCLUDE_BENCHMARKS=OFF
                -DLIBCXX_INCLUDE_TESTS=OFF
-               -DLIBCXX_ENABLE_STATIC_ABI_LIBRARY=ON
                ${LIBCXX_CMAKE_ARGS}
     INSTALL_COMMAND ""
     STEP_TARGETS configure build
     BUILD_ALWAYS 1
     USES_TERMINAL_CONFIGURE 1
     USES_TERMINAL_BUILD 1
     USES_TERMINAL_INSTALL 1
     LIST_SEPARATOR |

libcxx/CMakeLists.txt

 if (LIBCXX_TARGETING_MSVC)
   set(LIBCXX_DEFAULT_ABI_LIBRARY "vcruntime")
 elseif (${CMAKE_SYSTEM_NAME} MATCHES "FreeBSD")
   set(LIBCXX_DEFAULT_ABI_LIBRARY "libcxxrt")
 else()
   set(LIBCXX_DEFAULT_ABI_LIBRARY "libcxxabi")
 endif()
 
-set(LIBCXX_SUPPORTED_ABI_LIBRARIES none libcxxabi system-libcxxabi libcxxrt libstdc++ libsupc++ vcruntime)
+set(LIBCXX_SUPPORTED_ABI_LIBRARIES none libcxxabi libcxxabi-objects system-libcxxabi libcxxrt libstdc++ libsupc++ vcruntime)
 set(LIBCXX_CXX_ABI "${LIBCXX_DEFAULT_ABI_LIBRARY}" CACHE STRING "Specify C++ ABI library to use. Supported values are ${LIBCXX_SUPPORTED_ABI_LIBRARIES}.")
 if (NOT "${LIBCXX_CXX_ABI}" IN_LIST LIBCXX_SUPPORTED_ABI_LIBRARIES)
   message(FATAL_ERROR "Unsupported C++ ABI library: '${LIBCXX_CXX_ABI}'. Supported values are ${LIBCXX_SUPPORTED_ABI_LIBRARIES}.")
 endif()
 
+# TODO: Remove these options once we ship LLVM 15.
 option(LIBCXX_ENABLE_STATIC_ABI_LIBRARY
   "Use a static copy of the ABI library when linking libc++.
    This option cannot be used with LIBCXX_ENABLE_ABI_LINKER_SCRIPT." OFF)
 
 cmake_dependent_option(LIBCXX_STATICALLY_LINK_ABI_IN_STATIC_LIBRARY
   "Statically link the ABI library to static library" ON
   "LIBCXX_ENABLE_STATIC_ABI_LIBRARY" OFF)
 
 cmake_dependent_option(LIBCXX_STATICALLY_LINK_ABI_IN_SHARED_LIBRARY
   "Statically link the ABI library to shared library" ON
   "LIBCXX_ENABLE_STATIC_ABI_LIBRARY" OFF)
 
+if (LIBCXX_ENABLE_STATIC_ABI_LIBRARY OR LIBCXX_STATICALLY_LINK_ABI_IN_STATIC_LIBRARY OR LIBCXX_STATICALLY_LINK_ABI_IN_SHARED_LIBRARY)
+  message(WARNING "The LIBCXX_ENABLE_STATIC_ABI_LIBRARY, LIBCXX_STATICALLY_LINK_ABI_IN_STATIC_LIBRARY and "
+                  "LIBCXX_STATICALLY_LINK_ABI_IN_SHARED_LIBRARY options have been deprecated in favor of "
+                  "using LIBCXX_CXX_ABI=libcxxabi-objects. This will become an error in LLVM 16.")
+  set(LIBCXX_CXX_ABI "libcxxabi-objects" CACHE STRING "" FORCE)
+endif()
+
 # Generate and install a linker script inplace of libc++.so. The linker script
 # will link libc++ to the correct ABI library. This option is on by default
-# on UNIX platforms other than Apple unless 'LIBCXX_ENABLE_STATIC_ABI_LIBRARY'
-# is on. This option is also disabled when the ABI library is not specified
-# or is specified to be "none".
+# on UNIX platforms other than Apple unless we are linking the ABI library as
+# an object library. This option is also disabled when the ABI library is not
+# specified or is specified to be "none".
 set(ENABLE_LINKER_SCRIPT_DEFAULT_VALUE OFF)
-if (LLVM_HAVE_LINK_VERSION_SCRIPT AND NOT LIBCXX_STATICALLY_LINK_ABI_IN_SHARED_LIBRARY
+if (LLVM_HAVE_LINK_VERSION_SCRIPT
+      AND NOT LIBCXX_CXX_ABI STREQUAL "libcxxabi-objects"
       AND NOT LIBCXX_CXX_ABI STREQUAL "none"
       AND Python3_EXECUTABLE
       AND LIBCXX_ENABLE_SHARED)
     set(ENABLE_LINKER_SCRIPT_DEFAULT_VALUE ON)
 endif()
 
 option(LIBCXX_ENABLE_ABI_LINKER_SCRIPT
       "Use and install a linker script for the given ABI library"

 endif()
 
 # Ensure LLVM_USE_SANITIZER is not specified when LIBCXX_GENERATE_COVERAGE
 # is ON.
 if (LLVM_USE_SANITIZER AND LIBCXX_GENERATE_COVERAGE)
   message(FATAL_ERROR "LLVM_USE_SANITIZER cannot be used with LIBCXX_GENERATE_COVERAGE")
 endif()
 
-# Warn users that LIBCXX_ENABLE_STATIC_ABI_LIBRARY is an experimental option.
-if (LIBCXX_ENABLE_STATIC_ABI_LIBRARY)
-  message(WARNING "LIBCXX_ENABLE_STATIC_ABI_LIBRARY is an experimental option")
-  if (LIBCXX_ENABLE_STATIC AND NOT Python3_EXECUTABLE)
-    message(FATAL_ERROR "LIBCXX_ENABLE_STATIC_ABI_LIBRARY requires python but it was not found.")
-  endif()
-endif()
-
 if (LIBCXX_ENABLE_ABI_LINKER_SCRIPT)
     if (APPLE)
       message(FATAL_ERROR "LIBCXX_ENABLE_ABI_LINKER_SCRIPT cannot be used on APPLE targets")
     endif()
     if (NOT LIBCXX_ENABLE_SHARED)
       message(FATAL_ERROR "LIBCXX_ENABLE_ABI_LINKER_SCRIPT is only available for shared library builds.")
     endif()
 endif()
 
-if (LIBCXX_STATICALLY_LINK_ABI_IN_SHARED_LIBRARY AND LIBCXX_ENABLE_ABI_LINKER_SCRIPT)
+if (LIBCXX_CXX_ABI STREQUAL "libcxxabi-objects" AND LIBCXX_ENABLE_ABI_LINKER_SCRIPT)
     message(FATAL_ERROR "Conflicting options given.
-        LIBCXX_ENABLE_STATIC_ABI_LIBRARY cannot be specified with
-        LIBCXX_ENABLE_ABI_LINKER_SCRIPT")
+        LIBCXX_CXX_ABI=libcxxabi-objects cannot be specified with LIBCXX_ENABLE_ABI_LINKER_SCRIPT")
 endif()
 
 if (LIBCXX_ABI_FORCE_ITANIUM AND LIBCXX_ABI_FORCE_MICROSOFT)
   message(FATAL_ERROR "Only one of LIBCXX_ABI_FORCE_ITANIUM and LIBCXX_ABI_FORCE_MICROSOFT can be specified.")
 endif ()
 
 #===============================================================================
 # Configure System

 # By default libc++ on Windows expects to use a shared library, which requires
 # the headers to use DLL import/export semantics. However when building a
 # static library only we modify the headers to disable DLL import/export.
 if (DEFINED WIN32 AND LIBCXX_ENABLE_STATIC AND NOT LIBCXX_ENABLE_SHARED)
   message(STATUS "Generating custom __config for non-DLL Windows build")
   config_define(ON _LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS)
 endif()
 
-if (WIN32 AND LIBCXX_ENABLE_STATIC_ABI_LIBRARY)
+if (WIN32 AND LIBCXX_CXX_ABI STREQUAL "libcxxabi-objects")
   # If linking libcxxabi statically into libcxx, skip the dllimport attributes
   # on symbols we refer to from libcxxabi.
   add_definitions(-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS)
 endif()
 
 # Setup all common build flags =================================================
 function(cxx_add_common_build_flags target)
   cxx_add_basic_build_flags(${target})

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()
+# Link against the in-tree libc++abi objects, i.e. include libc++abi's object files directly
+# into the library that links against it.
+elseif ("${LIBCXX_CXX_ABI}" STREQUAL "libcxxabi-objects")
+  add_library(libcxx-abi-headers INTERFACE)
+  target_link_libraries(libcxx-abi-headers INTERFACE cxxabi-headers)
+  target_compile_definitions(libcxx-abi-headers INTERFACE "-DLIBCXX_BUILDING_LIBCXXABI")
 
-  if (TARGET cxxabi_static_objects)
-    add_library(libcxx-abi-static-objects ALIAS cxxabi_static_objects)
-  endif()
+  add_library(libcxx-abi-shared ALIAS cxxabi_shared_objects)
+  add_library(libcxx-abi-static ALIAS cxxabi_static_objects)
 
 # 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)

libcxx/cmake/caches/MinGW.cmake

 set(LIBCXX_ENABLE_EXPERIMENTAL_LIBRARY OFF CACHE BOOL "")
 
-set(LIBCXX_CXX_ABI libcxxabi CACHE STRING "")
+set(LIBCXX_CXX_ABI libcxxabi-objects CACHE STRING "")
 set(LIBCXXABI_USE_LLVM_UNWINDER ON CACHE BOOL "")
 
 set(LIBCXXABI_ENABLE_SHARED OFF CACHE BOOL "")
-set(LIBCXX_ENABLE_STATIC_ABI_LIBRARY ON CACHE BOOL "")
 
 set(LIBCXX_USE_COMPILER_RT ON CACHE BOOL "")
 set(LIBCXXABI_USE_COMPILER_RT ON CACHE BOOL "")
 set(LIBUNWIND_USE_COMPILER_RT ON CACHE BOOL "")
 
 set(LIBCXX_TARGET_INFO "libcxx.test.target_info.MingwLocalTI" CACHE STRING "")
 
 # Without this flag, 'long double' (which is 80 bit on x86 mingw, but
 # 64 bit in MSVC) isn't handled correctly in printf.
 set(LIBCXX_EXTRA_SITE_DEFINES "__USE_MINGW_ANSI_STDIO=1" CACHE STRING "")

libcxx/docs/BuildingLibcxx.rst

 
 .. _ABI Library Specific Options:
 
 ABI Library Specific Options
 ----------------------------
 
 .. option:: LIBCXX_CXX_ABI:STRING
 
-  **Values**: ``none``, ``libcxxabi``, ``system-libcxxabi``, ``libcxxrt``, ``libstdc++``, ``libsupc++``, ``vcruntime``.
+  **Values**: ``none``, ``libcxxabi``, ``libcxxabi-objects``, ``system-libcxxabi``, ``libcxxrt``, ``libstdc++``, ``libsupc++``, ``vcruntime``.
 
   Select the ABI library to build libc++ against.
 
 .. option:: LIBCXX_CXX_ABI_INCLUDE_PATHS:PATHS
 
   Provide additional search paths for the ABI library headers.
 
 .. option:: LIBCXX_CXX_ABI_LIBRARY_PATH:PATH
 
   Provide the path to the ABI library that libc++ should link against. This is only
   useful when linking against an out-of-tree ABI library.
 
-.. option:: LIBCXX_ENABLE_STATIC_ABI_LIBRARY:BOOL
-
-  **Default**: ``OFF``
-
-  If this option is enabled, libc++ will try and link the selected ABI library
-  statically.
-
 .. option:: LIBCXX_ENABLE_ABI_LINKER_SCRIPT:BOOL
 
   **Default**: ``ON`` by default on UNIX platforms other than Apple unless
-  'LIBCXX_ENABLE_STATIC_ABI_LIBRARY' is ON. Otherwise the default value is ``OFF``.
+  using the ``libcxxabi-objects`` ABI library. Otherwise the default value is ``OFF``.
 
   This option generate and installs a linker script as ``libc++.so`` which
   links the correct ABI library.
 
 .. option:: LIBCXXABI_USE_LLVM_UNWINDER:BOOL
 
   **Default**: ``OFF``
 

libcxx/docs/ReleaseNotes.rst

 - The ``LIBCXX_ENABLE_DEBUG_MODE_SUPPORT`` CMake configuration is not supported anymore. If you
   were disabling support for the debug mode with that flag, please use ``LIBCXX_ENABLE_BACKWARDS_COMPATIBILITY_DEBUG_MODE_SYMBOLS=OFF``
   instead.
 
 - MinGW DLL builds of libc++ no longer use dllimport in their headers, which
   means that the same set of installed headers works for both DLL and static
   linkage. This means that distributors finally can build both library
   versions with a single CMake invocation.
+
+- The following CMake options to control how the ABI library is linked into libc++ have been deprecated:
+  ``LIBCXX_ENABLE_STATIC_ABI_LIBRARY``, ``LIBCXX_STATICALLY_LINK_ABI_IN_SHARED_LIBRARY``,
+  ``LIBCXX_STATICALLY_LINK_ABI_IN_STATIC_LIBRARY``. If you want to merge the objects of libc++abi into
+  libc++, please specify ``-DLIBCXX_CXX_ABI=libcxxabi-objects`` instead. These options will be
+  removed entirely in LLVM 16.

libcxx/src/CMakeLists.txt

 
 split_list(LIBCXX_COMPILE_FLAGS)
 split_list(LIBCXX_LINK_FLAGS)
 
 # Build the shared library.
 if (LIBCXX_ENABLE_SHARED)
   add_library(cxx_shared SHARED ${exclude_from_all} ${LIBCXX_SOURCES} ${LIBCXX_HEADERS})
   target_include_directories(cxx_shared PRIVATE ${CMAKE_CURRENT_SOURCE_DIR})
-  target_link_libraries(cxx_shared PUBLIC cxx-headers
+  target_link_libraries(cxx_shared PUBLIC cxx-headers libcxx-abi-shared
                                    PRIVATE ${LIBCXX_LIBRARIES})
   set_target_properties(cxx_shared
     PROPERTIES
       COMPILE_FLAGS "${LIBCXX_COMPILE_FLAGS}"
       LINK_FLAGS    "${LIBCXX_LINK_FLAGS}"
       OUTPUT_NAME   "c++"
       VERSION       "${LIBCXX_LIBRARY_VERSION}"
       SOVERSION     "${LIBCXX_ABI_VERSION}"
if (LIBCXXABI_STATICALLY_LINK_UNWINDER_IN_SHARED_LIBRARY)
       # libunwind is already included in libc++abi
     elseif (TARGET unwind_shared OR HAVE_LIBUNWIND)
       target_link_libraries(cxx_shared PUBLIC unwind_shared)
     else()
       target_link_libraries(cxx_shared PUBLIC unwind)
     endif()
   endif()
 
-  # Link against libc++abi
-  if (LIBCXX_STATICALLY_LINK_ABI_IN_SHARED_LIBRARY)
-    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"
-            AND NOT DEFINED LIBCXX_OSX_REEXPORT_LIBCXXABI_SYMBOLS
-            AND NOT LIBCXX_STATICALLY_LINK_ABI_IN_SHARED_LIBRARY)
+            AND NOT DEFINED LIBCXX_OSX_REEXPORT_LIBCXXABI_SYMBOLS)
     set(LIBCXX_OSX_REEXPORT_LIBCXXABI_SYMBOLS ON)
   endif()
 
   if (LIBCXX_OSX_REEXPORT_LIBCXXABI_SYMBOLS)
     target_link_libraries(cxx_shared PRIVATE
       "-Wl,-unexported_symbols_list,${CMAKE_CURRENT_SOURCE_DIR}/../lib/libc++unexp.exp"
       "-Wl,-reexported_symbols_list,${CMAKE_CURRENT_SOURCE_DIR}/../lib/libc++abi.exp"
       "-Wl,-force_symbols_not_weak_list,${CMAKE_CURRENT_SOURCE_DIR}/../lib/notweak.exp"
if (LIBCXX_HERMETIC_STATIC_LIBRARY)
     endif()
     target_compile_options(cxx_static PRIVATE ${CXX_STATIC_LIBRARY_FLAGS})
     # _LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS can be defined in __config_site
     # too. Define it in the same way here, to avoid redefinition conflicts.
     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)
-    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
     experimental/memory_resource.cpp

libcxx/test/CMakeLists.txt

 macro(pythonize_bool var)
   if (${var})
     set(${var} True)
   else()
     set(${var} False)
   endif()
 endmacro()
 
 set(LIBCXX_LIT_VARIANT "libcxx" CACHE STRING
     "Configuration variant to use for LIT.")
 
 set(LIBCXX_TEST_LINKER_FLAGS "" CACHE STRING
     "Additonal linker flags to pass when compiling the tests")
 set(LIBCXX_TEST_COMPILER_FLAGS "" CACHE STRING
     "Additonal linker flags to pass when compiling the tests")
 
-# The tests shouldn't link to any ABI library when it has been linked into
-# libc++ statically or via a linker script.
-if (LIBCXX_ENABLE_STATIC_ABI_LIBRARY OR LIBCXX_ENABLE_ABI_LINKER_SCRIPT)
-  set(LIBCXX_CXXABI_FOR_TESTS "none")
-else()
-  set(LIBCXX_CXXABI_FOR_TESTS "${LIBCXX_CXX_ABI}")
-endif()
-
 # The tests shouldn't link to libunwind if we have a linker script which
 # already does so.
 if (LIBCXX_ENABLE_ABI_LINKER_SCRIPT)
   set(LIBCXXABI_USE_LLVM_UNWINDER OFF)
 endif()
 
 # TODO: Clients using those options should switch to from-scratch Lit configuration files.
 option(LIBCXX_LINK_TESTS_WITH_SHARED_LIBCXXABI

libcxx/test/configs/legacy.cfg.in

 @AUTO_GEN_COMMENT@
 
 @SERIALIZED_LIT_PARAMS@
 
 import os
 import site
 
 config.cxx_headers              = "@LIBCXX_GENERATED_INCLUDE_DIR@"
 config.cxx_under_test           = "@CMAKE_CXX_COMPILER@"
 config.project_obj_root         = "@CMAKE_BINARY_DIR@"
 config.install_root             = "@CMAKE_BINARY_DIR@"
 config.libcxx_src_root          = "@LIBCXX_SOURCE_DIR@"
 config.libcxx_obj_root          = "@LIBCXX_BINARY_DIR@"
 config.cxx_library_root         = "@LIBCXX_LIBRARY_DIR@"
 config.abi_library_root         = "@LIBCXX_CXX_ABI_LIBRARY_PATH@"
 config.enable_shared            = @LIBCXX_LINK_TESTS_WITH_SHARED_LIBCXX@
-config.cxx_abi                  = "@LIBCXX_CXXABI_FOR_TESTS@"
+config.cxx_abi                  = "@LIBCXX_CXX_ABI@"
 config.configuration_variant    = "@LIBCXX_LIT_VARIANT@"
 config.host_triple              = "@LLVM_HOST_TRIPLE@"
 config.sysroot                  = "@CMAKE_SYSROOT@"
 config.gcc_toolchain            = "@CMAKE_CXX_COMPILER_EXTERNAL_TOOLCHAIN@"
 config.generate_coverage        = @LIBCXX_GENERATE_COVERAGE@
 config.target_info              = "@LIBCXX_TARGET_INFO@"
 config.test_linker_flags        = "@LIBCXX_TEST_LINKER_FLAGS@"
 config.test_compiler_flags      = "@LIBCXX_TEST_COMPILER_FLAGS@"

libcxx/utils/ci/run-buildbot

${CMAKE} \
           -DLIBUNWIND_ENABLE_WERROR=YES \
           -DLLVM_LIT_ARGS="-sv --show-unsupported --xunit-xml-output test-results.xml --timeout=1500 --time-tests" \
           "${@}"
 }
 
 function generate-cmake() {
     generate-cmake-base \
           -DLLVM_ENABLE_RUNTIMES="libcxx;libcxxabi;libunwind" \
-          -DLIBCXX_CXX_ABI=libcxxabi \
           "${@}"
 }
 
 function generate-cmake-libcxx-win() {
     # TODO: Clang-cl in MSVC configurations don't have access to compiler_rt
     # builtins helpers for int128 division. See
     # https://reviews.llvm.org/D91139#2429595 for a comment about longterm
     # intent for handling the issue. In the meantime, define
legacy-project-build)
     echo "--- Generating CMake"
     ${CMAKE} \
           -S "${MONOREPO_ROOT}/llvm" \
           -B "${BUILD_DIR}" \
           -DLLVM_ENABLE_PROJECTS="libcxx;libunwind;libcxxabi" \
           -GNinja -DCMAKE_MAKE_PROGRAM="${NINJA}" \
           -DCMAKE_BUILD_TYPE=RelWithDebInfo \
           -DCMAKE_INSTALL_PREFIX="${INSTALL_DIR}" \
-          -DLLVM_LIT_ARGS="-sv --show-unsupported --xunit-xml-output test-results.xml --timeout=1500" \
-          -DLIBCXX_CXX_ABI=libcxxabi
+          -DLLVM_LIT_ARGS="-sv --show-unsupported --xunit-xml-output test-results.xml --timeout=1500"
     check-runtimes
 ;;
 aarch64)
     clean
     generate-cmake -C "${MONOREPO_ROOT}/libcxx/cmake/caches/AArch64.cmake"
     check-runtimes
 ;;
 aarch64-noexceptions)

llvm/docs/HowToBuildWindowsItaniumPrograms.rst

 The CMake files will need to be edited to prevent them adding GNU specific libraries to the link line.
 
 Building libc++abi:
 -------------------
 
 * ``-DLIBCXXABI_ENABLE_SHARED=OFF``
 * ``-DLIBCXXABI_ENABLE_STATIC=ON``
 * ``-DLIBCXX_ENABLE_SHARED=ON'``
-* ``-DLIBCXX_ENABLE_STATIC_ABI_LIBRARY=ON``
 
 To break the symbol dependency between libc++abi and libc++ we
 build libc++abi as a static library and then statically link it
 into the libc++ DLL. This necessitates setting the CMake file
 to ensure that the visibility macros (which expand to dllexport/import)
 are expanded as they will be needed when creating the final libc++
 DLL later, see: https://reviews.llvm.org/D90021.
 

 * ``-DLIBCXX_USE_COMPILER_RT=OFF``
 
 We use the MS runtime.
 
 * ``-DLIBCXX_HAS_WIN32_THREAD_API=ON``
 
 Windows Itanium does not offer a POSIX-like layer over WIN32.
 
-* ``-DLIBCXX_ENABLE_STATIC_ABI_LIBRARY=ON``
-* ``-DLIBCXX_CXX_ABI=libcxxabi``
+* ``-DLIBCXX_CXX_ABI=libcxxabi-objects``
 * ``-DLIBCXX_CXX_ABI_INCLUDE_PATHS=<libcxxabi src path>/include``
 * ``-DLIBCXX_CXX_ABI_LIBRARY_PATH=<libcxxabi build path>/lib``
 
 Use the static libc++abi library built earlier.
 
 * ``-DLIBCXX_NO_VCRUNTIME=ON``
 
 Remove any dependency on the VC runtime - we need libc++abi to supply the C++ runtime.