maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity
llvm-project/libcxx/test/CMakeLists.txt

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

133 lines
4.7 KiB
CMake
Raw Normal View History

Add CMake build and fix major Linux blockers. llvm-svn: 121510
2010-12-11 03:47:54 +08:00
macro(pythonize_bool var)
if (${var})
set(${var} True)
else()
set(${var} False)
endif()
endmacro()
Reapply working parts of CMake cleanup. This patch adds the working parts of r243503. The difference with this patch is that it doesn't include the HandleLLVMOptions.cmake file. llvm-svn: 243698
2015-07-31 06:30:34 +08:00
set(LIBCXX_LIT_VARIANT "libcxx" CACHE STRING
"Configuration variant to use for LIT.")
Allow passing additional compiler/linker flags for the tests Summary: These flags can be specified using the CMake variables LIBCXX_TEST_LINKER_FLAGS and LIBCXX_TEST_COMPILER_FLAGS. When building the tests for CHERI I need to pass additional flags (such as -mabi=n64 or -mabi=purecap) to the compiler for our test configurations Reviewers: EricWF Reviewed By: EricWF Subscribers: christof, mgorny, cfe-commits Differential Revision: https://reviews.llvm.org/D42139 llvm-svn: 325914
2018-02-23 23:19:48 +08:00
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")
Fix linker script generation for in-tree builds llvm-svn: 283700
2016-10-10 05:34:03 +08:00
# 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_CXX_ABI_LIBNAME "none")
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()
Reapply working parts of CMake cleanup. This patch adds the working parts of r243503. The difference with this patch is that it doesn't include the HandleLLVMOptions.cmake file. llvm-svn: 243698
2015-07-31 06:30:34 +08:00
pythonize_bool(LIBCXX_ENABLE_EXCEPTIONS)
Create new library 'libc++experimental.a' for packaging TS symbols. Summary: Out-of-line symbols for <experimental/...> headers are not ABI or API stable and cannot live in the 'libc++.dylib'. Currently they have nowhere to live. I would like to add a new library target `libc++experimental.a` to fix this. Previously I had suggested different libraries for different TS's (`libc++filesystem.a`, 'libc++LFTS.a`, ect). I no longer think this is the right approach. Instead `c++experimental` will hold *all* TS implementations as a single monolithic library. I see two main benefits to this: 1. Users only have to know about and manually link one library. 2. It makes it easy to implement TS's with one or two out-of-line symbols. (Ex. PMRs) `c++experimental` provides NO ABI compatibility. Symbols can freely be added/removed/changed without concern for ABI stability. I will add documentation for this after landing this patch (but before adding anything to it). `c++experimental` only builds as a static library. By default CMake will build/test this library but will *NOT* install it. This patch adds the CMake and LIT logic needed to build/test the new library. Once this lands I plan on using it to implement parts of `<experimental/memory_resource>`. Reviewers: mclow.lists Subscribers: cfe-commits, theraven, krememek, dexonsmith, bcraig, beanz, danalbert Differential Revision: http://reviews.llvm.org/D19856 llvm-svn: 268443
2016-05-04 05:30:18 +08:00
pythonize_bool(LIBCXX_ENABLE_EXPERIMENTAL_LIBRARY)
Reapply working parts of CMake cleanup. This patch adds the working parts of r243503. The difference with this patch is that it doesn't include the HandleLLVMOptions.cmake file. llvm-svn: 243698
2015-07-31 06:30:34 +08:00
pythonize_bool(LIBCXX_ENABLE_RTTI)
pythonize_bool(LIBCXX_ENABLE_SHARED)
Allow disabling of filesystem library. Summary: Filesystem doesn't work on Windows, so we need a mechanism to turn it off for the time being. Reviewers: ldionne, serge-sans-paille, EricWF Reviewed By: EricWF Subscribers: mstorsjo, mgorny, christof, jdoerfert, libcxx-commits Differential Revision: https://reviews.llvm.org/D59619 llvm-svn: 356633
2019-03-21 08:04:31 +08:00
pythonize_bool(LIBCXX_ENABLE_FILESYSTEM)
Reapply working parts of CMake cleanup. This patch adds the working parts of r243503. The difference with this patch is that it doesn't include the HandleLLVMOptions.cmake file. llvm-svn: 243698
2015-07-31 06:30:34 +08:00
pythonize_bool(LIBCXX_BUILD_32_BITS)
pythonize_bool(LIBCXX_GENERATE_COVERAGE)
Framework to allow testing of static libc++abi These changes make linking against static libraries more explicit. Instead of using -lc++ and -lc++abi in the tests, an absolute path to the library is provided instead. The choices of shared vs. static, and the choices of library paths for both libcxx and libcxxabi needed to be exchanged for this to work. In other words, libcxx tests need to know the library path of libcxxabi, and whether libcxxabi is a static or shared library. Some Mac specific logic for testing against libc++abi had to be moved from libcxxabi's config.py, as it was overriding choices made in libcxx's config.py. That logic is now in libcxx's target_info.py. Testing a static libcxx on Linux will now automatically link in librt most of the time. Previously, lots of pthread tests would fail because of an unresolved clock_gettime. http://reviews.llvm.org/D16544 llvm-svn: 266730
2016-04-19 20:49:05 +08:00
pythonize_bool(LIBCXXABI_ENABLE_SHARED)
Reapply working parts of CMake cleanup. This patch adds the working parts of r243503. The difference with this patch is that it doesn't include the HandleLLVMOptions.cmake file. llvm-svn: 243698
2015-07-31 06:30:34 +08:00
pythonize_bool(LIBCXXABI_USE_LLVM_UNWINDER)
[libcxx] Support the use of compiler-rt in lit tests Don't link tests against libgcc when compiler-rt is being used. Differential Revision: https://reviews.llvm.org/D40513 llvm-svn: 322044
2018-01-09 07:36:53 +08:00
pythonize_bool(LIBCXX_USE_COMPILER_RT)
Re-commit "Introduce a cmake module to figure out whether we need to link with libatomic." This re-applies commit r260235. However, this time we add -gcc-toolchain to the compiler's flags when the user has specified the LIBCXX_GCC_TOOLCHAIN variable. llvm-svn: 260515
2016-02-11 20:43:04 +08:00
pythonize_bool(LIBCXX_HAS_ATOMIC_LIB)
Rework libatomic handling in CMake and LIT. This patch updates the way libc++ handles checking for libatomic, in part to prepare for https://reviews.llvm.org/D22073. Changes: * 'LIBCXX_HAS_ATOMIC_LIB' is now set whenever libatomic is available even libc++ doesn't need to manually link it. * 'LIBCXX_HAVE_CXX_ATOMICS_WITH_LIB' is now used to detect when libatomic needs to be manually linked. * 'LIBCXX_HAS_ATOMIC_LIB' now adds 'libatomic' as a available feature in the test suite. llvm-svn: 275759
2016-07-18 14:01:50 +08:00
pythonize_bool(LIBCXX_HAVE_CXX_ATOMICS_WITH_LIB)
[libc++] Cleanup and document <__threading_support> Summary: This patch attempts to clean up the macro configuration mess in `<__threading_support>`, specifically the mess involving external threading variants. Additionally this patch adds design documentation for `<__threading_support>` and the configuration macros it uses. The primary change in this patch is separating the idea of an "external API" provided by `<__external_threading>` and the idea of having an external threading library. Now `_LIBCPP_HAS_THREAD_API_EXTERNAL` means that libc++ should use `<__external_threading>` and that the header is expected to exist. Additionally the new macro `_LIBCPP_HAS_THREAD_LIBRARY_EXTERNAL` is now used to configure for using an "external library" with the default threading API. Reviewers: compnerd, rmaprath Subscribers: smeenai, cfe-commits, mgorny Differential Revision: https://reviews.llvm.org/D28316 llvm-svn: 291275
2017-01-07 04:05:40 +08:00
pythonize_bool(LIBCXX_BUILD_EXTERNAL_THREAD_LIBRARY)
[libc++][CMake] Use debug MSVC runtimes when libc++ is built in debug mode Summary: This patch allows libc++ to be built against the debug MSVC runtimes instead of just the release ones. Reviewers: rnk, majnemer, compnerd, smeenai Subscribers: mgorny, cfe-commits Differential Revision: https://reviews.llvm.org/D28725 llvm-svn: 292006
2017-01-14 15:54:39 +08:00
pythonize_bool(LIBCXX_DEBUG_BUILD)
[libc++] Take 2: Integrate the PSTL into libc++ Summary: This commit allows specifying LIBCXX_ENABLE_PARALLEL_ALGORITHMS when configuring libc++ in CMake. When that option is enabled, libc++ will assume that the PSTL can be found somewhere on the CMake module path, and it will provide the C++17 parallel algorithms based on the PSTL (that is assumed to be available). The commit also adds support for running the PSTL tests as part of the libc++ test suite. The first attempt to commit this failed because it exposed a bug in the tests for modules. Now that this has been fixed, it should be safe to commit this. Reviewers: EricWF Subscribers: mgorny, christof, jkorous, dexonsmith, libcxx-commits, mclow.lists, EricWF Tags: #libc Differential Revision: https://reviews.llvm.org/D60480 llvm-svn: 367903
2019-08-06 02:29:14 +08:00
pythonize_bool(LIBCXX_ENABLE_PARALLEL_ALGORITHMS)
Reapply working parts of CMake cleanup. This patch adds the working parts of r243503. The difference with this patch is that it doesn't include the HandleLLVMOptions.cmake file. llvm-svn: 243698
2015-07-31 06:30:34 +08:00
Framework to allow testing of static libc++abi These changes make linking against static libraries more explicit. Instead of using -lc++ and -lc++abi in the tests, an absolute path to the library is provided instead. The choices of shared vs. static, and the choices of library paths for both libcxx and libcxxabi needed to be exchanged for this to work. In other words, libcxx tests need to know the library path of libcxxabi, and whether libcxxabi is a static or shared library. Some Mac specific logic for testing against libc++abi had to be moved from libcxxabi's config.py, as it was overriding choices made in libcxx's config.py. That logic is now in libcxx's target_info.py. Testing a static libcxx on Linux will now automatically link in librt most of the time. Previously, lots of pthread tests would fail because of an unresolved clock_gettime. http://reviews.llvm.org/D16544 llvm-svn: 266730
2016-04-19 20:49:05 +08:00
# By default, for non-standalone builds, libcxx and libcxxabi share a library
# directory.
if (NOT LIBCXX_CXX_ABI_LIBRARY_PATH)
set(LIBCXX_CXX_ABI_LIBRARY_PATH "${LIBCXX_LIBRARY_DIR}" CACHE PATH
[libcxx] Force-cache LIBCXX_CXX_ABI_LIBRARY_PATH Summary: The `LIBCXX_CXX_ABI_LIBRARY_PATH` CMake variable is cached once in libcxx/cmake/Modules/HandleLibCXXABI.cmake in the `setup_abi_lib` macro, and then cached again in libcxx/test/CMakeLists.txt. There, if it is not set to a value, it is by default set to `LIBCXX_LIBRARY_DIR`. However, this new value is not actually cached, because the old (empty) value has been already cached. Use the `FORCE` CMake flag so that it is saved to the cache. This should not break anything, because the code changed here previously had no effect, when it should have. Reviewers: jroelofs, bcraig, ldionne, EricWF, mclow.lists, vvereschaka, eastig Reviewed By: vvereschaka Subscribers: mgorny, christof, dexonsmith, libcxx-commits Tags: #libc Differential Revision: https://reviews.llvm.org/D69169
2020-01-10 17:54:49 +08:00
"The path to libc++abi library." FORCE)
Framework to allow testing of static libc++abi These changes make linking against static libraries more explicit. Instead of using -lc++ and -lc++abi in the tests, an absolute path to the library is provided instead. The choices of shared vs. static, and the choices of library paths for both libcxx and libcxxabi needed to be exchanged for this to work. In other words, libcxx tests need to know the library path of libcxxabi, and whether libcxxabi is a static or shared library. Some Mac specific logic for testing against libc++abi had to be moved from libcxxabi's config.py, as it was overriding choices made in libcxx's config.py. That logic is now in libcxx's target_info.py. Testing a static libcxx on Linux will now automatically link in librt most of the time. Previously, lots of pthread tests would fail because of an unresolved clock_gettime. http://reviews.llvm.org/D16544 llvm-svn: 266730
2016-04-19 20:49:05 +08:00
endif()
Reapply working parts of CMake cleanup. This patch adds the working parts of r243503. The difference with this patch is that it doesn't include the HandleLLVMOptions.cmake file. llvm-svn: 243698
2015-07-31 06:30:34 +08:00
set(LIBCXX_TARGET_INFO "libcxx.test.target_info.LocalTI" CACHE STRING
"TargetInfo to use when setting up test environment.")
set(LIBCXX_EXECUTOR "None" CACHE STRING
"Executor to use when running tests.")
set(AUTO_GEN_COMMENT "## Autogenerated by libcxx configuration.\n# Do not edit!")
Rename cxx-benchmark-unittests target and convert to LIT. This patch renames the cxx-benchmark-unittests to check-cxx-benchmarks and converts the target to use LIT in order to make the tests run faster and provide better output. In particular this runs each benchmark in a suite one by one, allowing more parallelism while ensuring output isn't garbage with multiple threads. Additionally, it adds the CMake flag '-DLIBCXX_BENCHMARK_TEST_ARGS=<list>' to specify what options are passed when running the benchmarks. llvm-svn: 346888
2018-11-15 04:38:46 +08:00
if (NOT DEFINED LIBCXX_TEST_DEPS)
message(FATAL_ERROR "Expected LIBCXX_TEST_DEPS to be defined")
[libcxx] Introduce an externally-threaded libc++ variant. This patch further decouples libc++ from pthread, allowing libc++ to be built against other threading systems. There are two main use cases: - Building libc++ against a thread library other than pthreads. - Building libc++ with an "external" thread API, allowing a separate library to provide the implementation of that API. The two use cases are quite similar, the second one being sligtly more de-coupled than the first. The cmake option LIBCXX_HAS_EXTERNAL_THREAD_API enables both kinds of builds. One needs to place an <__external_threading> header file containing an implementation of the "libc++ thread API" declared in the <__threading_support> header. For the second use case, the implementation of the libc++ thread API can delegate to a custom "external" thread API where the implementation of this external API is provided in a seperate library. This mechanism allows toolchain vendors to distribute a build of libc++ with a custom thread-porting-layer API (which is the "external" API above), platform vendors (recipients of the toolchain/libc++) are then required to provide their implementation of this API to be linked with (end-user) C++ programs. Note that the second use case still requires establishing the basic types that get passed between the external thread library and the libc++ library (e.g. __libcpp_mutex_t). These cannot be opaque pointer types (libc++ sources won't compile otherwise). It should also be noted that the second use case can have a slight performance penalty; as all the thread constructs need to cross a library boundary through an additional function call. When the header <__external_threading> is omitted, libc++ is built with the "libc++ thread API" (declared in <__threading_support>) as the "external" thread API (basic types are pthread based). An implementation (pthread based) of this API is provided in test/support/external_threads.cpp, which is built into a separate DSO and linked in when running the libc++ test suite. A test run therefore demonstrates the second use case (less the intermediate custom API). Differential revision: https://reviews.llvm.org/D21968 Reviewers: bcraig, compnerd, EricWF, mclow.lists llvm-svn: 281179
2016-09-12 05:46:40 +08:00
endif()
Add an off-by-default option to enable testing for gdb pretty printers. Summary: The current version of the pretty printers are not python3 compatible, so turn them off by default until sufficiently improved. Reviewers: MaskRay, tamur Subscribers: mgorny, christof, llvm-commits Tags: #llvm Differential Revision: https://reviews.llvm.org/D68477 llvm-svn: 373796
2019-10-05 06:15:28 +08:00
# Turn this on by default when the pretty printers are python3
# compatible.
if(LIBCXX_TEST_GDB_PRETTY_PRINTERS)
find_program(LIBCXX_GDB gdb)
if (LIBCXX_GDB)
set(LIBCXX_GDB "${LIBCXX_GDB}")
message(STATUS "gdb found: ${LIBCXX_GDB}")
else()
message(STATUS "gdb not found. Disabling dependent tests.")
endif()
Add testing infrastructure to check if gdb is available for testing. Reviewers: echristo, EricWF Subscribers: mgorny, christof, llvm-commits Tags: #llvm Differential Revision: https://reviews.llvm.org/D67194 llvm-svn: 371120
2019-09-06 04:44:08 +08:00
endif()
Generate the test configuration even when LIBCXX_INCLUDE_TESTS=OFF. This patch changes the CMake configuration so that it always generates the test/lit.site.cfg file, even when testing is disabled. This allows users to test libc++ without requiring them to have a full LLVM checkout on their machine. llvm-svn: 296685
2017-03-02 05:53:30 +08:00
if (LIBCXX_INCLUDE_TESTS)
Include AddLLVM needed for tests in the right context AddLLVM is needed for several functions that are used in tests and as such needs to be included from the right context which previously wasn't the case. Differential Revision: https://reviews.llvm.org/D40280 llvm-svn: 319515
2017-12-01 11:16:50 +08:00
include(AddLLVM) # for configure_lit_site_cfg and add_lit_testsuit
configure_lit_site_cfg(
${CMAKE_CURRENT_SOURCE_DIR}/lit.site.cfg.in
${CMAKE_CURRENT_BINARY_DIR}/lit.site.cfg)
Generate the test configuration even when LIBCXX_INCLUDE_TESTS=OFF. This patch changes the CMake configuration so that it always generates the test/lit.site.cfg file, even when testing is disabled. This allows users to test libc++ without requiring them to have a full LLVM checkout on their machine. llvm-svn: 296685
2017-03-02 05:53:30 +08:00
add_lit_testsuite(check-cxx
"Running libcxx tests"
${CMAKE_CURRENT_BINARY_DIR}
DEPENDS cxx ${LIBCXX_TEST_DEPS})
Reapply working parts of CMake cleanup. This patch adds the working parts of r243503. The difference with this patch is that it doesn't include the HandleLLVMOptions.cmake file. llvm-svn: 243698
2015-07-31 06:30:34 +08:00
Generate the test configuration even when LIBCXX_INCLUDE_TESTS=OFF. This patch changes the CMake configuration so that it always generates the test/lit.site.cfg file, even when testing is disabled. This allows users to test libc++ without requiring them to have a full LLVM checkout on their machine. llvm-svn: 296685
2017-03-02 05:53:30 +08:00
add_custom_target(check-libcxx DEPENDS check-cxx)
endif()
[CMake] Be more consistent about naming targets and components Summary: The point of this patch is to have a consistent convention for naming build, check and install targets so that the targets can be constructed from the project name. This change renames a bunch of CMake components and targets from libcxx to cxx. For each renamed target I've added a convenience target that matches the old target name and depends on the new target. This will preserve function of the old targets so that the change doesn't break the world. We can evaluate if it is worth removing the extra targets later. Reviewers: EricWF Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D23699 llvm-svn: 279675
2016-08-25 06:17:06 +08:00
Reapply working parts of CMake cleanup. This patch adds the working parts of r243503. The difference with this patch is that it doesn't include the HandleLLVMOptions.cmake file. llvm-svn: 243698
2015-07-31 06:30:34 +08:00
if (LIBCXX_GENERATE_COVERAGE)
include(CodeCoverage)
set(output_dir "${CMAKE_CURRENT_BINARY_DIR}/coverage")
fix test coverage capture dirs llvm-svn: 297555
2017-03-11 13:28:09 +08:00
set(capture_dirs
"${LIBCXX_LIB_CMAKEFILES_DIR}/cxx_objects.dir/"
"${LIBCXX_LIB_CMAKEFILES_DIR}/cxx.dir/"
"${LIBCXX_LIB_CMAKEFILES_DIR}/cxx_experimental.dir/"
"${CMAKE_CURRENT_BINARY_DIR}")
Reapply working parts of CMake cleanup. This patch adds the working parts of r243503. The difference with this patch is that it doesn't include the HandleLLVMOptions.cmake file. llvm-svn: 243698
2015-07-31 06:30:34 +08:00
set(extract_dirs "${LIBCXX_SOURCE_DIR}/include;${LIBCXX_SOURCE_DIR}/src")
setup_lcov_test_target_coverage("cxx" "${output_dir}" "${capture_dirs}" "${extract_dirs}")
Add CMake build and fix major Linux blockers. llvm-svn: 121510
2010-12-11 03:47:54 +08:00
endif()
Add dummy CMake target for *.pass.cpp tests when LIBCXX_CONFIGURE_IDE=ON. In order for IDE's like CLion to correctly parse and highlight the tests it needs to know roughly how to build them. This patch adds a dummy CMake target for each/all of the .pass.cpp tests in the test suite to solve this problem. The target is only created when LIBCXX_CONFIGURE_IDE=ON, so it shouldn't affect most users. Originally I wasn't sure that this change deserved to live upstream, but it's quite frustrating to edit libc++ tests using CLion or Visual Studio without it, in particular the filesystem tests which rely heavily on macros. Even though the change should have no effect on non-IDE users/configurations I decided to commit it upstream with the hopes it will benefit somebody other than me. llvm-svn: 307118
2017-07-05 11:50:03 +08:00
if (LIBCXX_CONFIGURE_IDE)
# Create dummy targets for each of the tests in the test suite, this allows
# IDE's such as CLion to correctly highlight the tests because it knows
# roughly what include paths/compile flags/macro definitions are needed.
include_directories(support)
file(GLOB_RECURSE LIBCXX_TESTS ${CMAKE_CURRENT_SOURCE_DIR}/*.pass.cpp)
file(GLOB LIBCXX_TEST_HEADERS ${CMAKE_CURRENT_SOURCE_DIR}/support/*)
file(GLOB_RECURSE LIBCXX_HEADERS ${CMAKE_CURRENT_SOURCE_DIR}/../include/*)
add_executable(libcxx_test_objects EXCLUDE_FROM_ALL
${LIBCXX_TESTS} ${LIBCXX_TEST_HEADERS} ${LIBCXX_HEADERS})
add_dependencies(libcxx_test_objects cxx)
Attempt to unbreak *all the bots* The bots were failing to build the cxx_filesystem target, so the tests were failing. Though this does lead me to wonder how it was ever working with c++experimental. llvm-svn: 338095
2018-07-27 11:42:58 +08:00
set(STATIC_ROOT ${LIBCXX_SOURCE_DIR}/test/std/input.output/filesystems/Inputs/static_test_env)
Add dummy CMake target for *.pass.cpp tests when LIBCXX_CONFIGURE_IDE=ON. In order for IDE's like CLion to correctly parse and highlight the tests it needs to know roughly how to build them. This patch adds a dummy CMake target for each/all of the .pass.cpp tests in the test suite to solve this problem. The target is only created when LIBCXX_CONFIGURE_IDE=ON, so it shouldn't affect most users. Originally I wasn't sure that this change deserved to live upstream, but it's quite frustrating to edit libc++ tests using CLion or Visual Studio without it, in particular the filesystem tests which rely heavily on macros. Even though the change should have no effect on non-IDE users/configurations I decided to commit it upstream with the hopes it will benefit somebody other than me. llvm-svn: 307118
2017-07-05 11:50:03 +08:00
add_definitions(-DLIBCXX_FILESYSTEM_STATIC_TEST_ROOT="${STATIC_ROOT}")
set(DYNAMIC_ROOT ${LIBCXX_BINARY_DIR}/test/filesystem/Output/dynamic_env)
add_definitions(-DLIBCXX_FILESYSTEM_DYNAMIC_TEST_ROOT="${DYNAMIC_ROOT}")
set(DYNAMIC_HELPER "python ${LIBCXX_SOURCE_DIR}/test/support/filesystem_dynamic_test_helper.py ")
add_definitions(-DLIBCXX_FILESYSTEM_DYNAMIC_TEST_HELPER="${DYNAMIC_HELPER}")
split_list(LIBCXX_COMPILE_FLAGS)
split_list(LIBCXX_LINK_FLAGS)
set_target_properties(libcxx_test_objects
PROPERTIES
COMPILE_FLAGS "${LIBCXX_COMPILE_FLAGS}"
LINK_FLAGS "${LIBCXX_LINK_FLAGS}"
EXCLUDE_FROM_ALL ON
)
endif()