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

83 lines
2.6 KiB
CMake
Raw Normal View History

[CMake] Get libcxx building under LLVM/runtimes Summary: The new LLVM runtimes build directory requires some basic conventions across the runtime projects. These changes make libcxx build under the runtimes subdirectory. The general idea of the changes is that the runtimes subdirectory requires some conventions to be consistent across runtime projects. I expect to have a few more small patches that build on this to tie up check targets and other things useful in development workflows. Summary of changes in this patch: * Renamed variable LLVM_CONFIG -> LLVM_CONFIG_PATH * Renamed variable LIBCXX_BUILT_STANDALONE -> LIBCXX_STANDALONE_BUILD * Add an include of AddLLVM in the tests subdirectory for add_lit_testsuite. Reviewers: EricWF Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D23696 llvm-svn: 279151
2016-08-19 05:31:51 +08:00
include(AddLLVM) # for add_lit_testsuite
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.")
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)
Add Filesystem TS -- Complete Add the completed std::experimental::filesystem implementation and tests. The implementation supports C++11 or newer. The TS is built as part of 'libc++experimental.a'. Users of the TS need to manually link this library. Building and testing the TS can be disabled using the CMake option '-DLIBCXX_ENABLE_FILESYSTEM=OFF'. Currently 'libc++experimental.a' is not installed by default. To turn on the installation of the library use '-DLIBCXX_INSTALL_EXPERIMENTAL_LIBRARY=ON'. llvm-svn: 273034
2016-06-18 03:46:40 +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_ENABLE_RTTI)
pythonize_bool(LIBCXX_ENABLE_SHARED)
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)
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)
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
"The path to libc++abi library.")
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!")
configure_file(
${CMAKE_CURRENT_SOURCE_DIR}/lit.site.cfg.in
${CMAKE_CURRENT_BINARY_DIR}/lit.site.cfg
@ONLY)
[libcxx] Add build/test support for the externally threaded libc++abi variant Differential revision: https://reviews.llvm.org/D27576 Reviewers: EricWF llvm-svn: 290889
2017-01-03 20:59:50 +08:00
set(LIBCXX_TEST_DEPS "")
Make check-libcxx dependant on libc++experimental if present. llvm-svn: 268451
2016-05-04 05:58:07 +08:00
if (LIBCXX_ENABLE_EXPERIMENTAL_LIBRARY)
[libcxx] Add build/test support for the externally threaded libc++abi variant Differential revision: https://reviews.llvm.org/D27576 Reviewers: EricWF llvm-svn: 290889
2017-01-03 20:59:50 +08:00
set(LIBCXX_TEST_DEPS cxx_experimental)
Make check-libcxx dependant on libc++experimental if present. llvm-svn: 268451
2016-05-04 05:58:07 +08:00
endif()
Fix cmake dependency for the external-thread-library variant. NFC. llvm-svn: 296338
2017-02-27 21:19:25 +08:00
if (LIBCXX_BUILD_EXTERNAL_THREAD_LIBRARY)
[libcxx] Add build/test support for the externally threaded libc++abi variant Differential revision: https://reviews.llvm.org/D27576 Reviewers: EricWF llvm-svn: 290889
2017-01-03 20:59:50 +08:00
list(APPEND LIBCXX_TEST_DEPS cxx_external_threads)
[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()
[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
add_lit_testsuite(check-cxx
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
"Running libcxx tests"
${CMAKE_CURRENT_BINARY_DIR}
[libcxx] Add build/test support for the externally threaded libc++abi variant Differential revision: https://reviews.llvm.org/D27576 Reviewers: EricWF llvm-svn: 290889
2017-01-03 20:59:50 +08:00
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
[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
add_custom_target(check-libcxx DEPENDS check-cxx)
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")
Generate code coverage for experimental libraries llvm-svn: 268887
2016-05-09 07:08:50 +08:00
set(capture_dirs "${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()